From c554046381f485e1049a9c77c6c2c16e6b46e23c Mon Sep 17 00:00:00 2001 From: T45K Date: Sun, 29 Dec 2024 00:52:06 +0900 Subject: [PATCH 1/5] update gradle wrapper --- gradle/wrapper/gradle-wrapper.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index a441313..cea7a79 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME From 104bd7ce1665672871e5dc14d3ffa860c1a65539 Mon Sep 17 00:00:00 2001 From: T45K Date: Sun, 29 Dec 2024 00:52:30 +0900 Subject: [PATCH 2/5] reformat README --- README.md | 56 +++++++++++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 24 deletions(-) diff --git a/README.md b/README.md index 55e6a2d..b1230f6 100644 --- a/README.md +++ b/README.md @@ -4,47 +4,55 @@ FSE '21 paper implementation ([preprint](./camera-ready.pdf))
DOI of submitted version executable file of NIL is `10.5281/zenodo.4492665`. # NIL + NIL is a clone detector using N-gram, Inverted index, and LCS. NIL provides scalable large-variance clone detection. ## Requirements + - JDK 21+ ## Install & Usage + - Clone this repository (`git clone https://github.com/kusumotolab/NIL`) - Move into NIL's directory (`cd NIL`) and build NIL (`./gradlew ShadowJar`) - Run NIL (`java -jar ./build/libs/NIL-all.jar [options]`) - Check the result file - - If you didn't specify `-bce` option, the format is `/path/to/file_A,start_line_A,end_line_A,/path/to/file_B,start_line_B,end_line_B`. - - If you specified `-bce` option, the format is `dir_A,file_A,start_line_A,end_line_A,dir_B,file_B,start_line_B,end_line_B` + - If you didn't specify `-bce` option, the format is + `/path/to/file_A,start_line_A,end_line_A,/path/to/file_B,start_line_B,end_line_B`. + - If you specified `-bce` option, the format is + `dir_A,file_A,start_line_A,end_line_A,dir_B,file_B,start_line_B,end_line_B` ## Options -|Name|Description|Default| -|:--:|:--|:--:| -|`-s`,`--src`|Input source directory. You must specify the target dir.|None| -|`-mil`,`--min-line`|Minimum number of lines that a code fragment must be to be treated as a clone.|`6`| -|`-mit`,`--min-token`|Minimum number of tokens that a code fragment must be to be treated as a clone.|`50`| -|`-n`,`--n-gram`|N for N-gram.|`5`| -|`-p`,`--partition-size`|The number of partitions.|`10`| -|`-f`,`--filtration-threshold`|Threshold used in the filtration phase (%).|`10`| -|`-v`,`--verification-threshold`|Threshold used in the verificatioin phase (%).|`70`| -|`-o`,`--output`|Output file name.|`result_{n}_{f}_{v}.csv`| -|`-t`,`--threads`|The number of threads used for parallel execution (both the *Preprocess* and *Clone detection* phases)|all threads| -|`-l`,`--language`|[Target language](#Languages)|`java`| -|`-bce`,`--bigcloneeval`|If you specify `-bce` option, NIL outputs result file feasible to BigCloneEval.|not specified| -|`-mif`,`--mutationinjectionframework`|If you specify `-mif` option, NIL outputs nothing except for the output file name as standard output.|not specified| + +| Name | Description | Default | +|:-------------------------------------:|:-------------------------------------------------------------------------------------------------------|:------------------------:| +| `-s`,`--src` | Input source directory. You must specify the target dir. | None | +| `-mil`,`--min-line` | Minimum number of lines that a code fragment must be to be treated as a clone. | `6` | +| `-mit`,`--min-token` | Minimum number of tokens that a code fragment must be to be treated as a clone. | `50` | +| `-n`,`--n-gram` | N for N-gram. | `5` | +| `-p`,`--partition-size` | The number of partitions. | `10` | +| `-f`,`--filtration-threshold` | Threshold used in the filtration phase (%). | `10` | +| `-v`,`--verification-threshold` | Threshold used in the verificatioin phase (%). | `70` | +| `-o`,`--output` | Output file name. | `result_{n}_{f}_{v}.csv` | +| `-t`,`--threads` | The number of threads used for parallel execution (both the *Preprocess* and *Clone detection* phases) | all threads | +| `-l`,`--language` | [Target language](#Languages) | `java` | +| `-bce`,`--bigcloneeval` | If you specify `-bce` option, NIL outputs result file feasible to BigCloneEval. | not specified | +| `-mif`,`--mutationinjectionframework` | If you specify `-mif` option, NIL outputs nothing except for the output file name as standard output. | not specified | ## Languages -|Name|Option|Extension| -|:--:|:--:|:--:| -|Java|`java`|`.java`| -|C|`c`|`.c`,`.h`| -|C++|`cpp`|`.cpp`,`.hpp`| -|C#|`cs`,`csharp`|`.cs`| -|Python|`py`,`python`|`.py`| -|Kotlin|`kt`,`kotlin`|`.kt`| + +| Name | Option | Extension | +|:------:|:-------------:|:-------------:| +| Java | `java` | `.java` | +| C | `c` | `.c`,`.h` | +| C++ | `cpp` | `.cpp`,`.hpp` | +| C# | `cs`,`csharp` | `.cs` | +| Python | `py`,`python` | `.py` | +| Kotlin | `kt`,`kotlin` | `.kt` | If you execute NIL on 250-MLOC codebase, we recommend `-p` option to 135. ## Experiments, datasets, and baseline tools + - Please refer to [EXPERIMENTS.md](./EXPERIMENTS.md) From c5a7dff3556f42fc7fa9fd2245c119e3024543a9 Mon Sep 17 00:00:00 2001 From: T45K Date: Sun, 29 Dec 2024 01:41:12 +0900 Subject: [PATCH 3/5] update py lang version --- build.gradle.kts | 12 +- clone_pairs | 1 + code_blocks | 2 + result_5_10_70.csv | 1 + src/main/antlr/KotlinLexer.g4 | 514 + src/main/antlr/KotlinParser.g4 | 819 + src/main/antlr/Python3.g4 | 1155 - src/main/antlr/PythonLexer.g4 | 1362 + src/main/antlr/PythonParser.g4 | 884 + src/main/antlr/UnicodeClasses.g4 | 1658 + src/main/java/CPP14Lexer.interp | 478 + src/main/java/CPP14Lexer.java | 1158 + .../sdl/nil/parser/cpp => }/CPP14Lexer.tokens | 0 src/main/java/CPP14Parser.interp | 490 + .../sdl/nil/parser/cpp => }/CPP14Parser.java | 2615 +- .../nil/parser/cpp => }/CPP14Parser.tokens | 0 .../cpp => }/CPP14ParserBaseListener.java | 5 +- .../parser/cpp => }/CPP14ParserListener.java | 6 +- src/main/java/CSharpLexer.interp | 665 + src/main/java/CSharpLexer.java | 1884 ++ .../sdl/nil/parser/cs => }/CSharpLexer.tokens | 0 src/main/java/CSharpParser.interp | 625 + src/main/java/CSharpParser.java | 25249 ++++++++++++++++ .../nil/parser/cs => }/CSharpParser.tokens | 0 .../cs => }/CSharpParserBaseListener.java | 3 +- .../parser/cs => }/CSharpParserListener.java | 2 +- src/main/java/KotlinLexer.interp | 721 + src/main/java/KotlinLexer.java | 2337 ++ src/main/java/KotlinLexer.tokens | 288 + src/main/java/KotlinParser.interp | 498 + src/main/java/KotlinParser.java | 19417 ++++++++++++ src/main/java/KotlinParser.tokens | 288 + src/main/java/KotlinParserBaseListener.java | 2695 ++ src/main/java/KotlinParserListener.java | 2067 ++ src/main/java/PythonLexer.interp | 378 + src/main/java/PythonLexer.java | 1209 + src/main/java/PythonLexer.tokens | 178 + src/main/java/PythonLexerBase.java | 402 + src/main/java/PythonParser.interp | 403 + src/main/java/PythonParser.java | 18693 ++++++++++++ src/main/java/PythonParser.tokens | 178 + src/main/java/PythonParserBase.java | 17 + src/main/java/PythonParserBaseListener.java | 3613 +++ src/main/java/PythonParserListener.java | 2781 ++ src/main/java/UnicodeClasses.interp | 38 + src/main/java/UnicodeClasses.java | 464 + src/main/java/UnicodeClasses.tokens | 7 + .../sdl/nil/parser/cpp/CPP14Lexer.interp | 478 - .../sdl/nil/parser/cpp/CPP14Lexer.java | 781 - .../sdl/nil/parser/cpp/CPP14Parser.interp | 490 - .../sdl/nil/parser/cs/CSharpLexer.interp | 665 - .../sdl/nil/parser/cs/CSharpLexer.java | 1332 - .../sdl/nil/parser/cs/CSharpParser.interp | 625 - .../sdl/nil/parser/cs/CSharpParser.java | 20418 ------------- .../sdl/nil/parser/kotlin/KotlinLexer.interp | 666 - .../sdl/nil/parser/kotlin/KotlinLexer.java | 1390 - .../sdl/nil/parser/kotlin/KotlinLexer.tokens | 289 - .../sdl/nil/parser/kotlin/KotlinParser.interp | 515 - .../sdl/nil/parser/kotlin/KotlinParser.java | 18386 ----------- .../sdl/nil/parser/kotlin/KotlinParser.tokens | 289 - .../kotlin/KotlinParserBaseListener.java | 2030 -- .../parser/kotlin/KotlinParserListener.java | 1669 - .../sdl/nil/parser/python/Python3.interp | 295 - .../sdl/nil/parser/python/Python3.tokens | 181 - .../parser/python/Python3BaseListener.java | 1596 - .../sdl/nil/parser/python/Python3Lexer.interp | 335 - .../sdl/nil/parser/python/Python3Lexer.java | 803 - .../sdl/nil/parser/python/Python3Lexer.tokens | 179 - .../nil/parser/python/Python3Listener.java | 1213 - .../sdl/nil/parser/python/Python3Parser.java | 8987 ------ .../usecase/preprocess/cpp/CPPTransformer.kt | 6 +- .../preprocess/cs/CSharpTransformer.kt | 6 +- .../preprocess/kotlin/KotlinTransformer.kt | 6 +- .../preprocess/python/PythonTransformer.kt | 19 +- 74 files changed, 94172 insertions(+), 65737 deletions(-) create mode 100644 clone_pairs create mode 100644 code_blocks create mode 100644 result_5_10_70.csv create mode 100644 src/main/antlr/KotlinLexer.g4 create mode 100644 src/main/antlr/KotlinParser.g4 delete mode 100644 src/main/antlr/Python3.g4 create mode 100644 src/main/antlr/PythonLexer.g4 create mode 100644 src/main/antlr/PythonParser.g4 create mode 100644 src/main/antlr/UnicodeClasses.g4 create mode 100644 src/main/java/CPP14Lexer.interp create mode 100644 src/main/java/CPP14Lexer.java rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cpp => }/CPP14Lexer.tokens (100%) create mode 100644 src/main/java/CPP14Parser.interp rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cpp => }/CPP14Parser.java (81%) rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cpp => }/CPP14Parser.tokens (100%) rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cpp => }/CPP14ParserBaseListener.java (99%) rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cpp => }/CPP14ParserListener.java (99%) create mode 100644 src/main/java/CSharpLexer.interp create mode 100644 src/main/java/CSharpLexer.java rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cs => }/CSharpLexer.tokens (100%) create mode 100644 src/main/java/CSharpParser.interp create mode 100644 src/main/java/CSharpParser.java rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cs => }/CSharpParser.tokens (100%) rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cs => }/CSharpParserBaseListener.java (99%) rename src/main/java/{jp/ac/osaka_u/sdl/nil/parser/cs => }/CSharpParserListener.java (99%) create mode 100644 src/main/java/KotlinLexer.interp create mode 100644 src/main/java/KotlinLexer.java create mode 100644 src/main/java/KotlinLexer.tokens create mode 100644 src/main/java/KotlinParser.interp create mode 100644 src/main/java/KotlinParser.java create mode 100644 src/main/java/KotlinParser.tokens create mode 100644 src/main/java/KotlinParserBaseListener.java create mode 100644 src/main/java/KotlinParserListener.java create mode 100644 src/main/java/PythonLexer.interp create mode 100644 src/main/java/PythonLexer.java create mode 100644 src/main/java/PythonLexer.tokens create mode 100644 src/main/java/PythonLexerBase.java create mode 100644 src/main/java/PythonParser.interp create mode 100644 src/main/java/PythonParser.java create mode 100644 src/main/java/PythonParser.tokens create mode 100644 src/main/java/PythonParserBase.java create mode 100644 src/main/java/PythonParserBaseListener.java create mode 100644 src/main/java/PythonParserListener.java create mode 100644 src/main/java/UnicodeClasses.interp create mode 100644 src/main/java/UnicodeClasses.java create mode 100644 src/main/java/UnicodeClasses.tokens delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.tokens delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.tokens delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserBaseListener.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserListener.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.tokens delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3BaseListener.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.interp delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.tokens delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Listener.java delete mode 100644 src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Parser.java diff --git a/build.gradle.kts b/build.gradle.kts index 097de4d..54c78ff 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,12 +1,16 @@ plugins { kotlin("jvm") version "2.0.0" id("com.github.johnrengelman.shadow") version "8.1.1" - id("antlr") + + antlr application } -java.sourceCompatibility = JavaVersion.VERSION_21 +java { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 +} repositories { mavenCentral() @@ -29,7 +33,7 @@ dependencies { testImplementation("org.jetbrains.kotlin:kotlin-test-junit") // Use ANTLR - antlr("org.antlr:antlr4:4.9") + antlr("org.antlr:antlr4:4.13.2") } application { @@ -37,7 +41,9 @@ application { } tasks.generateGrammarSource { + // Comment out when generating lexers and parsers from g4 file enabled = false + outputDirectory = file("$projectDir/src/main/java") } tasks.generateTestGrammarSource { diff --git a/clone_pairs b/clone_pairs new file mode 100644 index 0000000..93c12d9 --- /dev/null +++ b/clone_pairs @@ -0,0 +1 @@ +0,1 diff --git a/code_blocks b/code_blocks new file mode 100644 index 0000000..eecdb02 --- /dev/null +++ b/code_blocks @@ -0,0 +1,2 @@ +/Users/t45k/prog/NIL/src/test/resources/examples/FizzBuzz.py,1,13 +/Users/t45k/prog/NIL/src/test/resources/examples/FizzBuzz.py,13,24 diff --git a/result_5_10_70.csv b/result_5_10_70.csv new file mode 100644 index 0000000..f77c657 --- /dev/null +++ b/result_5_10_70.csv @@ -0,0 +1 @@ +examples,FizzBuzz.py,1,13,examples,FizzBuzz.py,13,24 diff --git a/src/main/antlr/KotlinLexer.g4 b/src/main/antlr/KotlinLexer.g4 new file mode 100644 index 0000000..430e6a9 --- /dev/null +++ b/src/main/antlr/KotlinLexer.g4 @@ -0,0 +1,514 @@ +/** + * Kotlin Grammar for ANTLR v4 + * + * Based on: + * http://jetbrains.github.io/kotlin-spec/#_grammars_and_parsing + * and + * http://kotlinlang.org/docs/reference/grammar.html + * + * Tested on + * https://github.com/JetBrains/kotlin/tree/master/compiler/testData/psi + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true + +lexer grammar KotlinLexer; + +import UnicodeClasses; + +ShebangLine: '#!' ~[\u000A\u000D]* -> channel(HIDDEN); + +DelimitedComment: '/*' ( DelimitedComment | .)*? '*/' -> channel(HIDDEN); + +LineComment: '//' ~[\u000A\u000D]* -> channel(HIDDEN); + +WS: [\u0020\u0009\u000C] -> skip; + +NL: '\u000A' | '\u000D' '\u000A'; + +//SEPARATORS & OPERATIONS + +RESERVED : '...'; +DOT : '.'; +COMMA : ','; +LPAREN : '(' -> pushMode(Inside); +RPAREN : ')'; +LSQUARE : '[' -> pushMode(Inside); +RSQUARE : ']'; +LCURL : '{'; +RCURL : '}'; +MULT : '*'; +MOD : '%'; +DIV : '/'; +ADD : '+'; +SUB : '-'; +INCR : '++'; +DECR : '--'; +CONJ : '&&'; +DISJ : '||'; +EXCL : '!'; +COLON : ':'; +SEMICOLON : ';'; +ASSIGNMENT : '='; +ADD_ASSIGNMENT : '+='; +SUB_ASSIGNMENT : '-='; +MULT_ASSIGNMENT : '*='; +DIV_ASSIGNMENT : '/='; +MOD_ASSIGNMENT : '%='; +ARROW : '->'; +DOUBLE_ARROW : '=>'; +RANGE : '..'; +COLONCOLON : '::'; +Q_COLONCOLON : '?::'; +DOUBLE_SEMICOLON : ';;'; +HASH : '#'; +AT : '@'; +QUEST : '?'; +ELVIS : '?:'; +LANGLE : '<'; +RANGLE : '>'; +LE : '<='; +GE : '>='; +EXCL_EQ : '!='; +EXCL_EQEQ : '!=='; +AS_SAFE : 'as?'; +EQEQ : '=='; +EQEQEQ : '==='; +SINGLE_QUOTE : '\''; + +//KEYWORDS + +RETURN_AT : 'return@' Identifier; +CONTINUE_AT : 'continue@' Identifier; +BREAK_AT : 'break@' Identifier; + +FILE : '@file'; +PACKAGE : 'package'; +IMPORT : 'import'; +CLASS : 'class'; +INTERFACE : 'interface'; +FUN : 'fun'; +OBJECT : 'object'; +VAL : 'val'; +VAR : 'var'; +TYPE_ALIAS : 'typealias'; +CONSTRUCTOR : 'constructor'; +BY : 'by'; +COMPANION : 'companion'; +INIT : 'init'; +THIS : 'this'; +SUPER : 'super'; +TYPEOF : 'typeof'; +WHERE : 'where'; +IF : 'if'; +ELSE : 'else'; +WHEN : 'when'; +TRY : 'try'; +CATCH : 'catch'; +FINALLY : 'finally'; +FOR : 'for'; +DO : 'do'; +WHILE : 'while'; +THROW : 'throw'; +RETURN : 'return'; +CONTINUE : 'continue'; +BREAK : 'break'; +AS : 'as'; +IS : 'is'; +IN : 'in'; +NOT_IS : '!is' (WS | NL)+; +NOT_IN : '!in' (WS | NL)+; +OUT : 'out'; +FIELD : '@field'; +PROPERTY : '@property'; +GET : '@get'; +SET : '@set'; +GETTER : 'get'; +SETTER : 'set'; +RECEIVER : '@receiver'; +PARAM : '@param'; +SETPARAM : '@setparam'; +DELEGATE : '@delegate'; +DYNAMIC : 'dynamic'; + +//MODIFIERS + +PUBLIC : 'public'; +PRIVATE : 'private'; +PROTECTED : 'protected'; +INTERNAL : 'internal'; +ENUM : 'enum'; +SEALED : 'sealed'; +ANNOTATION : 'annotation'; +DATA : 'data'; +INNER : 'inner'; +TAILREC : 'tailrec'; +OPERATOR : 'operator'; +INLINE : 'inline'; +INFIX : 'infix'; +EXTERNAL : 'external'; +SUSPEND : 'suspend'; +OVERRIDE : 'override'; +ABSTRACT : 'abstract'; +FINAL : 'final'; +OPEN : 'open'; +CONST : 'const'; +LATEINIT : 'lateinit'; +VARARG : 'vararg'; +NOINLINE : 'noinline'; +CROSSINLINE : 'crossinline'; +REIFIED : 'reified'; + +// + +QUOTE_OPEN : '"' -> pushMode(LineString); +TRIPLE_QUOTE_OPEN : '"""' -> pushMode(MultiLineString); + +RealLiteral: FloatLiteral | DoubleLiteral; + +FloatLiteral: (DoubleLiteral | IntegerLiteral) [fF]; + +DoubleLiteral: + ((DecDigitNoZero DecDigit* | '0')? '.' | (DecDigitNoZero (DecDigit | '_')* DecDigit)? '.') ( + DecDigit+ + | DecDigit (DecDigit | '_')+ DecDigit + | DecDigit+ [eE] ('+' | '-')? DecDigit+ + | DecDigit+ [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit + | DecDigit (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit+ + | DecDigit (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit + ) +; + +LongLiteral: (IntegerLiteral | HexLiteral | BinLiteral) 'L'; + +IntegerLiteral: + ( + '0' + | DecDigitNoZero DecDigit* + | DecDigitNoZero (DecDigit | '_')+ DecDigit + | DecDigitNoZero DecDigit* [eE] ('+' | '-')? DecDigit+ + | DecDigitNoZero DecDigit* [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit + | DecDigitNoZero (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit+ + | DecDigitNoZero (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit + ) +; + +fragment DecDigit: UNICODE_CLASS_ND; + +fragment DecDigitNoZero: UNICODE_CLASS_ND_NoZeros; + +fragment UNICODE_CLASS_ND_NoZeros: + '\u0031' ..'\u0039' + | '\u0661' ..'\u0669' + | '\u06f1' ..'\u06f9' + | '\u07c1' ..'\u07c9' + | '\u0967' ..'\u096f' + | '\u09e7' ..'\u09ef' + | '\u0a67' ..'\u0a6f' + | '\u0ae7' ..'\u0aef' + | '\u0b67' ..'\u0b6f' + | '\u0be7' ..'\u0bef' + | '\u0c67' ..'\u0c6f' + | '\u0ce7' ..'\u0cef' + | '\u0d67' ..'\u0d6f' + | '\u0de7' ..'\u0def' + | '\u0e51' ..'\u0e59' + | '\u0ed1' ..'\u0ed9' + | '\u0f21' ..'\u0f29' + | '\u1041' ..'\u1049' + | '\u1091' ..'\u1099' + | '\u17e1' ..'\u17e9' + | '\u1811' ..'\u1819' + | '\u1947' ..'\u194f' + | '\u19d1' ..'\u19d9' + | '\u1a81' ..'\u1a89' + | '\u1a91' ..'\u1a99' + | '\u1b51' ..'\u1b59' + | '\u1bb1' ..'\u1bb9' + | '\u1c41' ..'\u1c49' + | '\u1c51' ..'\u1c59' + | '\ua621' ..'\ua629' + | '\ua8d1' ..'\ua8d9' + | '\ua901' ..'\ua909' + | '\ua9d1' ..'\ua9d9' + | '\ua9f1' ..'\ua9f9' + | '\uaa51' ..'\uaa59' + | '\uabf1' ..'\uabf9' + | '\uff11' ..'\uff19' +; + +HexLiteral: '0' [xX] HexDigit (HexDigit | '_')*; + +fragment HexDigit: [0-9a-fA-F]; + +BinLiteral: '0' [bB] BinDigit (BinDigit | '_')*; + +fragment BinDigit: [01]; + +BooleanLiteral: 'true' | 'false'; + +NullLiteral: 'null'; + +Identifier: (Letter | '_') (Letter | '_' | DecDigit)* | '`' ~('`')+ '`'; + +LabelReference: '@' Identifier; + +LabelDefinition: Identifier '@'; + +FieldIdentifier: '$' Identifier; + +CharacterLiteral: '\'' (EscapeSeq | .) '\''; + +fragment EscapeSeq: UniCharacterLiteral | EscapedIdentifier; + +fragment UniCharacterLiteral: '\\' 'u' HexDigit HexDigit HexDigit HexDigit; + +fragment EscapedIdentifier: '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | '$'); + +fragment Letter: + UNICODE_CLASS_LL + | UNICODE_CLASS_LM + | UNICODE_CLASS_LO + | UNICODE_CLASS_LT + | UNICODE_CLASS_LU + | UNICODE_CLASS_NL +; + +mode Inside; + +Inside_RPAREN : ')' -> popMode, type(RPAREN); +Inside_RSQUARE : ']' -> popMode, type(RSQUARE); + +Inside_LPAREN : LPAREN -> pushMode(Inside), type(LPAREN); +Inside_LSQUARE : LSQUARE -> pushMode(Inside), type(LSQUARE); + +Inside_LCURL : LCURL -> type(LCURL); +Inside_RCURL : RCURL -> type(RCURL); +Inside_DOT : DOT -> type(DOT); +Inside_COMMA : COMMA -> type(COMMA); +Inside_MULT : MULT -> type(MULT); +Inside_MOD : MOD -> type(MOD); +Inside_DIV : DIV -> type(DIV); +Inside_ADD : ADD -> type(ADD); +Inside_SUB : SUB -> type(SUB); +Inside_INCR : INCR -> type(INCR); +Inside_DECR : DECR -> type(DECR); +Inside_CONJ : CONJ -> type(CONJ); +Inside_DISJ : DISJ -> type(DISJ); +Inside_EXCL : EXCL -> type(EXCL); +Inside_COLON : COLON -> type(COLON); +Inside_SEMICOLON : SEMICOLON -> type(SEMICOLON); +Inside_ASSIGNMENT : ASSIGNMENT -> type(ASSIGNMENT); +Inside_ADD_ASSIGNMENT : ADD_ASSIGNMENT -> type(ADD_ASSIGNMENT); +Inside_SUB_ASSIGNMENT : SUB_ASSIGNMENT -> type(SUB_ASSIGNMENT); +Inside_MULT_ASSIGNMENT : MULT_ASSIGNMENT -> type(MULT_ASSIGNMENT); +Inside_DIV_ASSIGNMENT : DIV_ASSIGNMENT -> type(DIV_ASSIGNMENT); +Inside_MOD_ASSIGNMENT : MOD_ASSIGNMENT -> type(MOD_ASSIGNMENT); +Inside_ARROW : ARROW -> type(ARROW); +Inside_DOUBLE_ARROW : DOUBLE_ARROW -> type(DOUBLE_ARROW); +Inside_RANGE : RANGE -> type(RANGE); +Inside_RESERVED : RESERVED -> type(RESERVED); +Inside_COLONCOLON : COLONCOLON -> type(COLONCOLON); +Inside_Q_COLONCOLON : Q_COLONCOLON -> type(Q_COLONCOLON); +Inside_DOUBLE_SEMICOLON : DOUBLE_SEMICOLON -> type(DOUBLE_SEMICOLON); +Inside_HASH : HASH -> type(HASH); +Inside_AT : AT -> type(AT); +Inside_QUEST : QUEST -> type(QUEST); +Inside_ELVIS : ELVIS -> type(ELVIS); +Inside_LANGLE : LANGLE -> type(LANGLE); +Inside_RANGLE : RANGLE -> type(RANGLE); +Inside_LE : LE -> type(LE); +Inside_GE : GE -> type(GE); +Inside_EXCL_EQ : EXCL_EQ -> type(EXCL_EQ); +Inside_EXCL_EQEQ : EXCL_EQEQ -> type(EXCL_EQEQ); +Inside_NOT_IS : NOT_IS -> type(NOT_IS); +Inside_NOT_IN : NOT_IN -> type(NOT_IN); +Inside_AS_SAFE : AS_SAFE -> type(AS_SAFE); +Inside_EQEQ : EQEQ -> type(EQEQ); +Inside_EQEQEQ : EQEQEQ -> type(EQEQEQ); +Inside_SINGLE_QUOTE : SINGLE_QUOTE -> type(SINGLE_QUOTE); +Inside_QUOTE_OPEN : QUOTE_OPEN -> pushMode(LineString), type(QUOTE_OPEN); +Inside_TRIPLE_QUOTE_OPEN: + TRIPLE_QUOTE_OPEN -> pushMode(MultiLineString), type(TRIPLE_QUOTE_OPEN) +; + +Inside_VAL : VAL -> type(VAL); +Inside_VAR : VAR -> type(VAR); +Inside_OBJECT : OBJECT -> type(OBJECT); +Inside_SUPER : SUPER -> type(SUPER); +Inside_IN : IN -> type(IN); +Inside_OUT : OUT -> type(OUT); +Inside_FIELD : FIELD -> type(FIELD); +Inside_FILE : FILE -> type(FILE); +Inside_PROPERTY : PROPERTY -> type(PROPERTY); +Inside_GET : GET -> type(GET); +Inside_SET : SET -> type(SET); +Inside_RECEIVER : RECEIVER -> type(RECEIVER); +Inside_PARAM : PARAM -> type(PARAM); +Inside_SETPARAM : SETPARAM -> type(SETPARAM); +Inside_DELEGATE : DELEGATE -> type(DELEGATE); +Inside_THROW : THROW -> type(THROW); +Inside_RETURN : RETURN -> type(RETURN); +Inside_CONTINUE : CONTINUE -> type(CONTINUE); +Inside_BREAK : BREAK -> type(BREAK); +Inside_RETURN_AT : RETURN_AT -> type(RETURN_AT); +Inside_CONTINUE_AT : CONTINUE_AT -> type(CONTINUE_AT); +Inside_BREAK_AT : BREAK_AT -> type(BREAK_AT); +Inside_IF : IF -> type(IF); +Inside_ELSE : ELSE -> type(ELSE); +Inside_WHEN : WHEN -> type(WHEN); +Inside_TRY : TRY -> type(TRY); +Inside_CATCH : CATCH -> type(CATCH); +Inside_FINALLY : FINALLY -> type(FINALLY); +Inside_FOR : FOR -> type(FOR); +Inside_DO : DO -> type(DO); +Inside_WHILE : WHILE -> type(WHILE); + +Inside_PUBLIC : PUBLIC -> type(PUBLIC); +Inside_PRIVATE : PRIVATE -> type(PRIVATE); +Inside_PROTECTED : PROTECTED -> type(PROTECTED); +Inside_INTERNAL : INTERNAL -> type(INTERNAL); +Inside_ENUM : ENUM -> type(ENUM); +Inside_SEALED : SEALED -> type(SEALED); +Inside_ANNOTATION : ANNOTATION -> type(ANNOTATION); +Inside_DATA : DATA -> type(DATA); +Inside_INNER : INNER -> type(INNER); +Inside_TAILREC : TAILREC -> type(TAILREC); +Inside_OPERATOR : OPERATOR -> type(OPERATOR); +Inside_INLINE : INLINE -> type(INLINE); +Inside_INFIX : INFIX -> type(INFIX); +Inside_EXTERNAL : EXTERNAL -> type(EXTERNAL); +Inside_SUSPEND : SUSPEND -> type(SUSPEND); +Inside_OVERRIDE : OVERRIDE -> type(OVERRIDE); +Inside_ABSTRACT : ABSTRACT -> type(ABSTRACT); +Inside_FINAL : FINAL -> type(FINAL); +Inside_OPEN : OPEN -> type(OPEN); +Inside_CONST : CONST -> type(CONST); +Inside_LATEINIT : LATEINIT -> type(LATEINIT); +Inside_VARARG : VARARG -> type(VARARG); +Inside_NOINLINE : NOINLINE -> type(NOINLINE); +Inside_CROSSINLINE : CROSSINLINE -> type(CROSSINLINE); +Inside_REIFIED : REIFIED -> type(REIFIED); + +Inside_BooleanLiteral : BooleanLiteral -> type(BooleanLiteral); +Inside_IntegerLiteral : IntegerLiteral -> type(IntegerLiteral); +Inside_HexLiteral : HexLiteral -> type(HexLiteral); +Inside_BinLiteral : BinLiteral -> type(BinLiteral); +Inside_CharacterLiteral : CharacterLiteral -> type(CharacterLiteral); +Inside_RealLiteral : RealLiteral -> type(RealLiteral); +Inside_NullLiteral : NullLiteral -> type(NullLiteral); + +Inside_LongLiteral: LongLiteral -> type(LongLiteral); + +Inside_Identifier : Identifier -> type(Identifier); +Inside_LabelReference : LabelReference -> type(LabelReference); +Inside_LabelDefinition : LabelDefinition -> type(LabelDefinition); +Inside_Comment : (LineComment | DelimitedComment) -> channel(HIDDEN); +Inside_WS : WS -> skip; +Inside_NL : NL -> skip; + +mode LineString; + +QUOTE_CLOSE: '"' -> popMode; + +LineStrRef: FieldIdentifier; + +LineStrText: ~('\\' | '"' | '$')+ | '$'; + +LineStrEscapedChar: '\\' . | UniCharacterLiteral; + +LineStrExprStart: '${' -> pushMode(StringExpression); + +mode MultiLineString; + +TRIPLE_QUOTE_CLOSE: MultiLineStringQuote? '"""' -> popMode; + +MultiLineStringQuote: '"'+; + +MultiLineStrRef: FieldIdentifier; + +MultiLineStrText: ~('\\' | '"' | '$')+ | '$'; + +MultiLineStrEscapedChar: '\\' .; + +MultiLineStrExprStart: '${' -> pushMode(StringExpression); + +MultiLineNL: NL -> skip; + +mode StringExpression; + +StrExpr_RCURL: RCURL -> popMode, type(RCURL); + +StrExpr_LPAREN : LPAREN -> pushMode(Inside), type(LPAREN); +StrExpr_LSQUARE : LSQUARE -> pushMode(Inside), type(LSQUARE); + +StrExpr_RPAREN : ')' -> type(RPAREN); +StrExpr_RSQUARE : ']' -> type(RSQUARE); +StrExpr_LCURL : LCURL -> pushMode(StringExpression), type(LCURL); +StrExpr_DOT : DOT -> type(DOT); +StrExpr_COMMA : COMMA -> type(COMMA); +StrExpr_MULT : MULT -> type(MULT); +StrExpr_MOD : MOD -> type(MOD); +StrExpr_DIV : DIV -> type(DIV); +StrExpr_ADD : ADD -> type(ADD); +StrExpr_SUB : SUB -> type(SUB); +StrExpr_INCR : INCR -> type(INCR); +StrExpr_DECR : DECR -> type(DECR); +StrExpr_CONJ : CONJ -> type(CONJ); +StrExpr_DISJ : DISJ -> type(DISJ); +StrExpr_EXCL : EXCL -> type(EXCL); +StrExpr_COLON : COLON -> type(COLON); +StrExpr_SEMICOLON : SEMICOLON -> type(SEMICOLON); +StrExpr_ASSIGNMENT : ASSIGNMENT -> type(ASSIGNMENT); +StrExpr_ADD_ASSIGNMENT : ADD_ASSIGNMENT -> type(ADD_ASSIGNMENT); +StrExpr_SUB_ASSIGNMENT : SUB_ASSIGNMENT -> type(SUB_ASSIGNMENT); +StrExpr_MULT_ASSIGNMENT : MULT_ASSIGNMENT -> type(MULT_ASSIGNMENT); +StrExpr_DIV_ASSIGNMENT : DIV_ASSIGNMENT -> type(DIV_ASSIGNMENT); +StrExpr_MOD_ASSIGNMENT : MOD_ASSIGNMENT -> type(MOD_ASSIGNMENT); +StrExpr_ARROW : ARROW -> type(ARROW); +StrExpr_DOUBLE_ARROW : DOUBLE_ARROW -> type(DOUBLE_ARROW); +StrExpr_RANGE : RANGE -> type(RANGE); +StrExpr_COLONCOLON : COLONCOLON -> type(COLONCOLON); +StrExpr_Q_COLONCOLON : Q_COLONCOLON -> type(Q_COLONCOLON); +StrExpr_DOUBLE_SEMICOLON : DOUBLE_SEMICOLON -> type(DOUBLE_SEMICOLON); +StrExpr_HASH : HASH -> type(HASH); +StrExpr_AT : AT -> type(AT); +StrExpr_QUEST : QUEST -> type(QUEST); +StrExpr_ELVIS : ELVIS -> type(ELVIS); +StrExpr_LANGLE : LANGLE -> type(LANGLE); +StrExpr_RANGLE : RANGLE -> type(RANGLE); +StrExpr_LE : LE -> type(LE); +StrExpr_GE : GE -> type(GE); +StrExpr_EXCL_EQ : EXCL_EQ -> type(EXCL_EQ); +StrExpr_EXCL_EQEQ : EXCL_EQEQ -> type(EXCL_EQEQ); +StrExpr_AS : AS -> type(IS); +StrExpr_IS : IS -> type(IN); +StrExpr_IN : IN; +StrExpr_NOT_IS : NOT_IS -> type(NOT_IS); +StrExpr_NOT_IN : NOT_IN -> type(NOT_IN); +StrExpr_AS_SAFE : AS_SAFE -> type(AS_SAFE); +StrExpr_EQEQ : EQEQ -> type(EQEQ); +StrExpr_EQEQEQ : EQEQEQ -> type(EQEQEQ); +StrExpr_SINGLE_QUOTE : SINGLE_QUOTE -> type(SINGLE_QUOTE); +StrExpr_QUOTE_OPEN : QUOTE_OPEN -> pushMode(LineString), type(QUOTE_OPEN); +StrExpr_TRIPLE_QUOTE_OPEN: + TRIPLE_QUOTE_OPEN -> pushMode(MultiLineString), type(TRIPLE_QUOTE_OPEN) +; + +StrExpr_BooleanLiteral : BooleanLiteral -> type(BooleanLiteral); +StrExpr_IntegerLiteral : IntegerLiteral -> type(IntegerLiteral); +StrExpr_HexLiteral : HexLiteral -> type(HexLiteral); +StrExpr_BinLiteral : BinLiteral -> type(BinLiteral); +StrExpr_CharacterLiteral : CharacterLiteral -> type(CharacterLiteral); +StrExpr_RealLiteral : RealLiteral -> type(RealLiteral); +StrExpr_NullLiteral : NullLiteral -> type(NullLiteral); +StrExpr_LongLiteral : LongLiteral -> type(LongLiteral); + +StrExpr_Identifier : Identifier -> type(Identifier); +StrExpr_LabelReference : LabelReference -> type(LabelReference); +StrExpr_LabelDefinition : LabelDefinition -> type(LabelDefinition); +StrExpr_Comment : (LineComment | DelimitedComment) -> channel(HIDDEN); +StrExpr_WS : WS -> skip; +StrExpr_NL : NL -> skip; diff --git a/src/main/antlr/KotlinParser.g4 b/src/main/antlr/KotlinParser.g4 new file mode 100644 index 0000000..777b44f --- /dev/null +++ b/src/main/antlr/KotlinParser.g4 @@ -0,0 +1,819 @@ +/** + * Kotlin Grammar for ANTLR v4 + * + * Based on: + * http://jetbrains.github.io/kotlin-spec/#_grammars_and_parsing + * and + * http://kotlinlang.org/docs/reference/grammar.html + * + * Tested on + * https://github.com/JetBrains/kotlin/tree/master/compiler/testData/psi + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +parser grammar KotlinParser; + +options { + tokenVocab = KotlinLexer; +} + +kotlinFile + : NL* preamble anysemi* (topLevelObject (anysemi+ topLevelObject?)*)? EOF + ; + +script + : NL* preamble anysemi* (expression (anysemi+ expression?)*)? EOF + ; + +preamble + : fileAnnotations? packageHeader importList + ; + +fileAnnotations + : fileAnnotation+ + ; + +fileAnnotation + : (FILE COLON (LSQUARE unescapedAnnotation+ RSQUARE | unescapedAnnotation) semi?)+ + ; + +packageHeader + : (modifierList? PACKAGE identifier semi?)? + ; + +importList + : importHeader* + ; + +importHeader + : IMPORT identifier (DOT MULT | importAlias)? semi? + ; + +importAlias + : AS simpleIdentifier + ; + +topLevelObject + : classDeclaration + | objectDeclaration + | functionDeclaration + | propertyDeclaration + | typeAlias + ; + +classDeclaration + : modifierList? (CLASS | INTERFACE) NL* simpleIdentifier (NL* typeParameters)? ( + NL* primaryConstructor + )? (NL* COLON NL* delegationSpecifiers)? (NL* typeConstraints)? ( + NL* classBody + | NL* enumClassBody + )? + ; + +primaryConstructor + : modifierList? (CONSTRUCTOR NL*)? classParameters + ; + +classParameters + : LPAREN (classParameter (COMMA classParameter)* COMMA?)? RPAREN + ; + +classParameter + : modifierList? (VAL | VAR)? simpleIdentifier COLON type (ASSIGNMENT expression)? + ; + +delegationSpecifiers + : annotations* delegationSpecifier (NL* COMMA NL* annotations* delegationSpecifier)* + ; + +delegationSpecifier + : constructorInvocation + | userType + | explicitDelegation + ; + +constructorInvocation + : userType callSuffix + ; + +explicitDelegation + : userType NL* BY NL* expression + ; + +classBody + : LCURL NL* classMemberDeclaration* NL* RCURL + ; + +classMemberDeclaration + : ( + classDeclaration + | functionDeclaration + | objectDeclaration + | companionObject + | propertyDeclaration + | anonymousInitializer + | secondaryConstructor + | typeAlias + ) anysemi+ + ; + +anonymousInitializer + : INIT NL* block + ; + +secondaryConstructor + : modifierList? CONSTRUCTOR NL* functionValueParameters ( + NL* COLON NL* constructorDelegationCall + )? NL* block? + ; + +constructorDelegationCall + : THIS NL* valueArguments + | SUPER NL* valueArguments + ; + +enumClassBody + : LCURL NL* enumEntries? (NL* SEMICOLON NL* classMemberDeclaration*)? NL* RCURL + ; + +enumEntries + : (enumEntry NL*)+ SEMICOLON? + ; + +enumEntry + : annotations* simpleIdentifier (NL* valueArguments)? (NL* classBody)? (NL* COMMA)? + ; + +functionDeclaration + : modifierList? FUN (NL* type NL* DOT)? (NL* typeParameters)? (NL* receiverType NL* DOT)? ( + NL* identifier + )? NL* functionValueParameters (NL* COLON NL* type)? (NL* typeConstraints)? (NL* functionBody)? + ; + +functionValueParameters + : LPAREN (functionValueParameter (COMMA functionValueParameter)* COMMA?)? RPAREN + ; + +functionValueParameter + : modifierList? parameter (ASSIGNMENT expression)? + ; + +parameter + : simpleIdentifier COLON type + ; + +receiverType + : typeModifierList? (parenthesizedType | nullableType | typeReference) + ; + +functionBody + : block + | ASSIGNMENT NL* expression + ; + +objectDeclaration + : modifierList? OBJECT NL* simpleIdentifier (NL* primaryConstructor)? ( + NL* COLON NL* delegationSpecifiers + )? (NL* classBody)? + ; + +companionObject + : modifierList? COMPANION NL* modifierList? OBJECT (NL* simpleIdentifier)? ( + NL* COLON NL* delegationSpecifiers + )? (NL* classBody)? + ; + +propertyDeclaration + : modifierList? (VAL | VAR) (NL* typeParameters)? (NL* type NL* DOT)? ( + NL* (multiVariableDeclaration | variableDeclaration) + ) (NL* typeConstraints)? (NL* (BY | ASSIGNMENT) NL* expression)? ( + NL* getter (semi setter)? + | NL* setter (semi getter)? + )? + ; + +multiVariableDeclaration + : LPAREN variableDeclaration (COMMA variableDeclaration)* RPAREN + ; + +variableDeclaration + : simpleIdentifier (COLON type)? + ; + +getter + : modifierList? GETTER + | modifierList? GETTER NL* LPAREN RPAREN (NL* COLON NL* type)? NL* ( + block + | ASSIGNMENT NL* expression + ) + ; + +setter + : modifierList? SETTER + | modifierList? SETTER NL* LPAREN (annotations | parameterModifier)* ( + simpleIdentifier + | parameter + ) RPAREN NL* functionBody + ; + +typeAlias + : modifierList? TYPE_ALIAS NL* simpleIdentifier (NL* typeParameters)? NL* ASSIGNMENT NL* type + ; + +typeParameters + : LANGLE NL* typeParameter (NL* COMMA NL* typeParameter)* (NL* COMMA)? NL* RANGLE + ; + +typeParameter + : modifierList? NL* (simpleIdentifier | MULT) (NL* COLON NL* type)? + ; + +type + : typeModifierList? (functionType | parenthesizedType | nullableType | typeReference) + ; + +typeModifierList + : (annotations | SUSPEND NL*)+ + ; + +parenthesizedType + : LPAREN type RPAREN + ; + +nullableType + : (typeReference | parenthesizedType) NL* QUEST+ + ; + +typeReference + : LPAREN typeReference RPAREN + | userType + | DYNAMIC + ; + +functionType + : (functionTypeReceiver NL* DOT NL*)? functionTypeParameters NL* ARROW (NL* type) + ; + +functionTypeReceiver + : parenthesizedType + | nullableType + | typeReference + ; + +userType + : simpleUserType (NL* DOT NL* simpleUserType)* + ; + +simpleUserType + : simpleIdentifier (NL* typeArguments)? + ; + +//parameters for functionType +functionTypeParameters + : LPAREN NL* (parameter | type)? (NL* COMMA NL* (parameter | type))* (NL* COMMA)? NL* RPAREN + ; + +typeConstraints + : WHERE NL* typeConstraint (NL* COMMA NL* typeConstraint)* + ; + +typeConstraint + : annotations* simpleIdentifier NL* COLON NL* type + ; + +block + : LCURL statements RCURL + ; + +statements + : anysemi* (statement (anysemi+ statement?)*)? + ; + +statement + : declaration + | blockLevelExpression + ; + +blockLevelExpression + : annotations* NL* expression + ; + +declaration + : labelDefinition* (classDeclaration | functionDeclaration | propertyDeclaration | typeAlias) + ; + +expression + : disjunction (assignmentOperator disjunction)* + ; + +disjunction + : conjunction (NL* DISJ NL* conjunction)* + ; + +conjunction + : equalityComparison (NL* CONJ NL* equalityComparison)* + ; + +equalityComparison + : comparison (equalityOperation NL* comparison)* + ; + +comparison + : namedInfix (comparisonOperator NL* namedInfix)? + ; + +namedInfix + : elvisExpression ((inOperator NL* elvisExpression)+ | (isOperator NL* type))? + ; + +elvisExpression + : infixFunctionCall (NL* ELVIS NL* infixFunctionCall)* + ; + +infixFunctionCall + : rangeExpression (simpleIdentifier NL* rangeExpression)* + ; + +rangeExpression + : additiveExpression (RANGE NL* additiveExpression)* + ; + +additiveExpression + : multiplicativeExpression (additiveOperator NL* multiplicativeExpression)* + ; + +multiplicativeExpression + : typeRHS (multiplicativeOperation NL* typeRHS)* + ; + +typeRHS + : prefixUnaryExpression (NL* typeOperation prefixUnaryExpression)* + ; + +prefixUnaryExpression + : prefixUnaryOperation* postfixUnaryExpression + ; + +postfixUnaryExpression + : (atomicExpression | callableReference) postfixUnaryOperation* + ; + +atomicExpression + : parenthesizedExpression + | literalConstant + | functionLiteral + | thisExpression // THIS labelReference? + | superExpression // SUPER (LANGLE type RANGLE)? labelReference? + | conditionalExpression // ifExpression, whenExpression + | tryExpression + | objectLiteral + | jumpExpression + | loopExpression + | collectionLiteral + | simpleIdentifier + | VAL identifier + ; + +parenthesizedExpression + : LPAREN expression RPAREN + ; + +callSuffix + : typeArguments valueArguments? annotatedLambda* + | valueArguments annotatedLambda* + | annotatedLambda+ + ; + +annotatedLambda + : unescapedAnnotation* LabelDefinition? NL* functionLiteral + ; + +arrayAccess + : LSQUARE (expression (COMMA expression)*)? RSQUARE + ; + +valueArguments + : LPAREN (valueArgument (COMMA valueArgument)* (NL* COMMA)?)? RPAREN + ; + +typeArguments + : LANGLE NL* typeProjection (NL* COMMA typeProjection)* (NL* COMMA)? NL* RANGLE QUEST? + ; + +typeProjection + : typeProjectionModifierList? type + | MULT + ; + +typeProjectionModifierList + : varianceAnnotation+ + ; + +valueArgument + : (simpleIdentifier NL* ASSIGNMENT NL*)? MULT? NL* expression + ; + +literalConstant + : BooleanLiteral + | IntegerLiteral + | stringLiteral + | HexLiteral + | BinLiteral + | CharacterLiteral + | RealLiteral + | NullLiteral + | LongLiteral + ; + +stringLiteral + : lineStringLiteral + | multiLineStringLiteral + ; + +lineStringLiteral + : QUOTE_OPEN (lineStringContent | lineStringExpression)* QUOTE_CLOSE + ; + +multiLineStringLiteral + : TRIPLE_QUOTE_OPEN ( + multiLineStringContent + | multiLineStringExpression + | lineStringLiteral + | MultiLineStringQuote + )* TRIPLE_QUOTE_CLOSE + ; + +lineStringContent + : LineStrText + | LineStrEscapedChar + | LineStrRef + ; + +lineStringExpression + : LineStrExprStart expression RCURL + ; + +multiLineStringContent + : MultiLineStrText + | MultiLineStrEscapedChar + | MultiLineStrRef + ; + +multiLineStringExpression + : MultiLineStrExprStart expression RCURL + ; + +functionLiteral + : annotations* ( + LCURL NL* statements NL* RCURL + | LCURL NL* lambdaParameters NL* ARROW NL* statements NL* RCURL + ) + ; + +lambdaParameters + : lambdaParameter? (NL* COMMA NL* lambdaParameter)* + ; + +lambdaParameter + : variableDeclaration + | multiVariableDeclaration (NL* COLON NL* type)? + ; + +// https://kotlinlang.org/docs/reference/grammar.html#objectLiteral +objectLiteral + : OBJECT (NL* COLON NL* delegationSpecifiers)? NL* classBody? + ; + +collectionLiteral + : LSQUARE expression? (COMMA expression)* RSQUARE + ; + +thisExpression + : THIS LabelReference? + ; + +superExpression + : SUPER (LANGLE NL* type NL* RANGLE)? LabelReference? + ; + +conditionalExpression + : ifExpression + | whenExpression + ; + +ifExpression + : IF NL* LPAREN expression RPAREN NL* controlStructureBody? SEMICOLON? ( + NL* ELSE NL* controlStructureBody? + )? + ; + +controlStructureBody + : block + | expression + ; + +whenExpression + : WHEN NL* (LPAREN expression RPAREN)? NL* LCURL NL* (whenEntry NL*)* NL* RCURL + ; + +whenEntry + : whenCondition (NL* COMMA NL* whenCondition)* NL* ARROW NL* controlStructureBody semi? + | ELSE NL* ARROW NL* controlStructureBody + ; + +whenCondition + : expression + | rangeTest + | typeTest + ; + +rangeTest + : inOperator NL* expression + ; + +typeTest + : isOperator NL* type + ; + +tryExpression + : TRY NL* block (NL* catchBlock)* (NL* finallyBlock)? + ; + +catchBlock + : CATCH NL* LPAREN annotations* simpleIdentifier COLON userType RPAREN NL* block + ; + +finallyBlock + : FINALLY NL* block + ; + +loopExpression + : forExpression + | whileExpression + | doWhileExpression + ; + +forExpression + : FOR NL* LPAREN annotations* (variableDeclaration | multiVariableDeclaration) IN expression RPAREN NL* controlStructureBody? + ; + +whileExpression + : WHILE NL* LPAREN expression RPAREN NL* controlStructureBody? + ; + +doWhileExpression + : DO NL* controlStructureBody? NL* WHILE NL* LPAREN expression RPAREN + ; + +jumpExpression + : THROW NL* expression + | (RETURN | RETURN_AT) expression? + | CONTINUE + | CONTINUE_AT + | BREAK + | BREAK_AT + ; + +callableReference + : (userType (QUEST NL*)*)? NL* (COLONCOLON | Q_COLONCOLON) NL* (identifier | CLASS) + | THIS NL* COLONCOLON NL* CLASS + ; + +assignmentOperator + : ASSIGNMENT + | ADD_ASSIGNMENT + | SUB_ASSIGNMENT + | MULT_ASSIGNMENT + | DIV_ASSIGNMENT + | MOD_ASSIGNMENT + ; + +equalityOperation + : EXCL_EQ + | EXCL_EQEQ + | EQEQ + | EQEQEQ + ; + +comparisonOperator + : LANGLE + | RANGLE + | LE + | GE + ; + +inOperator + : IN + | NOT_IN + ; + +isOperator + : IS + | NOT_IS + ; + +additiveOperator + : ADD + | SUB + ; + +multiplicativeOperation + : MULT + | DIV + | MOD + ; + +typeOperation + : AS + | AS_SAFE + | COLON + ; + +prefixUnaryOperation + : INCR + | DECR + | ADD + | SUB + | EXCL + | annotations + | labelDefinition + ; + +postfixUnaryOperation + : INCR + | DECR + | EXCL EXCL + | callSuffix + | arrayAccess + | NL* memberAccessOperator postfixUnaryExpression + ; + +memberAccessOperator + : DOT + | QUEST DOT + ; + +modifierList + : (annotations | modifier)+ + ; + +modifier + : ( + classModifier + | memberModifier + | visibilityModifier + | varianceAnnotation + | functionModifier + | propertyModifier + | inheritanceModifier + | parameterModifier + | typeParameterModifier + ) NL* + ; + +classModifier + : ENUM + | SEALED + | ANNOTATION + | DATA + | INNER + ; + +memberModifier + : OVERRIDE + | LATEINIT + ; + +visibilityModifier + : PUBLIC + | PRIVATE + | INTERNAL + | PROTECTED + ; + +varianceAnnotation + : IN + | OUT + ; + +functionModifier + : TAILREC + | OPERATOR + | INFIX + | INLINE + | EXTERNAL + | SUSPEND + ; + +propertyModifier + : CONST + ; + +inheritanceModifier + : ABSTRACT + | FINAL + | OPEN + ; + +parameterModifier + : VARARG + | NOINLINE + | CROSSINLINE + ; + +typeParameterModifier + : REIFIED + ; + +labelDefinition + : LabelDefinition NL* + ; + +annotations + : (annotation | annotationList) NL* + ; + +annotation + : annotationUseSiteTarget NL* COLON NL* unescapedAnnotation + | LabelReference (NL* DOT NL* simpleIdentifier)* (NL* typeArguments)? (NL* valueArguments)? + ; + +annotationList + : annotationUseSiteTarget COLON LSQUARE unescapedAnnotation+ RSQUARE + | AT LSQUARE unescapedAnnotation+ RSQUARE + ; + +annotationUseSiteTarget + : FIELD + | FILE + | PROPERTY + | GET + | SET + | RECEIVER + | PARAM + | SETPARAM + | DELEGATE + ; + +unescapedAnnotation + : identifier typeArguments? valueArguments? + ; + +identifier + : simpleIdentifier (NL* DOT simpleIdentifier)* + ; + +simpleIdentifier + : Identifier + //soft keywords: + | ABSTRACT + | ANNOTATION + | BY + | CATCH + | COMPANION + | CONSTRUCTOR + | CROSSINLINE + | DATA + | DYNAMIC + | ENUM + | EXTERNAL + | FINAL + | FINALLY + | GETTER + | IMPORT + | INFIX + | INIT + | INLINE + | INNER + | INTERNAL + | LATEINIT + | NOINLINE + | OPEN + | OPERATOR + | OUT + | OVERRIDE + | PRIVATE + | PROTECTED + | PUBLIC + | REIFIED + | SEALED + | TAILREC + | SETTER + | VARARG + | WHERE + //strong keywords + | CONST + | SUSPEND + ; + +semi + : NL+ + | NL* SEMICOLON NL* + ; + +anysemi + : NL + | SEMICOLON + ; diff --git a/src/main/antlr/Python3.g4 b/src/main/antlr/Python3.g4 deleted file mode 100644 index d07c49e..0000000 --- a/src/main/antlr/Python3.g4 +++ /dev/null @@ -1,1155 +0,0 @@ -/* - * The MIT License (MIT) - * - * Copyright (c) 2014 by Bart Kiers - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, - * copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following - * conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES - * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT - * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, - * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR - * OTHER DEALINGS IN THE SOFTWARE. - * - * Project : python3-parser; an ANTLR4 grammar for Python 3 - * https://github.com/bkiers/python3-parser - * Developed by : Bart Kiers, bart@big-o.nl - */ -grammar Python3; - -// All comments that start with "///" are copy-pasted from -// The Python Language Reference - -tokens { INDENT, DEDENT } - -@lexer::members { - // A queue where extra tokens are pushed on (see the NEWLINE lexer rule). - private java.util.LinkedList tokens = new java.util.LinkedList<>(); - // The stack that keeps track of the indentation level. - private java.util.Stack indents = new java.util.Stack<>(); - // The amount of opened braces, brackets and parenthesis. - private int opened = 0; - // The most recently produced token. - private Token lastToken = null; - @Override - public void emit(Token t) { - super.setToken(t); - tokens.offer(t); - } - - @Override - public Token nextToken() { - // Check if the end-of-file is ahead and there are still some DEDENTS expected. - if (_input.LA(1) == EOF && !this.indents.isEmpty()) { - // Remove any trailing EOF tokens from our buffer. - for (int i = tokens.size() - 1; i >= 0; i--) { - if (tokens.get(i).getType() == EOF) { - tokens.remove(i); - } - } - - // First emit an extra line break that serves as the end of the statement. - this.emit(commonToken(Python3Parser.NEWLINE, "\n")); - - // Now emit as much DEDENT tokens as needed. - while (!indents.isEmpty()) { - this.emit(createDedent()); - indents.pop(); - } - - // Put the EOF back on the token stream. - this.emit(commonToken(Python3Parser.EOF, "")); - } - - Token next = super.nextToken(); - - if (next.getChannel() == Token.DEFAULT_CHANNEL) { - // Keep track of the last token on the default channel. - this.lastToken = next; - } - - return tokens.isEmpty() ? next : tokens.poll(); - } - - private Token createDedent() { - CommonToken dedent = commonToken(Python3Parser.DEDENT, ""); - dedent.setLine(this.lastToken.getLine()); - return dedent; - } - - private CommonToken commonToken(int type, String text) { - int stop = this.getCharIndex() - 1; - int start = text.isEmpty() ? stop : stop - text.length() + 1; - return new CommonToken(this._tokenFactorySourcePair, type, DEFAULT_TOKEN_CHANNEL, start, stop); - } - - // Calculates the indentation of the provided spaces, taking the - // following rules into account: - // - // "Tabs are replaced (from left to right) by one to eight spaces - // such that the total number of characters up to and including - // the replacement is a multiple of eight [...]" - // - // -- https://docs.python.org/3.1/reference/lexical_analysis.html#indentation - static int getIndentationCount(String spaces) { - int count = 0; - for (char ch : spaces.toCharArray()) { - switch (ch) { - case '\t': - count += 8 - (count % 8); - break; - default: - // A normal space char. - count++; - } - } - - return count; - } - - boolean atStartOfInput() { - return super.getCharPositionInLine() == 0 && super.getLine() == 1; - } -} - -/* - * parser rules - */ - -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE; -file_input: (NEWLINE | stmt)* EOF; -eval_input: testlist NEWLINE* EOF; - -decorator: '@' dotted_name ( '(' (arglist)? ')' )? NEWLINE; -decorators: decorator+; -decorated: decorators (classdef | funcdef | async_funcdef); - -async_funcdef: ASYNC funcdef; -funcdef: 'def' NAME parameters ('->' test)? ':' suite; - -parameters: '(' (typedargslist)? ')'; -typedargslist: (tfpdef ('=' test)? (',' tfpdef ('=' test)?)* (',' ( - '*' (tfpdef)? (',' tfpdef ('=' test)?)* (',' ('**' tfpdef (',')?)?)? - | '**' tfpdef (',')?)?)? - | '*' (tfpdef)? (',' tfpdef ('=' test)?)* (',' ('**' tfpdef (',')?)?)? - | '**' tfpdef (',')?); -tfpdef: NAME (':' test)?; -varargslist: (vfpdef ('=' test)? (',' vfpdef ('=' test)?)* (',' ( - '*' (vfpdef)? (',' vfpdef ('=' test)?)* (',' ('**' vfpdef (',')?)?)? - | '**' vfpdef (',')?)?)? - | '*' (vfpdef)? (',' vfpdef ('=' test)?)* (',' ('**' vfpdef (',')?)?)? - | '**' vfpdef (',')? -); -vfpdef: NAME; - -stmt: simple_stmt | compound_stmt; -simple_stmt: small_stmt (';' small_stmt)* (';')? NEWLINE; -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt); -expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*); -annassign: ':' test ('=' test)?; -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* (',')?; -augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//='); -// For normal and annotated assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist; -pass_stmt: 'pass'; -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt; -break_stmt: 'break'; -continue_stmt: 'continue'; -return_stmt: 'return' (testlist)?; -yield_stmt: yield_expr; -raise_stmt: 'raise' (test ('from' test)?)?; -import_stmt: import_name | import_from; -import_name: 'import' dotted_as_names; -// note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)); -import_as_name: NAME ('as' NAME)?; -dotted_as_name: dotted_name ('as' NAME)?; -import_as_names: import_as_name (',' import_as_name)* (',')?; -dotted_as_names: dotted_as_name (',' dotted_as_name)*; -dotted_name: NAME ('.' NAME)*; -global_stmt: 'global' NAME (',' NAME)*; -nonlocal_stmt: 'nonlocal' NAME (',' NAME)*; -assert_stmt: 'assert' test (',' test)?; - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt; -async_stmt: ASYNC (funcdef | with_stmt | for_stmt); -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ('else' ':' suite)?; -while_stmt: 'while' test ':' suite ('else' ':' suite)?; -for_stmt: 'for' exprlist 'in' testlist ':' suite ('else' ':' suite)?; -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ('else' ':' suite)? - ('finally' ':' suite)? | - 'finally' ':' suite)); -with_stmt: 'with' with_item (',' with_item)* ':' suite; -with_item: test ('as' expr)?; -// NB compile.c makes sure that the default except clause is last -except_clause: 'except' (test ('as' NAME)?)?; -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT; - -test: or_test ('if' or_test 'else' test)? | lambdef; -test_nocond: or_test | lambdef_nocond; -lambdef: 'lambda' (varargslist)? ':' test; -lambdef_nocond: 'lambda' (varargslist)? ':' test_nocond; -or_test: and_test ('or' and_test)*; -and_test: not_test ('and' not_test)*; -not_test: 'not' not_test | comparison; -comparison: expr (comp_op expr)*; -// <> isn't actually a valid comparison operator in Python. It's here for the -// sake of a __future__ import described in PEP 401 (which really works :-) -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'; -star_expr: '*' expr; -expr: xor_expr ('|' xor_expr)*; -xor_expr: and_expr ('^' and_expr)*; -and_expr: shift_expr ('&' shift_expr)*; -shift_expr: arith_expr (('<<'|'>>') arith_expr)*; -arith_expr: term (('+'|'-') term)*; -term: factor (('*'|'@'|'/'|'%'|'//') factor)*; -factor: ('+'|'-'|'~') factor | power; -power: atom_expr ('**' factor)?; -atom_expr: (AWAIT)? atom trailer*; -atom: ('(' (yield_expr|testlist_comp)? ')' | - '[' (testlist_comp)? ']' | - '{' (dictorsetmaker)? '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False'); -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* (',')? ); -trailer: '(' (arglist)? ')' | '[' subscriptlist ']' | '.' NAME; -subscriptlist: subscript (',' subscript)* (',')?; -subscript: test | (test)? ':' (test)? (sliceop)?; -sliceop: ':' (test)?; -exprlist: (expr|star_expr) (',' (expr|star_expr))* (',')?; -testlist: test (',' test)* (',')?; -dictorsetmaker: ( ((test ':' test | '**' expr) - (comp_for | (',' (test ':' test | '**' expr))* (',')?)) | - ((test | star_expr) - (comp_for | (',' (test | star_expr))* (',')?)) ); - -classdef: 'class' NAME ('(' (arglist)? ')')? ':' suite; - -arglist: argument (',' argument)* (',')?; - -// The reason that keywords are test nodes instead of NAME is that using NAME -// results in an ambiguity. ast.c makes sure it's a NAME. -// "test '=' test" is really "keyword '=' test", but we have no such token. -// These need to be in a single rule to avoid grammar that is ambiguous -// to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, -// we explicitly match '*' here, too, to give it proper precedence. -// Illegal combinations and orderings are blocked in ast.c: -// multiple (test comp_for) arguments are blocked; keyword unpackings -// that precede iterable unpackings are blocked; etc. -argument: ( test (comp_for)? | - test '=' test | - '**' test | - '*' test ); - -comp_iter: comp_for | comp_if; -comp_for: (ASYNC)? 'for' exprlist 'in' or_test (comp_iter)?; -comp_if: 'if' test_nocond (comp_iter)?; - -// not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME; - -yield_expr: 'yield' (yield_arg)?; -yield_arg: 'from' test | testlist; - -/* - * lexer rules - */ - -STRING - : STRING_LITERAL - | BYTES_LITERAL - ; - -NUMBER - : INTEGER - | FLOAT_NUMBER - | IMAG_NUMBER - ; - -INTEGER - : DECIMAL_INTEGER - | OCT_INTEGER - | HEX_INTEGER - | BIN_INTEGER - ; - -DEF : 'def'; -RETURN : 'return'; -RAISE : 'raise'; -FROM : 'from'; -IMPORT : 'import'; -AS : 'as'; -GLOBAL : 'global'; -NONLOCAL : 'nonlocal'; -ASSERT : 'assert'; -IF : 'if'; -ELIF : 'elif'; -ELSE : 'else'; -WHILE : 'while'; -FOR : 'for'; -IN : 'in'; -TRY : 'try'; -FINALLY : 'finally'; -WITH : 'with'; -EXCEPT : 'except'; -LAMBDA : 'lambda'; -OR : 'or'; -AND : 'and'; -NOT : 'not'; -IS : 'is'; -NONE : 'None'; -TRUE : 'True'; -FALSE : 'False'; -CLASS : 'class'; -YIELD : 'yield'; -DEL : 'del'; -PASS : 'pass'; -CONTINUE : 'continue'; -BREAK : 'break'; -ASYNC : 'async'; -AWAIT : 'await'; - -NEWLINE - : ( {atStartOfInput()}? SPACES - | ( '\r'? '\n' | '\r' | '\f' ) SPACES? - ) - { - String newLine = getText().replaceAll("[^\r\n\f]+", ""); - String spaces = getText().replaceAll("[\r\n\f]+", ""); - - // Strip newlines inside open clauses except if we are near EOF. We keep NEWLINEs near EOF to - // satisfy the final newline needed by the single_put rule used by the REPL. - int next = _input.LA(1); - int nextnext = _input.LA(2); - if (opened > 0 || (nextnext != -1 && (next == '\r' || next == '\n' || next == '\f' || next == '#'))) { - // If we're inside a list or on a blank line, ignore all indents, - // dedents and line breaks. - skip(); - } - else { - emit(commonToken(NEWLINE, newLine)); - int indent = getIndentationCount(spaces); - int previous = indents.isEmpty() ? 0 : indents.peek(); - if (indent == previous) { - // skip indents of the same size as the present indent-size - skip(); - } - else if (indent > previous) { - indents.push(indent); - emit(commonToken(Python3Parser.INDENT, spaces)); - } - else { - // Possibly emit more than 1 DEDENT token. - while(!indents.isEmpty() && indents.peek() > indent) { - this.emit(createDedent()); - indents.pop(); - } - } - } - } - ; - -/// identifier ::= id_start id_continue* -NAME - : ID_START ID_CONTINUE* - ; - -/// stringliteral ::= [stringprefix](shortstring | longstring) -/// stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F" -/// | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF" -STRING_LITERAL - : ( [rR] | [uU] | [fF] | ( [fF] [rR] ) | ( [rR] [fF] ) )? ( SHORT_STRING | LONG_STRING ) - ; - -/// bytesliteral ::= bytesprefix(shortbytes | longbytes) -/// bytesprefix ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB" -BYTES_LITERAL - : ( [bB] | ( [bB] [rR] ) | ( [rR] [bB] ) ) ( SHORT_BYTES | LONG_BYTES ) - ; - -/// decimalinteger ::= nonzerodigit digit* | "0"+ -DECIMAL_INTEGER - : NON_ZERO_DIGIT DIGIT* - | '0'+ - ; - -/// octinteger ::= "0" ("o" | "O") octdigit+ -OCT_INTEGER - : '0' [oO] OCT_DIGIT+ - ; - -/// hexinteger ::= "0" ("x" | "X") hexdigit+ -HEX_INTEGER - : '0' [xX] HEX_DIGIT+ - ; - -/// bininteger ::= "0" ("b" | "B") bindigit+ -BIN_INTEGER - : '0' [bB] BIN_DIGIT+ - ; - -/// floatnumber ::= pointfloat | exponentfloat -FLOAT_NUMBER - : POINT_FLOAT - | EXPONENT_FLOAT - ; - -/// imagnumber ::= (floatnumber | intpart) ("j" | "J") -IMAG_NUMBER - : ( FLOAT_NUMBER | INT_PART ) [jJ] - ; - -DOT : '.'; -ELLIPSIS : '...'; -STAR : '*'; -OPEN_PAREN : '(' {opened++;}; -CLOSE_PAREN : ')' {opened--;}; -COMMA : ','; -COLON : ':'; -SEMI_COLON : ';'; -POWER : '**'; -ASSIGN : '='; -OPEN_BRACK : '[' {opened++;}; -CLOSE_BRACK : ']' {opened--;}; -OR_OP : '|'; -XOR : '^'; -AND_OP : '&'; -LEFT_SHIFT : '<<'; -RIGHT_SHIFT : '>>'; -ADD : '+'; -MINUS : '-'; -DIV : '/'; -MOD : '%'; -IDIV : '//'; -NOT_OP : '~'; -OPEN_BRACE : '{' {opened++;}; -CLOSE_BRACE : '}' {opened--;}; -LESS_THAN : '<'; -GREATER_THAN : '>'; -EQUALS : '=='; -GT_EQ : '>='; -LT_EQ : '<='; -NOT_EQ_1 : '<>'; -NOT_EQ_2 : '!='; -AT : '@'; -ARROW : '->'; -ADD_ASSIGN : '+='; -SUB_ASSIGN : '-='; -MULT_ASSIGN : '*='; -AT_ASSIGN : '@='; -DIV_ASSIGN : '/='; -MOD_ASSIGN : '%='; -AND_ASSIGN : '&='; -OR_ASSIGN : '|='; -XOR_ASSIGN : '^='; -LEFT_SHIFT_ASSIGN : '<<='; -RIGHT_SHIFT_ASSIGN : '>>='; -POWER_ASSIGN : '**='; -IDIV_ASSIGN : '//='; - -SKIP_ - : ( SPACES | COMMENT | LINE_JOINING ) -> skip - ; - -UNKNOWN_CHAR - : . - ; - -/* - * fragments - */ - -/// shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"' -/// shortstringitem ::= shortstringchar | stringescapeseq -/// shortstringchar ::= -fragment SHORT_STRING - : '\'' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f'] )* '\'' - | '"' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f"] )* '"' - ; -/// longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""' -fragment LONG_STRING - : '\'\'\'' LONG_STRING_ITEM*? '\'\'\'' - | '"""' LONG_STRING_ITEM*? '"""' - ; - -/// longstringitem ::= longstringchar | stringescapeseq -fragment LONG_STRING_ITEM - : LONG_STRING_CHAR - | STRING_ESCAPE_SEQ - ; - -/// longstringchar ::= -fragment LONG_STRING_CHAR - : ~'\\' - ; - -/// stringescapeseq ::= "\" -fragment STRING_ESCAPE_SEQ - : '\\' . - | '\\' NEWLINE - ; - -/// nonzerodigit ::= "1"..."9" -fragment NON_ZERO_DIGIT - : [1-9] - ; - -/// digit ::= "0"..."9" -fragment DIGIT - : [0-9] - ; - -/// octdigit ::= "0"..."7" -fragment OCT_DIGIT - : [0-7] - ; - -/// hexdigit ::= digit | "a"..."f" | "A"..."F" -fragment HEX_DIGIT - : [0-9a-fA-F] - ; - -/// bindigit ::= "0" | "1" -fragment BIN_DIGIT - : [01] - ; - -/// pointfloat ::= [intpart] fraction | intpart "." -fragment POINT_FLOAT - : INT_PART? FRACTION - | INT_PART '.' - ; - -/// exponentfloat ::= (intpart | pointfloat) exponent -fragment EXPONENT_FLOAT - : ( INT_PART | POINT_FLOAT ) EXPONENT - ; - -/// intpart ::= digit+ -fragment INT_PART - : DIGIT+ - ; - -/// fraction ::= "." digit+ -fragment FRACTION - : '.' DIGIT+ - ; - -/// exponent ::= ("e" | "E") ["+" | "-"] digit+ -fragment EXPONENT - : [eE] [+-]? DIGIT+ - ; - -/// shortbytes ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"' -/// shortbytesitem ::= shortbyteschar | bytesescapeseq -fragment SHORT_BYTES - : '\'' ( SHORT_BYTES_CHAR_NO_SINGLE_QUOTE | BYTES_ESCAPE_SEQ )* '\'' - | '"' ( SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE | BYTES_ESCAPE_SEQ )* '"' - ; - -/// longbytes ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""' -fragment LONG_BYTES - : '\'\'\'' LONG_BYTES_ITEM*? '\'\'\'' - | '"""' LONG_BYTES_ITEM*? '"""' - ; - -/// longbytesitem ::= longbyteschar | bytesescapeseq -fragment LONG_BYTES_ITEM - : LONG_BYTES_CHAR - | BYTES_ESCAPE_SEQ - ; - -/// shortbyteschar ::= -fragment SHORT_BYTES_CHAR_NO_SINGLE_QUOTE - : [\u0000-\u0009] - | [\u000B-\u000C] - | [\u000E-\u0026] - | [\u0028-\u005B] - | [\u005D-\u007F] - ; - -fragment SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE - : [\u0000-\u0009] - | [\u000B-\u000C] - | [\u000E-\u0021] - | [\u0023-\u005B] - | [\u005D-\u007F] - ; - -/// longbyteschar ::= -fragment LONG_BYTES_CHAR - : [\u0000-\u005B] - | [\u005D-\u007F] - ; - -/// bytesescapeseq ::= "\" -fragment BYTES_ESCAPE_SEQ - : '\\' [\u0000-\u007F] - ; - -fragment SPACES - : [ \t]+ - ; - -fragment COMMENT - : '#' ~[\r\n\f]* - ; - -fragment LINE_JOINING - : '\\' SPACES? ( '\r'? '\n' | '\r' | '\f') - ; - -/// id_start ::= -fragment ID_START - : '_' - | [A-Z] - | [a-z] - | '\u00AA' - | '\u00B5' - | '\u00BA' - | [\u00C0-\u00D6] - | [\u00D8-\u00F6] - | [\u00F8-\u01BA] - | '\u01BB' - | [\u01BC-\u01BF] - | [\u01C0-\u01C3] - | [\u01C4-\u0241] - | [\u0250-\u02AF] - | [\u02B0-\u02C1] - | [\u02C6-\u02D1] - | [\u02E0-\u02E4] - | '\u02EE' - | '\u037A' - | '\u0386' - | [\u0388-\u038A] - | '\u038C' - | [\u038E-\u03A1] - | [\u03A3-\u03CE] - | [\u03D0-\u03F5] - | [\u03F7-\u0481] - | [\u048A-\u04CE] - | [\u04D0-\u04F9] - | [\u0500-\u050F] - | [\u0531-\u0556] - | '\u0559' - | [\u0561-\u0587] - | [\u05D0-\u05EA] - | [\u05F0-\u05F2] - | [\u0621-\u063A] - | '\u0640' - | [\u0641-\u064A] - | [\u066E-\u066F] - | [\u0671-\u06D3] - | '\u06D5' - | [\u06E5-\u06E6] - | [\u06EE-\u06EF] - | [\u06FA-\u06FC] - | '\u06FF' - | '\u0710' - | [\u0712-\u072F] - | [\u074D-\u076D] - | [\u0780-\u07A5] - | '\u07B1' - | [\u0904-\u0939] - | '\u093D' - | '\u0950' - | [\u0958-\u0961] - | '\u097D' - | [\u0985-\u098C] - | [\u098F-\u0990] - | [\u0993-\u09A8] - | [\u09AA-\u09B0] - | '\u09B2' - | [\u09B6-\u09B9] - | '\u09BD' - | '\u09CE' - | [\u09DC-\u09DD] - | [\u09DF-\u09E1] - | [\u09F0-\u09F1] - | [\u0A05-\u0A0A] - | [\u0A0F-\u0A10] - | [\u0A13-\u0A28] - | [\u0A2A-\u0A30] - | [\u0A32-\u0A33] - | [\u0A35-\u0A36] - | [\u0A38-\u0A39] - | [\u0A59-\u0A5C] - | '\u0A5E' - | [\u0A72-\u0A74] - | [\u0A85-\u0A8D] - | [\u0A8F-\u0A91] - | [\u0A93-\u0AA8] - | [\u0AAA-\u0AB0] - | [\u0AB2-\u0AB3] - | [\u0AB5-\u0AB9] - | '\u0ABD' - | '\u0AD0' - | [\u0AE0-\u0AE1] - | [\u0B05-\u0B0C] - | [\u0B0F-\u0B10] - | [\u0B13-\u0B28] - | [\u0B2A-\u0B30] - | [\u0B32-\u0B33] - | [\u0B35-\u0B39] - | '\u0B3D' - | [\u0B5C-\u0B5D] - | [\u0B5F-\u0B61] - | '\u0B71' - | '\u0B83' - | [\u0B85-\u0B8A] - | [\u0B8E-\u0B90] - | [\u0B92-\u0B95] - | [\u0B99-\u0B9A] - | '\u0B9C' - | [\u0B9E-\u0B9F] - | [\u0BA3-\u0BA4] - | [\u0BA8-\u0BAA] - | [\u0BAE-\u0BB9] - | [\u0C05-\u0C0C] - | [\u0C0E-\u0C10] - | [\u0C12-\u0C28] - | [\u0C2A-\u0C33] - | [\u0C35-\u0C39] - | [\u0C60-\u0C61] - | [\u0C85-\u0C8C] - | [\u0C8E-\u0C90] - | [\u0C92-\u0CA8] - | [\u0CAA-\u0CB3] - | [\u0CB5-\u0CB9] - | '\u0CBD' - | '\u0CDE' - | [\u0CE0-\u0CE1] - | [\u0D05-\u0D0C] - | [\u0D0E-\u0D10] - | [\u0D12-\u0D28] - | [\u0D2A-\u0D39] - | [\u0D60-\u0D61] - | [\u0D85-\u0D96] - | [\u0D9A-\u0DB1] - | [\u0DB3-\u0DBB] - | '\u0DBD' - | [\u0DC0-\u0DC6] - | [\u0E01-\u0E30] - | [\u0E32-\u0E33] - | [\u0E40-\u0E45] - | '\u0E46' - | [\u0E81-\u0E82] - | '\u0E84' - | [\u0E87-\u0E88] - | '\u0E8A' - | '\u0E8D' - | [\u0E94-\u0E97] - | [\u0E99-\u0E9F] - | [\u0EA1-\u0EA3] - | '\u0EA5' - | '\u0EA7' - | [\u0EAA-\u0EAB] - | [\u0EAD-\u0EB0] - | [\u0EB2-\u0EB3] - | '\u0EBD' - | [\u0EC0-\u0EC4] - | '\u0EC6' - | [\u0EDC-\u0EDD] - | '\u0F00' - | [\u0F40-\u0F47] - | [\u0F49-\u0F6A] - | [\u0F88-\u0F8B] - | [\u1000-\u1021] - | [\u1023-\u1027] - | [\u1029-\u102A] - | [\u1050-\u1055] - | [\u10A0-\u10C5] - | [\u10D0-\u10FA] - | '\u10FC' - | [\u1100-\u1159] - | [\u115F-\u11A2] - | [\u11A8-\u11F9] - | [\u1200-\u1248] - | [\u124A-\u124D] - | [\u1250-\u1256] - | '\u1258' - | [\u125A-\u125D] - | [\u1260-\u1288] - | [\u128A-\u128D] - | [\u1290-\u12B0] - | [\u12B2-\u12B5] - | [\u12B8-\u12BE] - | '\u12C0' - | [\u12C2-\u12C5] - | [\u12C8-\u12D6] - | [\u12D8-\u1310] - | [\u1312-\u1315] - | [\u1318-\u135A] - | [\u1380-\u138F] - | [\u13A0-\u13F4] - | [\u1401-\u166C] - | [\u166F-\u1676] - | [\u1681-\u169A] - | [\u16A0-\u16EA] - | [\u16EE-\u16F0] - | [\u1700-\u170C] - | [\u170E-\u1711] - | [\u1720-\u1731] - | [\u1740-\u1751] - | [\u1760-\u176C] - | [\u176E-\u1770] - | [\u1780-\u17B3] - | '\u17D7' - | '\u17DC' - | [\u1820-\u1842] - | '\u1843' - | [\u1844-\u1877] - | [\u1880-\u18A8] - | [\u1900-\u191C] - | [\u1950-\u196D] - | [\u1970-\u1974] - | [\u1980-\u19A9] - | [\u19C1-\u19C7] - | [\u1A00-\u1A16] - | [\u1D00-\u1D2B] - | [\u1D2C-\u1D61] - | [\u1D62-\u1D77] - | '\u1D78' - | [\u1D79-\u1D9A] - | [\u1D9B-\u1DBF] - | [\u1E00-\u1E9B] - | [\u1EA0-\u1EF9] - | [\u1F00-\u1F15] - | [\u1F18-\u1F1D] - | [\u1F20-\u1F45] - | [\u1F48-\u1F4D] - | [\u1F50-\u1F57] - | '\u1F59' - | '\u1F5B' - | '\u1F5D' - | [\u1F5F-\u1F7D] - | [\u1F80-\u1FB4] - | [\u1FB6-\u1FBC] - | '\u1FBE' - | [\u1FC2-\u1FC4] - | [\u1FC6-\u1FCC] - | [\u1FD0-\u1FD3] - | [\u1FD6-\u1FDB] - | [\u1FE0-\u1FEC] - | [\u1FF2-\u1FF4] - | [\u1FF6-\u1FFC] - | '\u2071' - | '\u207F' - | [\u2090-\u2094] - | '\u2102' - | '\u2107' - | [\u210A-\u2113] - | '\u2115' - | '\u2118' - | [\u2119-\u211D] - | '\u2124' - | '\u2126' - | '\u2128' - | [\u212A-\u212D] - | '\u212E' - | [\u212F-\u2131] - | [\u2133-\u2134] - | [\u2135-\u2138] - | '\u2139' - | [\u213C-\u213F] - | [\u2145-\u2149] - | [\u2160-\u2183] - | [\u2C00-\u2C2E] - | [\u2C30-\u2C5E] - | [\u2C80-\u2CE4] - | [\u2D00-\u2D25] - | [\u2D30-\u2D65] - | '\u2D6F' - | [\u2D80-\u2D96] - | [\u2DA0-\u2DA6] - | [\u2DA8-\u2DAE] - | [\u2DB0-\u2DB6] - | [\u2DB8-\u2DBE] - | [\u2DC0-\u2DC6] - | [\u2DC8-\u2DCE] - | [\u2DD0-\u2DD6] - | [\u2DD8-\u2DDE] - | '\u3005' - | '\u3006' - | '\u3007' - | [\u3021-\u3029] - | [\u3031-\u3035] - | [\u3038-\u303A] - | '\u303B' - | '\u303C' - | [\u3041-\u3096] - | [\u309B-\u309C] - | [\u309D-\u309E] - | '\u309F' - | [\u30A1-\u30FA] - | [\u30FC-\u30FE] - | '\u30FF' - | [\u3105-\u312C] - | [\u3131-\u318E] - | [\u31A0-\u31B7] - | [\u31F0-\u31FF] - | [\u3400-\u4DB5] - | [\u4E00-\u9FBB] - | [\uA000-\uA014] - | '\uA015' - | [\uA016-\uA48C] - | [\uA800-\uA801] - | [\uA803-\uA805] - | [\uA807-\uA80A] - | [\uA80C-\uA822] - | [\uAC00-\uD7A3] - | [\uF900-\uFA2D] - | [\uFA30-\uFA6A] - | [\uFA70-\uFAD9] - | [\uFB00-\uFB06] - | [\uFB13-\uFB17] - | '\uFB1D' - | [\uFB1F-\uFB28] - | [\uFB2A-\uFB36] - | [\uFB38-\uFB3C] - | '\uFB3E' - | [\uFB40-\uFB41] - | [\uFB43-\uFB44] - | [\uFB46-\uFBB1] - | [\uFBD3-\uFD3D] - | [\uFD50-\uFD8F] - | [\uFD92-\uFDC7] - | [\uFDF0-\uFDFB] - | [\uFE70-\uFE74] - | [\uFE76-\uFEFC] - | [\uFF21-\uFF3A] - | [\uFF41-\uFF5A] - | [\uFF66-\uFF6F] - | '\uFF70' - | [\uFF71-\uFF9D] - | [\uFF9E-\uFF9F] - | [\uFFA0-\uFFBE] - | [\uFFC2-\uFFC7] - | [\uFFCA-\uFFCF] - | [\uFFD2-\uFFD7] - | [\uFFDA-\uFFDC] - ; - -/// id_continue ::= -fragment ID_CONTINUE - : ID_START - | [0-9] - | [\u0300-\u036F] - | [\u0483-\u0486] - | [\u0591-\u05B9] - | [\u05BB-\u05BD] - | '\u05BF' - | [\u05C1-\u05C2] - | [\u05C4-\u05C5] - | '\u05C7' - | [\u0610-\u0615] - | [\u064B-\u065E] - | [\u0660-\u0669] - | '\u0670' - | [\u06D6-\u06DC] - | [\u06DF-\u06E4] - | [\u06E7-\u06E8] - | [\u06EA-\u06ED] - | [\u06F0-\u06F9] - | '\u0711' - | [\u0730-\u074A] - | [\u07A6-\u07B0] - | [\u0901-\u0902] - | '\u0903' - | '\u093C' - | [\u093E-\u0940] - | [\u0941-\u0948] - | [\u0949-\u094C] - | '\u094D' - | [\u0951-\u0954] - | [\u0962-\u0963] - | [\u0966-\u096F] - | '\u0981' - | [\u0982-\u0983] - | '\u09BC' - | [\u09BE-\u09C0] - | [\u09C1-\u09C4] - | [\u09C7-\u09C8] - | [\u09CB-\u09CC] - | '\u09CD' - | '\u09D7' - | [\u09E2-\u09E3] - | [\u09E6-\u09EF] - | [\u0A01-\u0A02] - | '\u0A03' - | '\u0A3C' - | [\u0A3E-\u0A40] - | [\u0A41-\u0A42] - | [\u0A47-\u0A48] - | [\u0A4B-\u0A4D] - | [\u0A66-\u0A6F] - | [\u0A70-\u0A71] - | [\u0A81-\u0A82] - | '\u0A83' - | '\u0ABC' - | [\u0ABE-\u0AC0] - | [\u0AC1-\u0AC5] - | [\u0AC7-\u0AC8] - | '\u0AC9' - | [\u0ACB-\u0ACC] - | '\u0ACD' - | [\u0AE2-\u0AE3] - | [\u0AE6-\u0AEF] - | '\u0B01' - | [\u0B02-\u0B03] - | '\u0B3C' - | '\u0B3E' - | '\u0B3F' - | '\u0B40' - | [\u0B41-\u0B43] - | [\u0B47-\u0B48] - | [\u0B4B-\u0B4C] - | '\u0B4D' - | '\u0B56' - | '\u0B57' - | [\u0B66-\u0B6F] - | '\u0B82' - | [\u0BBE-\u0BBF] - | '\u0BC0' - | [\u0BC1-\u0BC2] - | [\u0BC6-\u0BC8] - | [\u0BCA-\u0BCC] - | '\u0BCD' - | '\u0BD7' - | [\u0BE6-\u0BEF] - | [\u0C01-\u0C03] - | [\u0C3E-\u0C40] - | [\u0C41-\u0C44] - | [\u0C46-\u0C48] - | [\u0C4A-\u0C4D] - | [\u0C55-\u0C56] - | [\u0C66-\u0C6F] - | [\u0C82-\u0C83] - | '\u0CBC' - | '\u0CBE' - | '\u0CBF' - | [\u0CC0-\u0CC4] - | '\u0CC6' - | [\u0CC7-\u0CC8] - | [\u0CCA-\u0CCB] - | [\u0CCC-\u0CCD] - | [\u0CD5-\u0CD6] - | [\u0CE6-\u0CEF] - | [\u0D02-\u0D03] - | [\u0D3E-\u0D40] - | [\u0D41-\u0D43] - | [\u0D46-\u0D48] - | [\u0D4A-\u0D4C] - | '\u0D4D' - | '\u0D57' - | [\u0D66-\u0D6F] - | [\u0D82-\u0D83] - | '\u0DCA' - | [\u0DCF-\u0DD1] - | [\u0DD2-\u0DD4] - | '\u0DD6' - | [\u0DD8-\u0DDF] - | [\u0DF2-\u0DF3] - | '\u0E31' - | [\u0E34-\u0E3A] - | [\u0E47-\u0E4E] - | [\u0E50-\u0E59] - | '\u0EB1' - | [\u0EB4-\u0EB9] - | [\u0EBB-\u0EBC] - | [\u0EC8-\u0ECD] - | [\u0ED0-\u0ED9] - | [\u0F18-\u0F19] - | [\u0F20-\u0F29] - | '\u0F35' - | '\u0F37' - | '\u0F39' - | [\u0F3E-\u0F3F] - | [\u0F71-\u0F7E] - | '\u0F7F' - | [\u0F80-\u0F84] - | [\u0F86-\u0F87] - | [\u0F90-\u0F97] - | [\u0F99-\u0FBC] - | '\u0FC6' - | '\u102C' - | [\u102D-\u1030] - | '\u1031' - | '\u1032' - | [\u1036-\u1037] - | '\u1038' - | '\u1039' - | [\u1040-\u1049] - | [\u1056-\u1057] - | [\u1058-\u1059] - | '\u135F' - | [\u1369-\u1371] - | [\u1712-\u1714] - | [\u1732-\u1734] - | [\u1752-\u1753] - | [\u1772-\u1773] - | '\u17B6' - | [\u17B7-\u17BD] - | [\u17BE-\u17C5] - | '\u17C6' - | [\u17C7-\u17C8] - | [\u17C9-\u17D3] - | '\u17DD' - | [\u17E0-\u17E9] - | [\u180B-\u180D] - | [\u1810-\u1819] - | '\u18A9' - | [\u1920-\u1922] - | [\u1923-\u1926] - | [\u1927-\u1928] - | [\u1929-\u192B] - | [\u1930-\u1931] - | '\u1932' - | [\u1933-\u1938] - | [\u1939-\u193B] - | [\u1946-\u194F] - | [\u19B0-\u19C0] - | [\u19C8-\u19C9] - | [\u19D0-\u19D9] - | [\u1A17-\u1A18] - | [\u1A19-\u1A1B] - | [\u1DC0-\u1DC3] - | [\u203F-\u2040] - | '\u2054' - | [\u20D0-\u20DC] - | '\u20E1' - | [\u20E5-\u20EB] - | [\u302A-\u302F] - | [\u3099-\u309A] - | '\uA802' - | '\uA806' - | '\uA80B' - | [\uA823-\uA824] - | [\uA825-\uA826] - | '\uA827' - | '\uFB1E' - | [\uFE00-\uFE0F] - | [\uFE20-\uFE23] - | [\uFE33-\uFE34] - | [\uFE4D-\uFE4F] - | [\uFF10-\uFF19] - | '\uFF3F' - ; \ No newline at end of file diff --git a/src/main/antlr/PythonLexer.g4 b/src/main/antlr/PythonLexer.g4 new file mode 100644 index 0000000..9e69528 --- /dev/null +++ b/src/main/antlr/PythonLexer.g4 @@ -0,0 +1,1362 @@ +/* +Python grammar +The MIT License (MIT) +Copyright (c) 2021 Robert Einhorn + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + */ + + /* + * Project : an ANTLR4 lexer grammar for Python 3 + * https://github.com/RobEin/ANTLR4-parser-for-Python-3.12 + * Developed by : Robert Einhorn, robert.einhorn.hu@gmail.com + */ + +lexer grammar PythonLexer; + +options { superClass=PythonLexerBase; } + +tokens { + INDENT, DEDENT // https://docs.python.org/3.12/reference/lexical_analysis.html#indentation + , TYPE_COMMENT // not supported, only for compatibility with the PythonParser.g4 grammar + , FSTRING_START, FSTRING_MIDDLE, FSTRING_END // https://peps.python.org/pep-0701/#specification +} + + +// https://docs.python.org/3.12/reference/lexical_analysis.html + +/* + * default lexer mode + */ + +// https://docs.python.org/3.12/reference/lexical_analysis.html#keywords +FALSE : 'False'; +AWAIT : 'await'; +ELSE : 'else'; +IMPORT : 'import'; +PASS : 'pass'; +NONE : 'None'; +BREAK : 'break'; +EXCEPT : 'except'; +IN : 'in'; +RAISE : 'raise'; +TRUE : 'True'; +CLASS : 'class'; +FINALLY : 'finally'; +IS : 'is'; +RETURN : 'return'; +AND : 'and'; +CONTINUE : 'continue'; +FOR : 'for'; +LAMBDA : 'lambda'; +TRY : 'try'; +AS : 'as'; +DEF : 'def'; +FROM : 'from'; +NONLOCAL : 'nonlocal'; +WHILE : 'while'; +ASSERT : 'assert'; +DEL : 'del'; +GLOBAL : 'global'; +NOT : 'not'; +WITH : 'with'; +ASYNC : 'async'; +ELIF : 'elif'; +IF : 'if'; +OR : 'or'; +YIELD : 'yield'; + +// https://docs.python.org/3.12/library/token.html#module-token +LPAR : '('; // OPEN_PAREN +LSQB : '['; // OPEN_BRACK +LBRACE : '{'; // OPEN_BRACE +RPAR : ')'; // CLOSE_PAREN +RSQB : ']'; // CLOSE_BRACK +RBRACE : '}'; // CLOSE_BRACE +DOT : '.'; +COLON : ':'; +COMMA : ','; +SEMI : ';'; +PLUS : '+'; +MINUS : '-'; +STAR : '*'; +SLASH : '/'; +VBAR : '|'; +AMPER : '&'; +LESS : '<'; +GREATER : '>'; +EQUAL : '='; +PERCENT : '%'; +EQEQUAL : '=='; +NOTEQUAL : '!='; +LESSEQUAL : '<='; +GREATEREQUAL : '>='; +TILDE : '~'; +CIRCUMFLEX : '^'; +LEFTSHIFT : '<<'; +RIGHTSHIFT : '>>'; +DOUBLESTAR : '**'; +PLUSEQUAL : '+='; +MINEQUAL : '-='; +STAREQUAL : '*='; +SLASHEQUAL : '/='; +PERCENTEQUAL : '%='; +AMPEREQUAL : '&='; +VBAREQUAL : '|='; +CIRCUMFLEXEQUAL : '^='; +LEFTSHIFTEQUAL : '<<='; +RIGHTSHIFTEQUAL : '>>='; +DOUBLESTAREQUAL : '**='; +DOUBLESLASH : '//'; +DOUBLESLASHEQUAL : '//='; +AT : '@'; +ATEQUAL : '@='; +RARROW : '->'; +ELLIPSIS : '...'; +COLONEQUAL : ':='; +EXCLAMATION : '!'; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#identifiers +NAME + : ID_START ID_CONTINUE* + ; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#numeric-literals +NUMBER + : INTEGER + | FLOAT_NUMBER + | IMAG_NUMBER + ; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#string-and-bytes-literals +STRING + : STRING_LITERAL + | BYTES_LITERAL + ; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#physical-lines +NEWLINE : '\r'? '\n'; // Unix, Windows + +// https://docs.python.org/3.12/reference/lexical_analysis.html#comments +COMMENT : '#' ~[\r\n]* -> channel(HIDDEN); + +// https://docs.python.org/3.12/reference/lexical_analysis.html#whitespace-between-tokens +WS : [ \t\f]+ -> channel(HIDDEN); + +// https://docs.python.org/3.12/reference/lexical_analysis.html#explicit-line-joining +EXPLICIT_LINE_JOINING : '\\' NEWLINE -> channel(HIDDEN); + +// https://docs.python.org/3.12/reference/lexical_analysis.html#formatted-string-literals +SINGLE_QUOTE_FSTRING_START : F_STRING_PREFIX ['] -> type(FSTRING_START), pushMode(SINGLE_QUOTE_FSTRING_MODE); +DOUBLE_QUOTE_FSTRING_START : F_STRING_PREFIX ["] -> type(FSTRING_START), pushMode(DOUBLE_QUOTE_FSTRING_MODE); +LONG_SINGLE_QUOTE_FSTRING_START : F_STRING_PREFIX ['][']['] -> type(FSTRING_START), pushMode(LONG_SINGLE_QUOTE_FSTRING_MODE); +LONG_DOUBLE_QUOTE_FSTRING_START : F_STRING_PREFIX ["]["]["] -> type(FSTRING_START), pushMode(LONG_DOUBLE_QUOTE_FSTRING_MODE); + +ERRORTOKEN : . ; // catch the unrecognized characters and redirect these errors to the parser + + +/* + * other lexer modes + */ + +mode SINGLE_QUOTE_FSTRING_MODE; + SINGLE_QUOTE_FSTRING_END : ['] -> type(FSTRING_END), popMode; + SINGLE_QUOTE_FSTRING_MIDDLE : SINGLE_QUOTE_FSTRING_LITERAL -> type(FSTRING_MIDDLE); + SINGLE_QUOTE_FSTRING_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE or SINGLE_QUOTE_FORMAT_SPECIFICATION_RBRACE + +mode DOUBLE_QUOTE_FSTRING_MODE; + DOUBLE_QUOTE_FSTRING_END : ["] -> type(FSTRING_END), popMode; + DOUBLE_QUOTE_FSTRING_MIDDLE : DOUBLE_QUOTE_FSTRING_LITERAL -> type(FSTRING_MIDDLE); + DOUBLE_QUOTE_FSTRING_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE or DOUBLE_QUOTE_FORMAT_SPECIFICATION_RBRACE + +mode LONG_SINGLE_QUOTE_FSTRING_MODE; + LONG_SINGLE_QUOTE_FSTRING_END : ['][']['] -> type(FSTRING_END), popMode; + LONG_SINGLE_QUOTE_FSTRING_MIDDLE : SINGLE_QUOTE_FSTRING_LITERAL -> type(FSTRING_MIDDLE); + LONG_SINGLE_QUOTE_FSTRING_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE or SINGLE_QUOTE_FORMAT_SPECIFICATION_RBRACE + +mode LONG_DOUBLE_QUOTE_FSTRING_MODE; + LONG_DOUBLE_QUOTE_FSTRING_END : ["]["]["] -> type(FSTRING_END), popMode; + LONG_DOUBLE_QUOTE_FSTRING_MIDDLE : DOUBLE_QUOTE_FSTRING_LITERAL -> type(FSTRING_MIDDLE); + LONG_DOUBLE_QUOTE_FSTRING_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE or DOUBLE_QUOTE_FORMAT_SPECIFICATION_RBRACE + +mode SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE; // only used after a format specifier colon + SINGLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE : FORMAT_SPEC_CHAR_NO_SINGLE_QUOTE+ -> type(FSTRING_MIDDLE); + SINGLE_QUOTE_FORMAT_SPECIFICATION_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE by PythonLexerBase class + SINGLE_QUOTE_FORMAT_SPECIFICATION_RBRACE : '}' -> type(RBRACE); // popMode to ..._QUOTE_FSTRING_MODE by PythonLexerBase class + +mode DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE; // only used after a format specifier colon + DOUBLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE : FORMAT_SPEC_CHAR_NO_DOUBLE_QUOTE+ -> type(FSTRING_MIDDLE); + DOUBLE_QUOTE_FORMAT_SPECIFICATION_LBRACE : '{' -> type(LBRACE); // will be closed in DEFAULT_MODE by PythonLexerBase class + DOUBLE_QUOTE_FORMAT_SPECIFICATION_RBRACE : '}' -> type(RBRACE); // popMode to ..._QUOTE_FSTRING_MODE by PythonLexerBase class + + +/* + * fragments + */ + +fragment IGNORE: 'ignore'; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#literals + +// https://docs.python.org/3.12/reference/lexical_analysis.html#string-and-bytes-literals +fragment STRING_LITERAL : STRING_PREFIX? (SHORT_STRING | LONG_STRING); +fragment STRING_PREFIX : 'r' | 'u' | 'R' | 'U'; + +fragment SHORT_STRING + : '\'' SHORT_STRING_ITEM_FOR_SINGLE_QUOTE* '\'' + | '"' SHORT_STRING_ITEM_FOR_DOUBLE_QUOTE* '"' + ; + +fragment LONG_STRING + : '\'\'\'' LONG_STRING_ITEM*? '\'\'\'' + | '"""' LONG_STRING_ITEM*? '"""' + ; + +fragment SHORT_STRING_ITEM_FOR_SINGLE_QUOTE : SHORT_STRING_CHAR_NO_SINGLE_QUOTE | STRING_ESCAPE_SEQ; +fragment SHORT_STRING_ITEM_FOR_DOUBLE_QUOTE : SHORT_STRING_CHAR_NO_DOUBLE_QUOTE | STRING_ESCAPE_SEQ; + +fragment LONG_STRING_ITEM : LONG_STRING_CHAR | STRING_ESCAPE_SEQ; + +fragment SHORT_STRING_CHAR_NO_SINGLE_QUOTE : ~[\\\r\n']; // +fragment SHORT_STRING_CHAR_NO_DOUBLE_QUOTE : ~[\\\r\n"]; // + +fragment LONG_STRING_CHAR : ~'\\'; // + +fragment STRING_ESCAPE_SEQ // https://docs.python.org/3/reference/lexical_analysis.html#escape-sequences + : '\\' '\r' '\n' // for the two-character Windows line break: \ escape sequence (string literal line continuation) + | '\\' . // "\" + ; + +fragment BYTES_LITERAL : BYTES_PREFIX (SHORT_BYTES | LONG_BYTES); +fragment BYTES_PREFIX : 'b' | 'B' | 'br' | 'Br' | 'bR' | 'BR' | 'rb' | 'rB' | 'Rb' | 'RB'; + +fragment SHORT_BYTES + : '\'' SHORT_BYTES_ITEM_FOR_SINGLE_QUOTE* '\'' + | '"' SHORT_BYTES_ITEM_FOR_DOUBLE_QUOTE* '"' + ; + +fragment LONG_BYTES + : '\'\'\'' LONG_BYTES_ITEM*? '\'\'\'' + | '"""' LONG_BYTES_ITEM*? '"""' + ; + +fragment SHORT_BYTES_ITEM_FOR_SINGLE_QUOTE : SHORT_BYTES_CHAR_NO_SINGLE_QUOTE | BYTES_ESCAPE_SEQ; +fragment SHORT_BYTES_ITEM_FOR_DOUBLE_QUOTE : SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE | BYTES_ESCAPE_SEQ; + +fragment LONG_BYTES_ITEM : LONG_BYTES_CHAR | BYTES_ESCAPE_SEQ; + +fragment SHORT_BYTES_CHAR_NO_SINGLE_QUOTE // + : [\u0000-\u0009] + | [\u000B-\u000C] + | [\u000E-\u0026] + | [\u0028-\u005B] + | [\u005D-\u007F] + ; + +fragment SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE // + : [\u0000-\u0009] + | [\u000B-\u000C] + | [\u000E-\u0021] + | [\u0023-\u005B] + | [\u005D-\u007F] + ; + +fragment LONG_BYTES_CHAR : [\u0000-\u005B] | [\u005D-\u007F]; // +fragment BYTES_ESCAPE_SEQ : '\\' [\u0000-\u007F]; // "\" + +// https://docs.python.org/3.12/library/string.html#format-specification-mini-language +fragment SINGLE_QUOTE_FSTRING_LITERAL : (FORMAT_SPEC_CHAR_NO_SINGLE_QUOTE | DOUBLE_BRACES)+; +fragment DOUBLE_QUOTE_FSTRING_LITERAL : (FORMAT_SPEC_CHAR_NO_DOUBLE_QUOTE | DOUBLE_BRACES)+; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#formatted-string-literals +fragment F_STRING_PREFIX : 'f' | 'F' | 'fr' | 'Fr' | 'fR' | 'FR' | 'rf' | 'rF' | 'Rf' | 'RF'; +fragment FORMAT_SPEC_CHAR_NO_SINGLE_QUOTE : ~[{}']; +fragment FORMAT_SPEC_CHAR_NO_DOUBLE_QUOTE : ~[{}"]; +fragment DOUBLE_BRACES : '{{' | '}}'; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#integer-literals +fragment INTEGER : DEC_INTEGER | BIN_INTEGER | OCT_INTEGER | HEX_INTEGER; +fragment DEC_INTEGER : NON_ZERO_DIGIT ('_'? DIGIT)* | '0'+ ('_'? '0')*; +fragment BIN_INTEGER : '0' ('b' | 'B') ('_'? BIN_DIGIT)+; +fragment OCT_INTEGER : '0' ('o' | 'O') ('_'? OCT_DIGIT)+; +fragment HEX_INTEGER : '0' ('x' | 'X') ('_'? HEX_DIGIT)+; +fragment NON_ZERO_DIGIT : [1-9]; +fragment DIGIT : [0-9]; +fragment BIN_DIGIT : '0' | '1'; +fragment OCT_DIGIT : [0-7]; +fragment HEX_DIGIT : DIGIT | [a-f] | [A-F]; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#floating-point-literals +fragment FLOAT_NUMBER : POINT_FLOAT | EXPONENT_FLOAT; +fragment POINT_FLOAT : DIGIT_PART? FRACTION | DIGIT_PART '.'; +fragment EXPONENT_FLOAT : (DIGIT_PART | POINT_FLOAT) EXPONENT; +fragment DIGIT_PART : DIGIT ('_'? DIGIT)*; +fragment FRACTION : '.' DIGIT_PART; +fragment EXPONENT : ('e' | 'E') ('+' | '-')? DIGIT_PART; + +// https://docs.python.org/3.12/reference/lexical_analysis.html#imaginary-literals +fragment IMAG_NUMBER : (FLOAT_NUMBER | DIGIT_PART) ('j' | 'J'); + +// https://github.com/RobEin/ANTLR4-parser-for-Python-3.12/tree/main/valid_chars_in_py_identifiers +fragment ID_CONTINUE: + ID_START + | '\u{0030}' .. '\u{0039}' + | '\u{00B7}' + | '\u{0300}' .. '\u{036F}' + | '\u{0387}' + | '\u{0483}' .. '\u{0487}' + | '\u{0591}' .. '\u{05BD}' + | '\u{05BF}' + | '\u{05C1}' .. '\u{05C2}' + | '\u{05C4}' .. '\u{05C5}' + | '\u{05C7}' + | '\u{0610}' .. '\u{061A}' + | '\u{064B}' .. '\u{0669}' + | '\u{0670}' + | '\u{06D6}' .. '\u{06DC}' + | '\u{06DF}' .. '\u{06E4}' + | '\u{06E7}' .. '\u{06E8}' + | '\u{06EA}' .. '\u{06ED}' + | '\u{06F0}' .. '\u{06F9}' + | '\u{0711}' + | '\u{0730}' .. '\u{074A}' + | '\u{07A6}' .. '\u{07B0}' + | '\u{07C0}' .. '\u{07C9}' + | '\u{07EB}' .. '\u{07F3}' + | '\u{07FD}' + | '\u{0816}' .. '\u{0819}' + | '\u{081B}' .. '\u{0823}' + | '\u{0825}' .. '\u{0827}' + | '\u{0829}' .. '\u{082D}' + | '\u{0859}' .. '\u{085B}' + | '\u{0898}' .. '\u{089F}' + | '\u{08CA}' .. '\u{08E1}' + | '\u{08E3}' .. '\u{0903}' + | '\u{093A}' .. '\u{093C}' + | '\u{093E}' .. '\u{094F}' + | '\u{0951}' .. '\u{0957}' + | '\u{0962}' .. '\u{0963}' + | '\u{0966}' .. '\u{096F}' + | '\u{0981}' .. '\u{0983}' + | '\u{09BC}' + | '\u{09BE}' .. '\u{09C4}' + | '\u{09C7}' .. '\u{09C8}' + | '\u{09CB}' .. '\u{09CD}' + | '\u{09D7}' + | '\u{09E2}' .. '\u{09E3}' + | '\u{09E6}' .. '\u{09EF}' + | '\u{09FE}' + | '\u{0A01}' .. '\u{0A03}' + | '\u{0A3C}' + | '\u{0A3E}' .. '\u{0A42}' + | '\u{0A47}' .. '\u{0A48}' + | '\u{0A4B}' .. '\u{0A4D}' + | '\u{0A51}' + | '\u{0A66}' .. '\u{0A71}' + | '\u{0A75}' + | '\u{0A81}' .. '\u{0A83}' + | '\u{0ABC}' + | '\u{0ABE}' .. '\u{0AC5}' + | '\u{0AC7}' .. '\u{0AC9}' + | '\u{0ACB}' .. '\u{0ACD}' + | '\u{0AE2}' .. '\u{0AE3}' + | '\u{0AE6}' .. '\u{0AEF}' + | '\u{0AFA}' .. '\u{0AFF}' + | '\u{0B01}' .. '\u{0B03}' + | '\u{0B3C}' + | '\u{0B3E}' .. '\u{0B44}' + | '\u{0B47}' .. '\u{0B48}' + | '\u{0B4B}' .. '\u{0B4D}' + | '\u{0B55}' .. '\u{0B57}' + | '\u{0B62}' .. '\u{0B63}' + | '\u{0B66}' .. '\u{0B6F}' + | '\u{0B82}' + | '\u{0BBE}' .. '\u{0BC2}' + | '\u{0BC6}' .. '\u{0BC8}' + | '\u{0BCA}' .. '\u{0BCD}' + | '\u{0BD7}' + | '\u{0BE6}' .. '\u{0BEF}' + | '\u{0C00}' .. '\u{0C04}' + | '\u{0C3C}' + | '\u{0C3E}' .. '\u{0C44}' + | '\u{0C46}' .. '\u{0C48}' + | '\u{0C4A}' .. '\u{0C4D}' + | '\u{0C55}' .. '\u{0C56}' + | '\u{0C62}' .. '\u{0C63}' + | '\u{0C66}' .. '\u{0C6F}' + | '\u{0C81}' .. '\u{0C83}' + | '\u{0CBC}' + | '\u{0CBE}' .. '\u{0CC4}' + | '\u{0CC6}' .. '\u{0CC8}' + | '\u{0CCA}' .. '\u{0CCD}' + | '\u{0CD5}' .. '\u{0CD6}' + | '\u{0CE2}' .. '\u{0CE3}' + | '\u{0CE6}' .. '\u{0CEF}' + | '\u{0CF3}' + | '\u{0D00}' .. '\u{0D03}' + | '\u{0D3B}' .. '\u{0D3C}' + | '\u{0D3E}' .. '\u{0D44}' + | '\u{0D46}' .. '\u{0D48}' + | '\u{0D4A}' .. '\u{0D4D}' + | '\u{0D57}' + | '\u{0D62}' .. '\u{0D63}' + | '\u{0D66}' .. '\u{0D6F}' + | '\u{0D81}' .. '\u{0D83}' + | '\u{0DCA}' + | '\u{0DCF}' .. '\u{0DD4}' + | '\u{0DD6}' + | '\u{0DD8}' .. '\u{0DDF}' + | '\u{0DE6}' .. '\u{0DEF}' + | '\u{0DF2}' .. '\u{0DF3}' + | '\u{0E31}' + | '\u{0E33}' .. '\u{0E3A}' + | '\u{0E47}' .. '\u{0E4E}' + | '\u{0E50}' .. '\u{0E59}' + | '\u{0EB1}' + | '\u{0EB3}' .. '\u{0EBC}' + | '\u{0EC8}' .. '\u{0ECE}' + | '\u{0ED0}' .. '\u{0ED9}' + | '\u{0F18}' .. '\u{0F19}' + | '\u{0F20}' .. '\u{0F29}' + | '\u{0F35}' + | '\u{0F37}' + | '\u{0F39}' + | '\u{0F3E}' .. '\u{0F3F}' + | '\u{0F71}' .. '\u{0F84}' + | '\u{0F86}' .. '\u{0F87}' + | '\u{0F8D}' .. '\u{0F97}' + | '\u{0F99}' .. '\u{0FBC}' + | '\u{0FC6}' + | '\u{102B}' .. '\u{103E}' + | '\u{1040}' .. '\u{1049}' + | '\u{1056}' .. '\u{1059}' + | '\u{105E}' .. '\u{1060}' + | '\u{1062}' .. '\u{1064}' + | '\u{1067}' .. '\u{106D}' + | '\u{1071}' .. '\u{1074}' + | '\u{1082}' .. '\u{108D}' + | '\u{108F}' .. '\u{109D}' + | '\u{135D}' .. '\u{135F}' + | '\u{1369}' .. '\u{1371}' + | '\u{1712}' .. '\u{1715}' + | '\u{1732}' .. '\u{1734}' + | '\u{1752}' .. '\u{1753}' + | '\u{1772}' .. '\u{1773}' + | '\u{17B4}' .. '\u{17D3}' + | '\u{17DD}' + | '\u{17E0}' .. '\u{17E9}' + | '\u{180B}' .. '\u{180D}' + | '\u{180F}' .. '\u{1819}' + | '\u{18A9}' + | '\u{1920}' .. '\u{192B}' + | '\u{1930}' .. '\u{193B}' + | '\u{1946}' .. '\u{194F}' + | '\u{19D0}' .. '\u{19DA}' + | '\u{1A17}' .. '\u{1A1B}' + | '\u{1A55}' .. '\u{1A5E}' + | '\u{1A60}' .. '\u{1A7C}' + | '\u{1A7F}' .. '\u{1A89}' + | '\u{1A90}' .. '\u{1A99}' + | '\u{1AB0}' .. '\u{1ABD}' + | '\u{1ABF}' .. '\u{1ACE}' + | '\u{1B00}' .. '\u{1B04}' + | '\u{1B34}' .. '\u{1B44}' + | '\u{1B50}' .. '\u{1B59}' + | '\u{1B6B}' .. '\u{1B73}' + | '\u{1B80}' .. '\u{1B82}' + | '\u{1BA1}' .. '\u{1BAD}' + | '\u{1BB0}' .. '\u{1BB9}' + | '\u{1BE6}' .. '\u{1BF3}' + | '\u{1C24}' .. '\u{1C37}' + | '\u{1C40}' .. '\u{1C49}' + | '\u{1C50}' .. '\u{1C59}' + | '\u{1CD0}' .. '\u{1CD2}' + | '\u{1CD4}' .. '\u{1CE8}' + | '\u{1CED}' + | '\u{1CF4}' + | '\u{1CF7}' .. '\u{1CF9}' + | '\u{1DC0}' .. '\u{1DFF}' + | '\u{203F}' .. '\u{2040}' + | '\u{2054}' + | '\u{20D0}' .. '\u{20DC}' + | '\u{20E1}' + | '\u{20E5}' .. '\u{20F0}' + | '\u{2CEF}' .. '\u{2CF1}' + | '\u{2D7F}' + | '\u{2DE0}' .. '\u{2DFF}' + | '\u{302A}' .. '\u{302F}' + | '\u{3099}' .. '\u{309A}' + | '\u{A620}' .. '\u{A629}' + | '\u{A66F}' + | '\u{A674}' .. '\u{A67D}' + | '\u{A69E}' .. '\u{A69F}' + | '\u{A6F0}' .. '\u{A6F1}' + | '\u{A802}' + | '\u{A806}' + | '\u{A80B}' + | '\u{A823}' .. '\u{A827}' + | '\u{A82C}' + | '\u{A880}' .. '\u{A881}' + | '\u{A8B4}' .. '\u{A8C5}' + | '\u{A8D0}' .. '\u{A8D9}' + | '\u{A8E0}' .. '\u{A8F1}' + | '\u{A8FF}' .. '\u{A909}' + | '\u{A926}' .. '\u{A92D}' + | '\u{A947}' .. '\u{A953}' + | '\u{A980}' .. '\u{A983}' + | '\u{A9B3}' .. '\u{A9C0}' + | '\u{A9D0}' .. '\u{A9D9}' + | '\u{A9E5}' + | '\u{A9F0}' .. '\u{A9F9}' + | '\u{AA29}' .. '\u{AA36}' + | '\u{AA43}' + | '\u{AA4C}' .. '\u{AA4D}' + | '\u{AA50}' .. '\u{AA59}' + | '\u{AA7B}' .. '\u{AA7D}' + | '\u{AAB0}' + | '\u{AAB2}' .. '\u{AAB4}' + | '\u{AAB7}' .. '\u{AAB8}' + | '\u{AABE}' .. '\u{AABF}' + | '\u{AAC1}' + | '\u{AAEB}' .. '\u{AAEF}' + | '\u{AAF5}' .. '\u{AAF6}' + | '\u{ABE3}' .. '\u{ABEA}' + | '\u{ABEC}' .. '\u{ABED}' + | '\u{ABF0}' .. '\u{ABF9}' + | '\u{FB1E}' + | '\u{FE00}' .. '\u{FE0F}' + | '\u{FE20}' .. '\u{FE2F}' + | '\u{FE33}' .. '\u{FE34}' + | '\u{FE4D}' .. '\u{FE4F}' + | '\u{FF10}' .. '\u{FF19}' + | '\u{FF3F}' + | '\u{FF9E}' .. '\u{FF9F}' + | '\u{101FD}' + | '\u{102E0}' + | '\u{10376}' .. '\u{1037A}' + | '\u{104A0}' .. '\u{104A9}' + | '\u{10A01}' .. '\u{10A03}' + | '\u{10A05}' .. '\u{10A06}' + | '\u{10A0C}' .. '\u{10A0F}' + | '\u{10A38}' .. '\u{10A3A}' + | '\u{10A3F}' + | '\u{10AE5}' .. '\u{10AE6}' + | '\u{10D24}' .. '\u{10D27}' + | '\u{10D30}' .. '\u{10D39}' + | '\u{10EAB}' .. '\u{10EAC}' + | '\u{10EFD}' .. '\u{10EFF}' + | '\u{10F46}' .. '\u{10F50}' + | '\u{10F82}' .. '\u{10F85}' + | '\u{11000}' .. '\u{11002}' + | '\u{11038}' .. '\u{11046}' + | '\u{11066}' .. '\u{11070}' + | '\u{11073}' .. '\u{11074}' + | '\u{1107F}' .. '\u{11082}' + | '\u{110B0}' .. '\u{110BA}' + | '\u{110C2}' + | '\u{110F0}' .. '\u{110F9}' + | '\u{11100}' .. '\u{11102}' + | '\u{11127}' .. '\u{11134}' + | '\u{11136}' .. '\u{1113F}' + | '\u{11145}' .. '\u{11146}' + | '\u{11173}' + | '\u{11180}' .. '\u{11182}' + | '\u{111B3}' .. '\u{111C0}' + | '\u{111C9}' .. '\u{111CC}' + | '\u{111CE}' .. '\u{111D9}' + | '\u{1122C}' .. '\u{11237}' + | '\u{1123E}' + | '\u{11241}' + | '\u{112DF}' .. '\u{112EA}' + | '\u{112F0}' .. '\u{112F9}' + | '\u{11300}' .. '\u{11303}' + | '\u{1133B}' .. '\u{1133C}' + | '\u{1133E}' .. '\u{11344}' + | '\u{11347}' .. '\u{11348}' + | '\u{1134B}' .. '\u{1134D}' + | '\u{11357}' + | '\u{11362}' .. '\u{11363}' + | '\u{11366}' .. '\u{1136C}' + | '\u{11370}' .. '\u{11374}' + | '\u{11435}' .. '\u{11446}' + | '\u{11450}' .. '\u{11459}' + | '\u{1145E}' + | '\u{114B0}' .. '\u{114C3}' + | '\u{114D0}' .. '\u{114D9}' + | '\u{115AF}' .. '\u{115B5}' + | '\u{115B8}' .. '\u{115C0}' + | '\u{115DC}' .. '\u{115DD}' + | '\u{11630}' .. '\u{11640}' + | '\u{11650}' .. '\u{11659}' + | '\u{116AB}' .. '\u{116B7}' + | '\u{116C0}' .. '\u{116C9}' + | '\u{1171D}' .. '\u{1172B}' + | '\u{11730}' .. '\u{11739}' + | '\u{1182C}' .. '\u{1183A}' + | '\u{118E0}' .. '\u{118E9}' + | '\u{11930}' .. '\u{11935}' + | '\u{11937}' .. '\u{11938}' + | '\u{1193B}' .. '\u{1193E}' + | '\u{11940}' + | '\u{11942}' .. '\u{11943}' + | '\u{11950}' .. '\u{11959}' + | '\u{119D1}' .. '\u{119D7}' + | '\u{119DA}' .. '\u{119E0}' + | '\u{119E4}' + | '\u{11A01}' .. '\u{11A0A}' + | '\u{11A33}' .. '\u{11A39}' + | '\u{11A3B}' .. '\u{11A3E}' + | '\u{11A47}' + | '\u{11A51}' .. '\u{11A5B}' + | '\u{11A8A}' .. '\u{11A99}' + | '\u{11C2F}' .. '\u{11C36}' + | '\u{11C38}' .. '\u{11C3F}' + | '\u{11C50}' .. '\u{11C59}' + | '\u{11C92}' .. '\u{11CA7}' + | '\u{11CA9}' .. '\u{11CB6}' + | '\u{11D31}' .. '\u{11D36}' + | '\u{11D3A}' + | '\u{11D3C}' .. '\u{11D3D}' + | '\u{11D3F}' .. '\u{11D45}' + | '\u{11D47}' + | '\u{11D50}' .. '\u{11D59}' + | '\u{11D8A}' .. '\u{11D8E}' + | '\u{11D90}' .. '\u{11D91}' + | '\u{11D93}' .. '\u{11D97}' + | '\u{11DA0}' .. '\u{11DA9}' + | '\u{11EF3}' .. '\u{11EF6}' + | '\u{11F00}' .. '\u{11F01}' + | '\u{11F03}' + | '\u{11F34}' .. '\u{11F3A}' + | '\u{11F3E}' .. '\u{11F42}' + | '\u{11F50}' .. '\u{11F59}' + | '\u{13440}' + | '\u{13447}' .. '\u{13455}' + | '\u{16A60}' .. '\u{16A69}' + | '\u{16AC0}' .. '\u{16AC9}' + | '\u{16AF0}' .. '\u{16AF4}' + | '\u{16B30}' .. '\u{16B36}' + | '\u{16B50}' .. '\u{16B59}' + | '\u{16F4F}' + | '\u{16F51}' .. '\u{16F87}' + | '\u{16F8F}' .. '\u{16F92}' + | '\u{16FE4}' + | '\u{16FF0}' .. '\u{16FF1}' + | '\u{1BC9D}' .. '\u{1BC9E}' + | '\u{1CF00}' .. '\u{1CF2D}' + | '\u{1CF30}' .. '\u{1CF46}' + | '\u{1D165}' .. '\u{1D169}' + | '\u{1D16D}' .. '\u{1D172}' + | '\u{1D17B}' .. '\u{1D182}' + | '\u{1D185}' .. '\u{1D18B}' + | '\u{1D1AA}' .. '\u{1D1AD}' + | '\u{1D242}' .. '\u{1D244}' + | '\u{1D7CE}' .. '\u{1D7FF}' + | '\u{1DA00}' .. '\u{1DA36}' + | '\u{1DA3B}' .. '\u{1DA6C}' + | '\u{1DA75}' + | '\u{1DA84}' + | '\u{1DA9B}' .. '\u{1DA9F}' + | '\u{1DAA1}' .. '\u{1DAAF}' + | '\u{1E000}' .. '\u{1E006}' + | '\u{1E008}' .. '\u{1E018}' + | '\u{1E01B}' .. '\u{1E021}' + | '\u{1E023}' .. '\u{1E024}' + | '\u{1E026}' .. '\u{1E02A}' + | '\u{1E08F}' + | '\u{1E130}' .. '\u{1E136}' + | '\u{1E140}' .. '\u{1E149}' + | '\u{1E2AE}' + | '\u{1E2EC}' .. '\u{1E2F9}' + | '\u{1E4EC}' .. '\u{1E4F9}' + | '\u{1E8D0}' .. '\u{1E8D6}' + | '\u{1E944}' .. '\u{1E94A}' + | '\u{1E950}' .. '\u{1E959}' + | '\u{1FBF0}' .. '\u{1FBF9}' + | '\u{E0100}' .. '\u{E01EF}' +; + +// https://github.com/RobEin/ANTLR4-parser-for-Python-3.12/tree/main/valid_chars_in_py_identifiers +fragment ID_START: + '\u{0041}' .. '\u{005A}' + | '\u{005F}' + | '\u{0061}' .. '\u{007A}' + | '\u{00AA}' + | '\u{00B5}' + | '\u{00BA}' + | '\u{00C0}' .. '\u{00D6}' + | '\u{00D8}' .. '\u{00F6}' + | '\u{00F8}' .. '\u{02C1}' + | '\u{02C6}' .. '\u{02D1}' + | '\u{02E0}' .. '\u{02E4}' + | '\u{02EC}' + | '\u{02EE}' + | '\u{0370}' .. '\u{0374}' + | '\u{0376}' .. '\u{0377}' + | '\u{037B}' .. '\u{037D}' + | '\u{037F}' + | '\u{0386}' + | '\u{0388}' .. '\u{038A}' + | '\u{038C}' + | '\u{038E}' .. '\u{03A1}' + | '\u{03A3}' .. '\u{03F5}' + | '\u{03F7}' .. '\u{0481}' + | '\u{048A}' .. '\u{052F}' + | '\u{0531}' .. '\u{0556}' + | '\u{0559}' + | '\u{0560}' .. '\u{0588}' + | '\u{05D0}' .. '\u{05EA}' + | '\u{05EF}' .. '\u{05F2}' + | '\u{0620}' .. '\u{064A}' + | '\u{066E}' .. '\u{066F}' + | '\u{0671}' .. '\u{06D3}' + | '\u{06D5}' + | '\u{06E5}' .. '\u{06E6}' + | '\u{06EE}' .. '\u{06EF}' + | '\u{06FA}' .. '\u{06FC}' + | '\u{06FF}' + | '\u{0710}' + | '\u{0712}' .. '\u{072F}' + | '\u{074D}' .. '\u{07A5}' + | '\u{07B1}' + | '\u{07CA}' .. '\u{07EA}' + | '\u{07F4}' .. '\u{07F5}' + | '\u{07FA}' + | '\u{0800}' .. '\u{0815}' + | '\u{081A}' + | '\u{0824}' + | '\u{0828}' + | '\u{0840}' .. '\u{0858}' + | '\u{0860}' .. '\u{086A}' + | '\u{0870}' .. '\u{0887}' + | '\u{0889}' .. '\u{088E}' + | '\u{08A0}' .. '\u{08C9}' + | '\u{0904}' .. '\u{0939}' + | '\u{093D}' + | '\u{0950}' + | '\u{0958}' .. '\u{0961}' + | '\u{0971}' .. '\u{0980}' + | '\u{0985}' .. '\u{098C}' + | '\u{098F}' .. '\u{0990}' + | '\u{0993}' .. '\u{09A8}' + | '\u{09AA}' .. '\u{09B0}' + | '\u{09B2}' + | '\u{09B6}' .. '\u{09B9}' + | '\u{09BD}' + | '\u{09CE}' + | '\u{09DC}' .. '\u{09DD}' + | '\u{09DF}' .. '\u{09E1}' + | '\u{09F0}' .. '\u{09F1}' + | '\u{09FC}' + | '\u{0A05}' .. '\u{0A0A}' + | '\u{0A0F}' .. '\u{0A10}' + | '\u{0A13}' .. '\u{0A28}' + | '\u{0A2A}' .. '\u{0A30}' + | '\u{0A32}' .. '\u{0A33}' + | '\u{0A35}' .. '\u{0A36}' + | '\u{0A38}' .. '\u{0A39}' + | '\u{0A59}' .. '\u{0A5C}' + | '\u{0A5E}' + | '\u{0A72}' .. '\u{0A74}' + | '\u{0A85}' .. '\u{0A8D}' + | '\u{0A8F}' .. '\u{0A91}' + | '\u{0A93}' .. '\u{0AA8}' + | '\u{0AAA}' .. '\u{0AB0}' + | '\u{0AB2}' .. '\u{0AB3}' + | '\u{0AB5}' .. '\u{0AB9}' + | '\u{0ABD}' + | '\u{0AD0}' + | '\u{0AE0}' .. '\u{0AE1}' + | '\u{0AF9}' + | '\u{0B05}' .. '\u{0B0C}' + | '\u{0B0F}' .. '\u{0B10}' + | '\u{0B13}' .. '\u{0B28}' + | '\u{0B2A}' .. '\u{0B30}' + | '\u{0B32}' .. '\u{0B33}' + | '\u{0B35}' .. '\u{0B39}' + | '\u{0B3D}' + | '\u{0B5C}' .. '\u{0B5D}' + | '\u{0B5F}' .. '\u{0B61}' + | '\u{0B71}' + | '\u{0B83}' + | '\u{0B85}' .. '\u{0B8A}' + | '\u{0B8E}' .. '\u{0B90}' + | '\u{0B92}' .. '\u{0B95}' + | '\u{0B99}' .. '\u{0B9A}' + | '\u{0B9C}' + | '\u{0B9E}' .. '\u{0B9F}' + | '\u{0BA3}' .. '\u{0BA4}' + | '\u{0BA8}' .. '\u{0BAA}' + | '\u{0BAE}' .. '\u{0BB9}' + | '\u{0BD0}' + | '\u{0C05}' .. '\u{0C0C}' + | '\u{0C0E}' .. '\u{0C10}' + | '\u{0C12}' .. '\u{0C28}' + | '\u{0C2A}' .. '\u{0C39}' + | '\u{0C3D}' + | '\u{0C58}' .. '\u{0C5A}' + | '\u{0C5D}' + | '\u{0C60}' .. '\u{0C61}' + | '\u{0C80}' + | '\u{0C85}' .. '\u{0C8C}' + | '\u{0C8E}' .. '\u{0C90}' + | '\u{0C92}' .. '\u{0CA8}' + | '\u{0CAA}' .. '\u{0CB3}' + | '\u{0CB5}' .. '\u{0CB9}' + | '\u{0CBD}' + | '\u{0CDD}' .. '\u{0CDE}' + | '\u{0CE0}' .. '\u{0CE1}' + | '\u{0CF1}' .. '\u{0CF2}' + | '\u{0D04}' .. '\u{0D0C}' + | '\u{0D0E}' .. '\u{0D10}' + | '\u{0D12}' .. '\u{0D3A}' + | '\u{0D3D}' + | '\u{0D4E}' + | '\u{0D54}' .. '\u{0D56}' + | '\u{0D5F}' .. '\u{0D61}' + | '\u{0D7A}' .. '\u{0D7F}' + | '\u{0D85}' .. '\u{0D96}' + | '\u{0D9A}' .. '\u{0DB1}' + | '\u{0DB3}' .. '\u{0DBB}' + | '\u{0DBD}' + | '\u{0DC0}' .. '\u{0DC6}' + | '\u{0E01}' .. '\u{0E30}' + | '\u{0E32}' + | '\u{0E40}' .. '\u{0E46}' + | '\u{0E81}' .. '\u{0E82}' + | '\u{0E84}' + | '\u{0E86}' .. '\u{0E8A}' + | '\u{0E8C}' .. '\u{0EA3}' + | '\u{0EA5}' + | '\u{0EA7}' .. '\u{0EB0}' + | '\u{0EB2}' + | '\u{0EBD}' + | '\u{0EC0}' .. '\u{0EC4}' + | '\u{0EC6}' + | '\u{0EDC}' .. '\u{0EDF}' + | '\u{0F00}' + | '\u{0F40}' .. '\u{0F47}' + | '\u{0F49}' .. '\u{0F6C}' + | '\u{0F88}' .. '\u{0F8C}' + | '\u{1000}' .. '\u{102A}' + | '\u{103F}' + | '\u{1050}' .. '\u{1055}' + | '\u{105A}' .. '\u{105D}' + | '\u{1061}' + | '\u{1065}' .. '\u{1066}' + | '\u{106E}' .. '\u{1070}' + | '\u{1075}' .. '\u{1081}' + | '\u{108E}' + | '\u{10A0}' .. '\u{10C5}' + | '\u{10C7}' + | '\u{10CD}' + | '\u{10D0}' .. '\u{10FA}' + | '\u{10FC}' .. '\u{1248}' + | '\u{124A}' .. '\u{124D}' + | '\u{1250}' .. '\u{1256}' + | '\u{1258}' + | '\u{125A}' .. '\u{125D}' + | '\u{1260}' .. '\u{1288}' + | '\u{128A}' .. '\u{128D}' + | '\u{1290}' .. '\u{12B0}' + | '\u{12B2}' .. '\u{12B5}' + | '\u{12B8}' .. '\u{12BE}' + | '\u{12C0}' + | '\u{12C2}' .. '\u{12C5}' + | '\u{12C8}' .. '\u{12D6}' + | '\u{12D8}' .. '\u{1310}' + | '\u{1312}' .. '\u{1315}' + | '\u{1318}' .. '\u{135A}' + | '\u{1380}' .. '\u{138F}' + | '\u{13A0}' .. '\u{13F5}' + | '\u{13F8}' .. '\u{13FD}' + | '\u{1401}' .. '\u{166C}' + | '\u{166F}' .. '\u{167F}' + | '\u{1681}' .. '\u{169A}' + | '\u{16A0}' .. '\u{16EA}' + | '\u{16EE}' .. '\u{16F8}' + | '\u{1700}' .. '\u{1711}' + | '\u{171F}' .. '\u{1731}' + | '\u{1740}' .. '\u{1751}' + | '\u{1760}' .. '\u{176C}' + | '\u{176E}' .. '\u{1770}' + | '\u{1780}' .. '\u{17B3}' + | '\u{17D7}' + | '\u{17DC}' + | '\u{1820}' .. '\u{1878}' + | '\u{1880}' .. '\u{18A8}' + | '\u{18AA}' + | '\u{18B0}' .. '\u{18F5}' + | '\u{1900}' .. '\u{191E}' + | '\u{1950}' .. '\u{196D}' + | '\u{1970}' .. '\u{1974}' + | '\u{1980}' .. '\u{19AB}' + | '\u{19B0}' .. '\u{19C9}' + | '\u{1A00}' .. '\u{1A16}' + | '\u{1A20}' .. '\u{1A54}' + | '\u{1AA7}' + | '\u{1B05}' .. '\u{1B33}' + | '\u{1B45}' .. '\u{1B4C}' + | '\u{1B83}' .. '\u{1BA0}' + | '\u{1BAE}' .. '\u{1BAF}' + | '\u{1BBA}' .. '\u{1BE5}' + | '\u{1C00}' .. '\u{1C23}' + | '\u{1C4D}' .. '\u{1C4F}' + | '\u{1C5A}' .. '\u{1C7D}' + | '\u{1C80}' .. '\u{1C88}' + | '\u{1C90}' .. '\u{1CBA}' + | '\u{1CBD}' .. '\u{1CBF}' + | '\u{1CE9}' .. '\u{1CEC}' + | '\u{1CEE}' .. '\u{1CF3}' + | '\u{1CF5}' .. '\u{1CF6}' + | '\u{1CFA}' + | '\u{1D00}' .. '\u{1DBF}' + | '\u{1E00}' .. '\u{1F15}' + | '\u{1F18}' .. '\u{1F1D}' + | '\u{1F20}' .. '\u{1F45}' + | '\u{1F48}' .. '\u{1F4D}' + | '\u{1F50}' .. '\u{1F57}' + | '\u{1F59}' + | '\u{1F5B}' + | '\u{1F5D}' + | '\u{1F5F}' .. '\u{1F7D}' + | '\u{1F80}' .. '\u{1FB4}' + | '\u{1FB6}' .. '\u{1FBC}' + | '\u{1FBE}' + | '\u{1FC2}' .. '\u{1FC4}' + | '\u{1FC6}' .. '\u{1FCC}' + | '\u{1FD0}' .. '\u{1FD3}' + | '\u{1FD6}' .. '\u{1FDB}' + | '\u{1FE0}' .. '\u{1FEC}' + | '\u{1FF2}' .. '\u{1FF4}' + | '\u{1FF6}' .. '\u{1FFC}' + | '\u{2071}' + | '\u{207F}' + | '\u{2090}' .. '\u{209C}' + | '\u{2102}' + | '\u{2107}' + | '\u{210A}' .. '\u{2113}' + | '\u{2115}' + | '\u{2118}' .. '\u{211D}' + | '\u{2124}' + | '\u{2126}' + | '\u{2128}' + | '\u{212A}' .. '\u{2139}' + | '\u{213C}' .. '\u{213F}' + | '\u{2145}' .. '\u{2149}' + | '\u{214E}' + | '\u{2160}' .. '\u{2188}' + | '\u{2C00}' .. '\u{2CE4}' + | '\u{2CEB}' .. '\u{2CEE}' + | '\u{2CF2}' .. '\u{2CF3}' + | '\u{2D00}' .. '\u{2D25}' + | '\u{2D27}' + | '\u{2D2D}' + | '\u{2D30}' .. '\u{2D67}' + | '\u{2D6F}' + | '\u{2D80}' .. '\u{2D96}' + | '\u{2DA0}' .. '\u{2DA6}' + | '\u{2DA8}' .. '\u{2DAE}' + | '\u{2DB0}' .. '\u{2DB6}' + | '\u{2DB8}' .. '\u{2DBE}' + | '\u{2DC0}' .. '\u{2DC6}' + | '\u{2DC8}' .. '\u{2DCE}' + | '\u{2DD0}' .. '\u{2DD6}' + | '\u{2DD8}' .. '\u{2DDE}' + | '\u{3005}' .. '\u{3007}' + | '\u{3021}' .. '\u{3029}' + | '\u{3031}' .. '\u{3035}' + | '\u{3038}' .. '\u{303C}' + | '\u{3041}' .. '\u{3096}' + | '\u{309D}' .. '\u{309F}' + | '\u{30A1}' .. '\u{30FA}' + | '\u{30FC}' .. '\u{30FF}' + | '\u{3105}' .. '\u{312F}' + | '\u{3131}' .. '\u{318E}' + | '\u{31A0}' .. '\u{31BF}' + | '\u{31F0}' .. '\u{31FF}' + | '\u{3400}' .. '\u{4DBF}' + | '\u{4E00}' .. '\u{A48C}' + | '\u{A4D0}' .. '\u{A4FD}' + | '\u{A500}' .. '\u{A60C}' + | '\u{A610}' .. '\u{A61F}' + | '\u{A62A}' .. '\u{A62B}' + | '\u{A640}' .. '\u{A66E}' + | '\u{A67F}' .. '\u{A69D}' + | '\u{A6A0}' .. '\u{A6EF}' + | '\u{A717}' .. '\u{A71F}' + | '\u{A722}' .. '\u{A788}' + | '\u{A78B}' .. '\u{A7CA}' + | '\u{A7D0}' .. '\u{A7D1}' + | '\u{A7D3}' + | '\u{A7D5}' .. '\u{A7D9}' + | '\u{A7F2}' .. '\u{A801}' + | '\u{A803}' .. '\u{A805}' + | '\u{A807}' .. '\u{A80A}' + | '\u{A80C}' .. '\u{A822}' + | '\u{A840}' .. '\u{A873}' + | '\u{A882}' .. '\u{A8B3}' + | '\u{A8F2}' .. '\u{A8F7}' + | '\u{A8FB}' + | '\u{A8FD}' .. '\u{A8FE}' + | '\u{A90A}' .. '\u{A925}' + | '\u{A930}' .. '\u{A946}' + | '\u{A960}' .. '\u{A97C}' + | '\u{A984}' .. '\u{A9B2}' + | '\u{A9CF}' + | '\u{A9E0}' .. '\u{A9E4}' + | '\u{A9E6}' .. '\u{A9EF}' + | '\u{A9FA}' .. '\u{A9FE}' + | '\u{AA00}' .. '\u{AA28}' + | '\u{AA40}' .. '\u{AA42}' + | '\u{AA44}' .. '\u{AA4B}' + | '\u{AA60}' .. '\u{AA76}' + | '\u{AA7A}' + | '\u{AA7E}' .. '\u{AAAF}' + | '\u{AAB1}' + | '\u{AAB5}' .. '\u{AAB6}' + | '\u{AAB9}' .. '\u{AABD}' + | '\u{AAC0}' + | '\u{AAC2}' + | '\u{AADB}' .. '\u{AADD}' + | '\u{AAE0}' .. '\u{AAEA}' + | '\u{AAF2}' .. '\u{AAF4}' + | '\u{AB01}' .. '\u{AB06}' + | '\u{AB09}' .. '\u{AB0E}' + | '\u{AB11}' .. '\u{AB16}' + | '\u{AB20}' .. '\u{AB26}' + | '\u{AB28}' .. '\u{AB2E}' + | '\u{AB30}' .. '\u{AB5A}' + | '\u{AB5C}' .. '\u{AB69}' + | '\u{AB70}' .. '\u{ABE2}' + | '\u{AC00}' .. '\u{D7A3}' + | '\u{D7B0}' .. '\u{D7C6}' + | '\u{D7CB}' .. '\u{D7FB}' + | '\u{F900}' .. '\u{FA6D}' + | '\u{FA70}' .. '\u{FAD9}' + | '\u{FB00}' .. '\u{FB06}' + | '\u{FB13}' .. '\u{FB17}' + | '\u{FB1D}' + | '\u{FB1F}' .. '\u{FB28}' + | '\u{FB2A}' .. '\u{FB36}' + | '\u{FB38}' .. '\u{FB3C}' + | '\u{FB3E}' + | '\u{FB40}' .. '\u{FB41}' + | '\u{FB43}' .. '\u{FB44}' + | '\u{FB46}' .. '\u{FBB1}' + | '\u{FBD3}' .. '\u{FC5D}' + | '\u{FC64}' .. '\u{FD3D}' + | '\u{FD50}' .. '\u{FD8F}' + | '\u{FD92}' .. '\u{FDC7}' + | '\u{FDF0}' .. '\u{FDF9}' + | '\u{FE71}' + | '\u{FE73}' + | '\u{FE77}' + | '\u{FE79}' + | '\u{FE7B}' + | '\u{FE7D}' + | '\u{FE7F}' .. '\u{FEFC}' + | '\u{FF21}' .. '\u{FF3A}' + | '\u{FF41}' .. '\u{FF5A}' + | '\u{FF66}' .. '\u{FF9D}' + | '\u{FFA0}' .. '\u{FFBE}' + | '\u{FFC2}' .. '\u{FFC7}' + | '\u{FFCA}' .. '\u{FFCF}' + | '\u{FFD2}' .. '\u{FFD7}' + | '\u{FFDA}' .. '\u{FFDC}' + | '\u{10000}' .. '\u{1000B}' + | '\u{1000D}' .. '\u{10026}' + | '\u{10028}' .. '\u{1003A}' + | '\u{1003C}' .. '\u{1003D}' + | '\u{1003F}' .. '\u{1004D}' + | '\u{10050}' .. '\u{1005D}' + | '\u{10080}' .. '\u{100FA}' + | '\u{10140}' .. '\u{10174}' + | '\u{10280}' .. '\u{1029C}' + | '\u{102A0}' .. '\u{102D0}' + | '\u{10300}' .. '\u{1031F}' + | '\u{1032D}' .. '\u{1034A}' + | '\u{10350}' .. '\u{10375}' + | '\u{10380}' .. '\u{1039D}' + | '\u{103A0}' .. '\u{103C3}' + | '\u{103C8}' .. '\u{103CF}' + | '\u{103D1}' .. '\u{103D5}' + | '\u{10400}' .. '\u{1049D}' + | '\u{104B0}' .. '\u{104D3}' + | '\u{104D8}' .. '\u{104FB}' + | '\u{10500}' .. '\u{10527}' + | '\u{10530}' .. '\u{10563}' + | '\u{10570}' .. '\u{1057A}' + | '\u{1057C}' .. '\u{1058A}' + | '\u{1058C}' .. '\u{10592}' + | '\u{10594}' .. '\u{10595}' + | '\u{10597}' .. '\u{105A1}' + | '\u{105A3}' .. '\u{105B1}' + | '\u{105B3}' .. '\u{105B9}' + | '\u{105BB}' .. '\u{105BC}' + | '\u{10600}' .. '\u{10736}' + | '\u{10740}' .. '\u{10755}' + | '\u{10760}' .. '\u{10767}' + | '\u{10780}' .. '\u{10785}' + | '\u{10787}' .. '\u{107B0}' + | '\u{107B2}' .. '\u{107BA}' + | '\u{10800}' .. '\u{10805}' + | '\u{10808}' + | '\u{1080A}' .. '\u{10835}' + | '\u{10837}' .. '\u{10838}' + | '\u{1083C}' + | '\u{1083F}' .. '\u{10855}' + | '\u{10860}' .. '\u{10876}' + | '\u{10880}' .. '\u{1089E}' + | '\u{108E0}' .. '\u{108F2}' + | '\u{108F4}' .. '\u{108F5}' + | '\u{10900}' .. '\u{10915}' + | '\u{10920}' .. '\u{10939}' + | '\u{10980}' .. '\u{109B7}' + | '\u{109BE}' .. '\u{109BF}' + | '\u{10A00}' + | '\u{10A10}' .. '\u{10A13}' + | '\u{10A15}' .. '\u{10A17}' + | '\u{10A19}' .. '\u{10A35}' + | '\u{10A60}' .. '\u{10A7C}' + | '\u{10A80}' .. '\u{10A9C}' + | '\u{10AC0}' .. '\u{10AC7}' + | '\u{10AC9}' .. '\u{10AE4}' + | '\u{10B00}' .. '\u{10B35}' + | '\u{10B40}' .. '\u{10B55}' + | '\u{10B60}' .. '\u{10B72}' + | '\u{10B80}' .. '\u{10B91}' + | '\u{10C00}' .. '\u{10C48}' + | '\u{10C80}' .. '\u{10CB2}' + | '\u{10CC0}' .. '\u{10CF2}' + | '\u{10D00}' .. '\u{10D23}' + | '\u{10E80}' .. '\u{10EA9}' + | '\u{10EB0}' .. '\u{10EB1}' + | '\u{10F00}' .. '\u{10F1C}' + | '\u{10F27}' + | '\u{10F30}' .. '\u{10F45}' + | '\u{10F70}' .. '\u{10F81}' + | '\u{10FB0}' .. '\u{10FC4}' + | '\u{10FE0}' .. '\u{10FF6}' + | '\u{11003}' .. '\u{11037}' + | '\u{11071}' .. '\u{11072}' + | '\u{11075}' + | '\u{11083}' .. '\u{110AF}' + | '\u{110D0}' .. '\u{110E8}' + | '\u{11103}' .. '\u{11126}' + | '\u{11144}' + | '\u{11147}' + | '\u{11150}' .. '\u{11172}' + | '\u{11176}' + | '\u{11183}' .. '\u{111B2}' + | '\u{111C1}' .. '\u{111C4}' + | '\u{111DA}' + | '\u{111DC}' + | '\u{11200}' .. '\u{11211}' + | '\u{11213}' .. '\u{1122B}' + | '\u{1123F}' .. '\u{11240}' + | '\u{11280}' .. '\u{11286}' + | '\u{11288}' + | '\u{1128A}' .. '\u{1128D}' + | '\u{1128F}' .. '\u{1129D}' + | '\u{1129F}' .. '\u{112A8}' + | '\u{112B0}' .. '\u{112DE}' + | '\u{11305}' .. '\u{1130C}' + | '\u{1130F}' .. '\u{11310}' + | '\u{11313}' .. '\u{11328}' + | '\u{1132A}' .. '\u{11330}' + | '\u{11332}' .. '\u{11333}' + | '\u{11335}' .. '\u{11339}' + | '\u{1133D}' + | '\u{11350}' + | '\u{1135D}' .. '\u{11361}' + | '\u{11400}' .. '\u{11434}' + | '\u{11447}' .. '\u{1144A}' + | '\u{1145F}' .. '\u{11461}' + | '\u{11480}' .. '\u{114AF}' + | '\u{114C4}' .. '\u{114C5}' + | '\u{114C7}' + | '\u{11580}' .. '\u{115AE}' + | '\u{115D8}' .. '\u{115DB}' + | '\u{11600}' .. '\u{1162F}' + | '\u{11644}' + | '\u{11680}' .. '\u{116AA}' + | '\u{116B8}' + | '\u{11700}' .. '\u{1171A}' + | '\u{11740}' .. '\u{11746}' + | '\u{11800}' .. '\u{1182B}' + | '\u{118A0}' .. '\u{118DF}' + | '\u{118FF}' .. '\u{11906}' + | '\u{11909}' + | '\u{1190C}' .. '\u{11913}' + | '\u{11915}' .. '\u{11916}' + | '\u{11918}' .. '\u{1192F}' + | '\u{1193F}' + | '\u{11941}' + | '\u{119A0}' .. '\u{119A7}' + | '\u{119AA}' .. '\u{119D0}' + | '\u{119E1}' + | '\u{119E3}' + | '\u{11A00}' + | '\u{11A0B}' .. '\u{11A32}' + | '\u{11A3A}' + | '\u{11A50}' + | '\u{11A5C}' .. '\u{11A89}' + | '\u{11A9D}' + | '\u{11AB0}' .. '\u{11AF8}' + | '\u{11C00}' .. '\u{11C08}' + | '\u{11C0A}' .. '\u{11C2E}' + | '\u{11C40}' + | '\u{11C72}' .. '\u{11C8F}' + | '\u{11D00}' .. '\u{11D06}' + | '\u{11D08}' .. '\u{11D09}' + | '\u{11D0B}' .. '\u{11D30}' + | '\u{11D46}' + | '\u{11D60}' .. '\u{11D65}' + | '\u{11D67}' .. '\u{11D68}' + | '\u{11D6A}' .. '\u{11D89}' + | '\u{11D98}' + | '\u{11EE0}' .. '\u{11EF2}' + | '\u{11F02}' + | '\u{11F04}' .. '\u{11F10}' + | '\u{11F12}' .. '\u{11F33}' + | '\u{11FB0}' + | '\u{12000}' .. '\u{12399}' + | '\u{12400}' .. '\u{1246E}' + | '\u{12480}' .. '\u{12543}' + | '\u{12F90}' .. '\u{12FF0}' + | '\u{13000}' .. '\u{1342F}' + | '\u{13441}' .. '\u{13446}' + | '\u{14400}' .. '\u{14646}' + | '\u{16800}' .. '\u{16A38}' + | '\u{16A40}' .. '\u{16A5E}' + | '\u{16A70}' .. '\u{16ABE}' + | '\u{16AD0}' .. '\u{16AED}' + | '\u{16B00}' .. '\u{16B2F}' + | '\u{16B40}' .. '\u{16B43}' + | '\u{16B63}' .. '\u{16B77}' + | '\u{16B7D}' .. '\u{16B8F}' + | '\u{16E40}' .. '\u{16E7F}' + | '\u{16F00}' .. '\u{16F4A}' + | '\u{16F50}' + | '\u{16F93}' .. '\u{16F9F}' + | '\u{16FE0}' .. '\u{16FE1}' + | '\u{16FE3}' + | '\u{17000}' .. '\u{187F7}' + | '\u{18800}' .. '\u{18CD5}' + | '\u{18D00}' .. '\u{18D08}' + | '\u{1AFF0}' .. '\u{1AFF3}' + | '\u{1AFF5}' .. '\u{1AFFB}' + | '\u{1AFFD}' .. '\u{1AFFE}' + | '\u{1B000}' .. '\u{1B122}' + | '\u{1B132}' + | '\u{1B150}' .. '\u{1B152}' + | '\u{1B155}' + | '\u{1B164}' .. '\u{1B167}' + | '\u{1B170}' .. '\u{1B2FB}' + | '\u{1BC00}' .. '\u{1BC6A}' + | '\u{1BC70}' .. '\u{1BC7C}' + | '\u{1BC80}' .. '\u{1BC88}' + | '\u{1BC90}' .. '\u{1BC99}' + | '\u{1D400}' .. '\u{1D454}' + | '\u{1D456}' .. '\u{1D49C}' + | '\u{1D49E}' .. '\u{1D49F}' + | '\u{1D4A2}' + | '\u{1D4A5}' .. '\u{1D4A6}' + | '\u{1D4A9}' .. '\u{1D4AC}' + | '\u{1D4AE}' .. '\u{1D4B9}' + | '\u{1D4BB}' + | '\u{1D4BD}' .. '\u{1D4C3}' + | '\u{1D4C5}' .. '\u{1D505}' + | '\u{1D507}' .. '\u{1D50A}' + | '\u{1D50D}' .. '\u{1D514}' + | '\u{1D516}' .. '\u{1D51C}' + | '\u{1D51E}' .. '\u{1D539}' + | '\u{1D53B}' .. '\u{1D53E}' + | '\u{1D540}' .. '\u{1D544}' + | '\u{1D546}' + | '\u{1D54A}' .. '\u{1D550}' + | '\u{1D552}' .. '\u{1D6A5}' + | '\u{1D6A8}' .. '\u{1D6C0}' + | '\u{1D6C2}' .. '\u{1D6DA}' + | '\u{1D6DC}' .. '\u{1D6FA}' + | '\u{1D6FC}' .. '\u{1D714}' + | '\u{1D716}' .. '\u{1D734}' + | '\u{1D736}' .. '\u{1D74E}' + | '\u{1D750}' .. '\u{1D76E}' + | '\u{1D770}' .. '\u{1D788}' + | '\u{1D78A}' .. '\u{1D7A8}' + | '\u{1D7AA}' .. '\u{1D7C2}' + | '\u{1D7C4}' .. '\u{1D7CB}' + | '\u{1DF00}' .. '\u{1DF1E}' + | '\u{1DF25}' .. '\u{1DF2A}' + | '\u{1E030}' .. '\u{1E06D}' + | '\u{1E100}' .. '\u{1E12C}' + | '\u{1E137}' .. '\u{1E13D}' + | '\u{1E14E}' + | '\u{1E290}' .. '\u{1E2AD}' + | '\u{1E2C0}' .. '\u{1E2EB}' + | '\u{1E4D0}' .. '\u{1E4EB}' + | '\u{1E7E0}' .. '\u{1E7E6}' + | '\u{1E7E8}' .. '\u{1E7EB}' + | '\u{1E7ED}' .. '\u{1E7EE}' + | '\u{1E7F0}' .. '\u{1E7FE}' + | '\u{1E800}' .. '\u{1E8C4}' + | '\u{1E900}' .. '\u{1E943}' + | '\u{1E94B}' + | '\u{1EE00}' .. '\u{1EE03}' + | '\u{1EE05}' .. '\u{1EE1F}' + | '\u{1EE21}' .. '\u{1EE22}' + | '\u{1EE24}' + | '\u{1EE27}' + | '\u{1EE29}' .. '\u{1EE32}' + | '\u{1EE34}' .. '\u{1EE37}' + | '\u{1EE39}' + | '\u{1EE3B}' + | '\u{1EE42}' + | '\u{1EE47}' + | '\u{1EE49}' + | '\u{1EE4B}' + | '\u{1EE4D}' .. '\u{1EE4F}' + | '\u{1EE51}' .. '\u{1EE52}' + | '\u{1EE54}' + | '\u{1EE57}' + | '\u{1EE59}' + | '\u{1EE5B}' + | '\u{1EE5D}' + | '\u{1EE5F}' + | '\u{1EE61}' .. '\u{1EE62}' + | '\u{1EE64}' + | '\u{1EE67}' .. '\u{1EE6A}' + | '\u{1EE6C}' .. '\u{1EE72}' + | '\u{1EE74}' .. '\u{1EE77}' + | '\u{1EE79}' .. '\u{1EE7C}' + | '\u{1EE7E}' + | '\u{1EE80}' .. '\u{1EE89}' + | '\u{1EE8B}' .. '\u{1EE9B}' + | '\u{1EEA1}' .. '\u{1EEA3}' + | '\u{1EEA5}' .. '\u{1EEA9}' + | '\u{1EEAB}' .. '\u{1EEBB}' + | '\u{20000}' .. '\u{2A6DF}' + | '\u{2A700}' .. '\u{2B739}' + | '\u{2B740}' .. '\u{2B81D}' + | '\u{2B820}' .. '\u{2CEA1}' + | '\u{2CEB0}' .. '\u{2EBE0}' + | '\u{2F800}' .. '\u{2FA1D}' + | '\u{30000}' .. '\u{3134A}' + | '\u{31350}' .. '\u{323AF}' +; diff --git a/src/main/antlr/PythonParser.g4 b/src/main/antlr/PythonParser.g4 new file mode 100644 index 0000000..479ad92 --- /dev/null +++ b/src/main/antlr/PythonParser.g4 @@ -0,0 +1,884 @@ +/* +Python grammar +The MIT License (MIT) +Copyright (c) 2021 Robert Einhorn + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + */ + + /* + * Project : an ANTLR4 parser grammar by the official PEG grammar + * https://github.com/RobEin/ANTLR4-parser-for-Python-3.12 + * Developed by : Robert Einhorn + * + */ + + /* + * Contributors : + * [Willie Shen](https://github.com/Willie169) : Fix that `case [a, *_] if a == 0:` throws error `rule soft_kw__not__wildcard failed predicate: {this.isnotEqualToCurrentTokenText("_")}?` + */ + +parser grammar PythonParser; // Python 3.12.6 https://docs.python.org/3.12/reference/grammar.html#full-grammar-specification +options { + tokenVocab=PythonLexer; + superClass=PythonParserBase; +} + +// STARTING RULES +// ============== + +file_input: statements? EOF; +interactive: statement_newline; +eval: expressions NEWLINE* EOF; +func_type: '(' type_expressions? ')' '->' expression NEWLINE* EOF; +fstring_input: star_expressions; + +// GENERAL STATEMENTS +// ================== + +statements: statement+; + +statement: compound_stmt | simple_stmts; + +statement_newline + : compound_stmt NEWLINE + | simple_stmts + | NEWLINE + | EOF; + +simple_stmts + : simple_stmt (';' simple_stmt)* ';'? NEWLINE + ; + +// NOTE: assignment MUST precede expression, else parsing a simple assignment +// will throw a SyntaxError. +simple_stmt + : assignment + | type_alias + | star_expressions + | return_stmt + | import_stmt + | raise_stmt + | 'pass' + | del_stmt + | yield_stmt + | assert_stmt + | 'break' + | 'continue' + | global_stmt + | nonlocal_stmt; + +compound_stmt + : function_def + | if_stmt + | class_def + | with_stmt + | for_stmt + | try_stmt + | while_stmt + | match_stmt; + +// SIMPLE STATEMENTS +// ================= + +// NOTE: annotated_rhs may start with 'yield'; yield_expr must start with 'yield' +assignment + : NAME ':' expression ('=' annotated_rhs )? + | ('(' single_target ')' + | single_subscript_attribute_target) ':' expression ('=' annotated_rhs )? + | (star_targets '=' )+ (yield_expr | star_expressions) TYPE_COMMENT? + | single_target augassign (yield_expr | star_expressions); + +annotated_rhs: yield_expr | star_expressions; + +augassign + : '+=' + | '-=' + | '*=' + | '@=' + | '/=' + | '%=' + | '&=' + | '|=' + | '^=' + | '<<=' + | '>>=' + | '**=' + | '//='; + +return_stmt + : 'return' star_expressions?; + +raise_stmt + : 'raise' (expression ('from' expression )?)? + ; + +global_stmt: 'global' NAME (',' NAME)*; + +nonlocal_stmt: 'nonlocal' NAME (',' NAME)*; + +del_stmt + : 'del' del_targets; + +yield_stmt: yield_expr; + +assert_stmt: 'assert' expression (',' expression )?; + +import_stmt + : import_name + | import_from; + +// Import statements +// ----------------- + +import_name: 'import' dotted_as_names; +// note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS +import_from + : 'from' ('.' | '...')* dotted_name 'import' import_from_targets + | 'from' ('.' | '...')+ 'import' import_from_targets; +import_from_targets + : '(' import_from_as_names ','? ')' + | import_from_as_names + | '*'; +import_from_as_names + : import_from_as_name (',' import_from_as_name)*; +import_from_as_name + : NAME ('as' NAME )?; +dotted_as_names + : dotted_as_name (',' dotted_as_name)*; +dotted_as_name + : dotted_name ('as' NAME )?; +dotted_name + : dotted_name '.' NAME + | NAME; + +// COMPOUND STATEMENTS +// =================== + +// Common elements +// --------------- + +block + : NEWLINE INDENT statements DEDENT + | simple_stmts; + +decorators: ('@' named_expression NEWLINE )+; + +// Class definitions +// ----------------- + +class_def + : decorators class_def_raw + | class_def_raw; + +class_def_raw + : 'class' NAME type_params? ('(' arguments? ')' )? ':' block; + +// Function definitions +// -------------------- + +function_def + : decorators function_def_raw + | function_def_raw; + +function_def_raw + : 'def' NAME type_params? '(' params? ')' ('->' expression )? ':' func_type_comment? block + | ASYNC 'def' NAME type_params? '(' params? ')' ('->' expression )? ':' func_type_comment? block; + +// Function parameters +// ------------------- + +params + : parameters; + +parameters + : slash_no_default param_no_default* param_with_default* star_etc? + | slash_with_default param_with_default* star_etc? + | param_no_default+ param_with_default* star_etc? + | param_with_default+ star_etc? + | star_etc; + +// Some duplication here because we can't write (',' | {isCurrentTokenType(RPAR)}?), +// which is because we don't support empty alternatives (yet). + +slash_no_default + : param_no_default+ '/' ','? + ; +slash_with_default + : param_no_default* param_with_default+ '/' ','? + ; + +star_etc + : '*' param_no_default param_maybe_default* kwds? + | '*' param_no_default_star_annotation param_maybe_default* kwds? + | '*' ',' param_maybe_default+ kwds? + | kwds; + +kwds + : '**' param_no_default; + +// One parameter. This *includes* a following comma and type comment. +// +// There are three styles: +// - No default_assignment +// - With default_assignment +// - Maybe with default_assignment +// +// There are two alternative forms of each, to deal with type comments: +// - Ends in a comma followed by an optional type comment +// - No comma, optional type comment, must be followed by close paren +// The latter form is for a final parameter without trailing comma. +// + +param_no_default + : param ','? TYPE_COMMENT? + ; +param_no_default_star_annotation + : param_star_annotation ','? TYPE_COMMENT? + ; +param_with_default + : param default_assignment ','? TYPE_COMMENT? + ; +param_maybe_default + : param default_assignment? ','? TYPE_COMMENT? + ; +param: NAME annotation?; +param_star_annotation: NAME star_annotation; +annotation: ':' expression; +star_annotation: ':' star_expression; +default_assignment: '=' expression; + +// If statement +// ------------ + +if_stmt + : 'if' named_expression ':' block (elif_stmt | else_block?) + ; +elif_stmt + : 'elif' named_expression ':' block (elif_stmt | else_block?) + ; +else_block + : 'else' ':' block; + +// While statement +// --------------- + +while_stmt + : 'while' named_expression ':' block else_block?; + +// For statement +// ------------- + +for_stmt + : ASYNC? 'for' star_targets 'in' star_expressions ':' TYPE_COMMENT? block else_block? + ; + +// With statement +// -------------- + +with_stmt + : ASYNC? 'with' ( '(' with_item (',' with_item)* ','? ')' ':' + | with_item (',' with_item)* ':' TYPE_COMMENT? + ) block + ; + +with_item + : expression ('as' star_target)? + ; + +// Try statement +// ------------- + +try_stmt + : 'try' ':' block finally_block + | 'try' ':' block except_block+ else_block? finally_block? + | 'try' ':' block except_star_block+ else_block? finally_block?; + + +// Except statement +// ---------------- + +except_block + : 'except' (expression ('as' NAME )?)? ':' block + ; +except_star_block + : 'except' '*' expression ('as' NAME )? ':' block; +finally_block + : 'finally' ':' block; + +// Match statement +// --------------- + +match_stmt + : soft_kw_match subject_expr ':' NEWLINE INDENT case_block+ DEDENT; + +subject_expr + : star_named_expression ',' star_named_expressions? + | named_expression; + +case_block + : soft_kw_case patterns guard? ':' block; + +guard: 'if' named_expression; + +patterns + : open_sequence_pattern + | pattern; + +pattern + : as_pattern + | or_pattern; + +as_pattern + : or_pattern 'as' pattern_capture_target; + +or_pattern + : closed_pattern ('|' closed_pattern)*; + +closed_pattern + : literal_pattern + | capture_pattern + | wildcard_pattern + | value_pattern + | group_pattern + | sequence_pattern + | mapping_pattern + | class_pattern; + +// Literal patterns are used for equality and identity constraints +literal_pattern + : signed_number + | complex_number + | strings + | 'None' + | 'True' + | 'False'; + +// Literal expressions are used to restrict permitted mapping pattern keys +literal_expr + : signed_number + | complex_number + | strings + | 'None' + | 'True' + | 'False'; + +complex_number + : signed_real_number ('+' | '-') imaginary_number + ; + +signed_number + : '-'? NUMBER + ; + +signed_real_number + : '-'? real_number + ; + +real_number + : NUMBER; + +imaginary_number + : NUMBER; + +capture_pattern + : pattern_capture_target; + +pattern_capture_target + : soft_kw__not__wildcard; + +wildcard_pattern + : soft_kw_wildcard; + +value_pattern + : attr; + +attr + : NAME ('.' NAME)+ + ; +name_or_attr + : NAME ('.' NAME)* + ; + +group_pattern + : '(' pattern ')'; + +sequence_pattern + : '[' maybe_sequence_pattern? ']' + | '(' open_sequence_pattern? ')'; + +open_sequence_pattern + : maybe_star_pattern ',' maybe_sequence_pattern?; + +maybe_sequence_pattern + : maybe_star_pattern (',' maybe_star_pattern)* ','?; + +maybe_star_pattern + : star_pattern + | pattern; + +star_pattern + : '*' NAME; + +mapping_pattern + : LBRACE RBRACE + | LBRACE double_star_pattern ','? RBRACE + | LBRACE items_pattern (',' double_star_pattern)? ','? RBRACE + ; + +items_pattern + : key_value_pattern (',' key_value_pattern)*; + +key_value_pattern + : (literal_expr | attr) ':' pattern; + +double_star_pattern + : '**' pattern_capture_target; + +class_pattern + : name_or_attr '(' ((positional_patterns (',' keyword_patterns)? | keyword_patterns) ','?)? ')' + ; + + + +positional_patterns + : pattern (',' pattern)*; + +keyword_patterns + : keyword_pattern (',' keyword_pattern)*; + +keyword_pattern + : NAME '=' pattern; + +// Type statement +// --------------- + +type_alias + : soft_kw_type NAME type_params? '=' expression; + +// Type parameter declaration +// -------------------------- + +type_params: '[' type_param_seq ']'; + +type_param_seq: type_param (',' type_param)* ','?; + +type_param + : NAME type_param_bound? + | '*' NAME + | '**' NAME + ; + + +type_param_bound: ':' expression; + +// EXPRESSIONS +// ----------- + +expressions + : expression (',' expression )* ','? + ; + + +expression + : disjunction ('if' disjunction 'else' expression)? + | lambdef + ; + +yield_expr + : 'yield' ('from' expression | star_expressions?) + ; + +star_expressions + : star_expression (',' star_expression )* ','? + ; + + +star_expression + : '*' bitwise_or + | expression; + +star_named_expressions: star_named_expression (',' star_named_expression)* ','?; + +star_named_expression + : '*' bitwise_or + | named_expression; + +assignment_expression + : NAME ':=' expression; + +named_expression + : assignment_expression + | expression; + +disjunction + : conjunction ('or' conjunction )* + ; + +conjunction + : inversion ('and' inversion )* + ; + +inversion + : 'not' inversion + | comparison; + +// Comparison operators +// -------------------- + +comparison + : bitwise_or compare_op_bitwise_or_pair* + ; + +compare_op_bitwise_or_pair + : eq_bitwise_or + | noteq_bitwise_or + | lte_bitwise_or + | lt_bitwise_or + | gte_bitwise_or + | gt_bitwise_or + | notin_bitwise_or + | in_bitwise_or + | isnot_bitwise_or + | is_bitwise_or; + +eq_bitwise_or: '==' bitwise_or; +noteq_bitwise_or + : ('!=' ) bitwise_or; +lte_bitwise_or: '<=' bitwise_or; +lt_bitwise_or: '<' bitwise_or; +gte_bitwise_or: '>=' bitwise_or; +gt_bitwise_or: '>' bitwise_or; +notin_bitwise_or: 'not' 'in' bitwise_or; +in_bitwise_or: 'in' bitwise_or; +isnot_bitwise_or: 'is' 'not' bitwise_or; +is_bitwise_or: 'is' bitwise_or; + +// Bitwise operators +// ----------------- + +bitwise_or + : bitwise_or '|' bitwise_xor + | bitwise_xor; + +bitwise_xor + : bitwise_xor '^' bitwise_and + | bitwise_and; + +bitwise_and + : bitwise_and '&' shift_expr + | shift_expr; + +shift_expr + : shift_expr ('<<' | '>>') sum + | sum + ; + +// Arithmetic operators +// -------------------- + +sum + : sum ('+' | '-') term + | term + ; + +term + : term ('*' | '/' | '//' | '%' | '@') factor + | factor + ; + + + + +factor + : '+' factor + | '-' factor + | '~' factor + | power; + +power + : await_primary ('**' factor)? + ; + +// Primary elements +// ---------------- + +// Primary elements are things like "obj.something.something", "obj[something]", "obj(something)", "obj" ... + +await_primary + : AWAIT primary + | primary; + +primary + : primary ('.' NAME | genexp | '(' arguments? ')' | '[' slices ']') + | atom + ; + + + +slices + : slice + | (slice | starred_expression) (',' (slice | starred_expression))* ','?; + +slice + : expression? ':' expression? (':' expression? )? + | named_expression; + +atom + : NAME + | 'True' + | 'False' + | 'None' + | strings + | NUMBER + | (tuple | group | genexp) + | (list | listcomp) + | (dict | set | dictcomp | setcomp) + | '...'; + +group + : '(' (yield_expr | named_expression) ')'; + +// Lambda functions +// ---------------- + +lambdef + : 'lambda' lambda_params? ':' expression; + +lambda_params + : lambda_parameters; + +// lambda_parameters etc. duplicates parameters but without annotations +// or type comments, and if there's no comma after a parameter, we expect +// a colon, not a close parenthesis. (For more, see parameters above.) +// +lambda_parameters + : lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? + | lambda_slash_with_default lambda_param_with_default* lambda_star_etc? + | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? + | lambda_param_with_default+ lambda_star_etc? + | lambda_star_etc; + +lambda_slash_no_default + : lambda_param_no_default+ '/' ','? + ; + +lambda_slash_with_default + : lambda_param_no_default* lambda_param_with_default+ '/' ','? + ; + +lambda_star_etc + : '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? + | '*' ',' lambda_param_maybe_default+ lambda_kwds? + | lambda_kwds; + +lambda_kwds + : '**' lambda_param_no_default; + +lambda_param_no_default + : lambda_param ','? + ; +lambda_param_with_default + : lambda_param default_assignment ','? + ; +lambda_param_maybe_default + : lambda_param default_assignment? ','? + ; +lambda_param: NAME; + +// LITERALS +// ======== + +fstring_middle + : fstring_replacement_field + | FSTRING_MIDDLE; +fstring_replacement_field + : LBRACE (yield_expr | star_expressions) '='? fstring_conversion? fstring_full_format_spec? RBRACE; +fstring_conversion + : '!' NAME; +fstring_full_format_spec + : ':' fstring_format_spec*; +fstring_format_spec + : FSTRING_MIDDLE + | fstring_replacement_field; +fstring + : FSTRING_START fstring_middle* FSTRING_END; + +string: STRING; +strings: (fstring|string)+; + +list + : '[' star_named_expressions? ']'; + +tuple + : '(' (star_named_expression ',' star_named_expressions? )? ')'; + +set: LBRACE star_named_expressions RBRACE; + +// Dicts +// ----- + +dict + : LBRACE double_starred_kvpairs? RBRACE; + +double_starred_kvpairs: double_starred_kvpair (',' double_starred_kvpair)* ','?; + +double_starred_kvpair + : '**' bitwise_or + | kvpair; + +kvpair: expression ':' expression; + +// Comprehensions & Generators +// --------------------------- + +for_if_clauses + : for_if_clause+; + +for_if_clause + : ASYNC? 'for' star_targets 'in' disjunction ('if' disjunction )* + ; + +listcomp + : '[' named_expression for_if_clauses ']'; + +setcomp + : LBRACE named_expression for_if_clauses RBRACE; + +genexp + : '(' ( assignment_expression | expression) for_if_clauses ')'; + +dictcomp + : LBRACE kvpair for_if_clauses RBRACE; + +// FUNCTION CALL ARGUMENTS +// ======================= + +arguments + : args ','?; + +args + : (starred_expression | ( assignment_expression | expression)) (',' (starred_expression | ( assignment_expression | expression)))* (',' kwargs )? + | kwargs; + +kwargs + : kwarg_or_starred (',' kwarg_or_starred)* (',' kwarg_or_double_starred (',' kwarg_or_double_starred)*)? + | kwarg_or_double_starred (',' kwarg_or_double_starred)* + ; + +starred_expression + : '*' expression; + +kwarg_or_starred + : NAME '=' expression + | starred_expression; + +kwarg_or_double_starred + : NAME '=' expression + | '**' expression; + +// ASSIGNMENT TARGETS +// ================== + +// Generic targets +// --------------- + +// NOTE: star_targets may contain *bitwise_or, targets may not. +star_targets + : star_target (',' star_target )* ','? + ; + +star_targets_list_seq: star_target (',' star_target)+ ','?; + +star_targets_tuple_seq + : star_target (',' | (',' star_target )+ ','?) + ; + +star_target + : '*' (star_target) + | target_with_star_atom; + +target_with_star_atom + : t_primary ('.' NAME | '[' slices ']') + | star_atom + ; + +star_atom + : NAME + | '(' target_with_star_atom ')' + | '(' star_targets_tuple_seq? ')' + | '[' star_targets_list_seq? ']'; + +single_target + : single_subscript_attribute_target + | NAME + | '(' single_target ')'; + +single_subscript_attribute_target + : t_primary ('.' NAME | '[' slices ']') + ; + +t_primary + : t_primary ('.' NAME | '[' slices ']' | genexp | '(' arguments? ')') + | atom + ; + + + + + +// Targets for del statements +// -------------------------- + +del_targets: del_target (',' del_target)* ','?; + +del_target + : t_primary ('.' NAME | '[' slices ']') + | del_t_atom + ; + +del_t_atom + : NAME + | '(' del_target ')' + | '(' del_targets? ')' + | '[' del_targets? ']'; + +// TYPING ELEMENTS +// --------------- + + +// type_expressions allow */** but ignore them +type_expressions + : expression (',' expression)* (',' ('*' expression (',' '**' expression)? | '**' expression))? + | '*' expression (',' '**' expression)? + | '**' expression + ; + + + +func_type_comment + : NEWLINE TYPE_COMMENT // Must be followed by indented block + | TYPE_COMMENT; + +// *** Soft Keywords: https://docs.python.org/3.12/reference/lexical_analysis.html#soft-keywords +soft_kw_type: {this.isEqualToCurrentTokenText("type")}? NAME; +soft_kw_match: {this.isEqualToCurrentTokenText("match")}? NAME; +soft_kw_case: {this.isEqualToCurrentTokenText("case")}? NAME; +soft_kw_wildcard: {this.isEqualToCurrentTokenText("_")}? NAME; +soft_kw__not__wildcard: {this.isnotEqualToCurrentTokenText("_")}? NAME; + +// ========================= END OF THE GRAMMAR =========================== diff --git a/src/main/antlr/UnicodeClasses.g4 b/src/main/antlr/UnicodeClasses.g4 new file mode 100644 index 0000000..1f1541b --- /dev/null +++ b/src/main/antlr/UnicodeClasses.g4 @@ -0,0 +1,1658 @@ +/** + * Taken from http://www.antlr3.org/grammar/1345144569663/AntlrUnicode.txt + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true + +lexer grammar UnicodeClasses; + +UNICODE_CLASS_LL: + '\u0061' ..'\u007A' + | '\u00B5' + | '\u00DF' ..'\u00F6' + | '\u00F8' ..'\u00FF' + | '\u0101' + | '\u0103' + | '\u0105' + | '\u0107' + | '\u0109' + | '\u010B' + | '\u010D' + | '\u010F' + | '\u0111' + | '\u0113' + | '\u0115' + | '\u0117' + | '\u0119' + | '\u011B' + | '\u011D' + | '\u011F' + | '\u0121' + | '\u0123' + | '\u0125' + | '\u0127' + | '\u0129' + | '\u012B' + | '\u012D' + | '\u012F' + | '\u0131' + | '\u0133' + | '\u0135' + | '\u0137' + | '\u0138' + | '\u013A' + | '\u013C' + | '\u013E' + | '\u0140' + | '\u0142' + | '\u0144' + | '\u0146' + | '\u0148' + | '\u0149' + | '\u014B' + | '\u014D' + | '\u014F' + | '\u0151' + | '\u0153' + | '\u0155' + | '\u0157' + | '\u0159' + | '\u015B' + | '\u015D' + | '\u015F' + | '\u0161' + | '\u0163' + | '\u0165' + | '\u0167' + | '\u0169' + | '\u016B' + | '\u016D' + | '\u016F' + | '\u0171' + | '\u0173' + | '\u0175' + | '\u0177' + | '\u017A' + | '\u017C' + | '\u017E' ..'\u0180' + | '\u0183' + | '\u0185' + | '\u0188' + | '\u018C' + | '\u018D' + | '\u0192' + | '\u0195' + | '\u0199' ..'\u019B' + | '\u019E' + | '\u01A1' + | '\u01A3' + | '\u01A5' + | '\u01A8' + | '\u01AA' + | '\u01AB' + | '\u01AD' + | '\u01B0' + | '\u01B4' + | '\u01B6' + | '\u01B9' + | '\u01BA' + | '\u01BD' ..'\u01BF' + | '\u01C6' + | '\u01C9' + | '\u01CC' + | '\u01CE' + | '\u01D0' + | '\u01D2' + | '\u01D4' + | '\u01D6' + | '\u01D8' + | '\u01DA' + | '\u01DC' + | '\u01DD' + | '\u01DF' + | '\u01E1' + | '\u01E3' + | '\u01E5' + | '\u01E7' + | '\u01E9' + | '\u01EB' + | '\u01ED' + | '\u01EF' + | '\u01F0' + | '\u01F3' + | '\u01F5' + | '\u01F9' + | '\u01FB' + | '\u01FD' + | '\u01FF' + | '\u0201' + | '\u0203' + | '\u0205' + | '\u0207' + | '\u0209' + | '\u020B' + | '\u020D' + | '\u020F' + | '\u0211' + | '\u0213' + | '\u0215' + | '\u0217' + | '\u0219' + | '\u021B' + | '\u021D' + | '\u021F' + | '\u0221' + | '\u0223' + | '\u0225' + | '\u0227' + | '\u0229' + | '\u022B' + | '\u022D' + | '\u022F' + | '\u0231' + | '\u0233' ..'\u0239' + | '\u023C' + | '\u023F' + | '\u0240' + | '\u0242' + | '\u0247' + | '\u0249' + | '\u024B' + | '\u024D' + | '\u024F' ..'\u0293' + | '\u0295' ..'\u02AF' + | '\u0371' + | '\u0373' + | '\u0377' + | '\u037B' ..'\u037D' + | '\u0390' + | '\u03AC' ..'\u03CE' + | '\u03D0' + | '\u03D1' + | '\u03D5' ..'\u03D7' + | '\u03D9' + | '\u03DB' + | '\u03DD' + | '\u03DF' + | '\u03E1' + | '\u03E3' + | '\u03E5' + | '\u03E7' + | '\u03E9' + | '\u03EB' + | '\u03ED' + | '\u03EF' ..'\u03F3' + | '\u03F5' + | '\u03F8' + | '\u03FB' + | '\u03FC' + | '\u0430' ..'\u045F' + | '\u0461' + | '\u0463' + | '\u0465' + | '\u0467' + | '\u0469' + | '\u046B' + | '\u046D' + | '\u046F' + | '\u0471' + | '\u0473' + | '\u0475' + | '\u0477' + | '\u0479' + | '\u047B' + | '\u047D' + | '\u047F' + | '\u0481' + | '\u048B' + | '\u048D' + | '\u048F' + | '\u0491' + | '\u0493' + | '\u0495' + | '\u0497' + | '\u0499' + | '\u049B' + | '\u049D' + | '\u049F' + | '\u04A1' + | '\u04A3' + | '\u04A5' + | '\u04A7' + | '\u04A9' + | '\u04AB' + | '\u04AD' + | '\u04AF' + | '\u04B1' + | '\u04B3' + | '\u04B5' + | '\u04B7' + | '\u04B9' + | '\u04BB' + | '\u04BD' + | '\u04BF' + | '\u04C2' + | '\u04C4' + | '\u04C6' + | '\u04C8' + | '\u04CA' + | '\u04CC' + | '\u04CE' + | '\u04CF' + | '\u04D1' + | '\u04D3' + | '\u04D5' + | '\u04D7' + | '\u04D9' + | '\u04DB' + | '\u04DD' + | '\u04DF' + | '\u04E1' + | '\u04E3' + | '\u04E5' + | '\u04E7' + | '\u04E9' + | '\u04EB' + | '\u04ED' + | '\u04EF' + | '\u04F1' + | '\u04F3' + | '\u04F5' + | '\u04F7' + | '\u04F9' + | '\u04FB' + | '\u04FD' + | '\u04FF' + | '\u0501' + | '\u0503' + | '\u0505' + | '\u0507' + | '\u0509' + | '\u050B' + | '\u050D' + | '\u050F' + | '\u0511' + | '\u0513' + | '\u0515' + | '\u0517' + | '\u0519' + | '\u051B' + | '\u051D' + | '\u051F' + | '\u0521' + | '\u0523' + | '\u0525' + | '\u0527' + | '\u0561' ..'\u0587' + | '\u1D00' ..'\u1D2B' + | '\u1D6B' ..'\u1D77' + | '\u1D79' ..'\u1D9A' + | '\u1E01' + | '\u1E03' + | '\u1E05' + | '\u1E07' + | '\u1E09' + | '\u1E0B' + | '\u1E0D' + | '\u1E0F' + | '\u1E11' + | '\u1E13' + | '\u1E15' + | '\u1E17' + | '\u1E19' + | '\u1E1B' + | '\u1E1D' + | '\u1E1F' + | '\u1E21' + | '\u1E23' + | '\u1E25' + | '\u1E27' + | '\u1E29' + | '\u1E2B' + | '\u1E2D' + | '\u1E2F' + | '\u1E31' + | '\u1E33' + | '\u1E35' + | '\u1E37' + | '\u1E39' + | '\u1E3B' + | '\u1E3D' + | '\u1E3F' + | '\u1E41' + | '\u1E43' + | '\u1E45' + | '\u1E47' + | '\u1E49' + | '\u1E4B' + | '\u1E4D' + | '\u1E4F' + | '\u1E51' + | '\u1E53' + | '\u1E55' + | '\u1E57' + | '\u1E59' + | '\u1E5B' + | '\u1E5D' + | '\u1E5F' + | '\u1E61' + | '\u1E63' + | '\u1E65' + | '\u1E67' + | '\u1E69' + | '\u1E6B' + | '\u1E6D' + | '\u1E6F' + | '\u1E71' + | '\u1E73' + | '\u1E75' + | '\u1E77' + | '\u1E79' + | '\u1E7B' + | '\u1E7D' + | '\u1E7F' + | '\u1E81' + | '\u1E83' + | '\u1E85' + | '\u1E87' + | '\u1E89' + | '\u1E8B' + | '\u1E8D' + | '\u1E8F' + | '\u1E91' + | '\u1E93' + | '\u1E95' ..'\u1E9D' + | '\u1E9F' + | '\u1EA1' + | '\u1EA3' + | '\u1EA5' + | '\u1EA7' + | '\u1EA9' + | '\u1EAB' + | '\u1EAD' + | '\u1EAF' + | '\u1EB1' + | '\u1EB3' + | '\u1EB5' + | '\u1EB7' + | '\u1EB9' + | '\u1EBB' + | '\u1EBD' + | '\u1EBF' + | '\u1EC1' + | '\u1EC3' + | '\u1EC5' + | '\u1EC7' + | '\u1EC9' + | '\u1ECB' + | '\u1ECD' + | '\u1ECF' + | '\u1ED1' + | '\u1ED3' + | '\u1ED5' + | '\u1ED7' + | '\u1ED9' + | '\u1EDB' + | '\u1EDD' + | '\u1EDF' + | '\u1EE1' + | '\u1EE3' + | '\u1EE5' + | '\u1EE7' + | '\u1EE9' + | '\u1EEB' + | '\u1EED' + | '\u1EEF' + | '\u1EF1' + | '\u1EF3' + | '\u1EF5' + | '\u1EF7' + | '\u1EF9' + | '\u1EFB' + | '\u1EFD' + | '\u1EFF' ..'\u1F07' + | '\u1F10' ..'\u1F15' + | '\u1F20' ..'\u1F27' + | '\u1F30' ..'\u1F37' + | '\u1F40' ..'\u1F45' + | '\u1F50' ..'\u1F57' + | '\u1F60' ..'\u1F67' + | '\u1F70' ..'\u1F7D' + | '\u1F80' ..'\u1F87' + | '\u1F90' ..'\u1F97' + | '\u1FA0' ..'\u1FA7' + | '\u1FB0' ..'\u1FB4' + | '\u1FB6' + | '\u1FB7' + | '\u1FBE' + | '\u1FC2' ..'\u1FC4' + | '\u1FC6' + | '\u1FC7' + | '\u1FD0' ..'\u1FD3' + | '\u1FD6' + | '\u1FD7' + | '\u1FE0' ..'\u1FE7' + | '\u1FF2' ..'\u1FF4' + | '\u1FF6' + | '\u1FF7' + | '\u210A' + | '\u210E' + | '\u210F' + | '\u2113' + | '\u212F' + | '\u2134' + | '\u2139' + | '\u213C' + | '\u213D' + | '\u2146' ..'\u2149' + | '\u214E' + | '\u2184' + | '\u2C30' ..'\u2C5E' + | '\u2C61' + | '\u2C65' + | '\u2C66' + | '\u2C68' + | '\u2C6A' + | '\u2C6C' + | '\u2C71' + | '\u2C73' + | '\u2C74' + | '\u2C76' ..'\u2C7B' + | '\u2C81' + | '\u2C83' + | '\u2C85' + | '\u2C87' + | '\u2C89' + | '\u2C8B' + | '\u2C8D' + | '\u2C8F' + | '\u2C91' + | '\u2C93' + | '\u2C95' + | '\u2C97' + | '\u2C99' + | '\u2C9B' + | '\u2C9D' + | '\u2C9F' + | '\u2CA1' + | '\u2CA3' + | '\u2CA5' + | '\u2CA7' + | '\u2CA9' + | '\u2CAB' + | '\u2CAD' + | '\u2CAF' + | '\u2CB1' + | '\u2CB3' + | '\u2CB5' + | '\u2CB7' + | '\u2CB9' + | '\u2CBB' + | '\u2CBD' + | '\u2CBF' + | '\u2CC1' + | '\u2CC3' + | '\u2CC5' + | '\u2CC7' + | '\u2CC9' + | '\u2CCB' + | '\u2CCD' + | '\u2CCF' + | '\u2CD1' + | '\u2CD3' + | '\u2CD5' + | '\u2CD7' + | '\u2CD9' + | '\u2CDB' + | '\u2CDD' + | '\u2CDF' + | '\u2CE1' + | '\u2CE3' + | '\u2CE4' + | '\u2CEC' + | '\u2CEE' + | '\u2CF3' + | '\u2D00' ..'\u2D25' + | '\u2D27' + | '\u2D2D' + | '\uA641' + | '\uA643' + | '\uA645' + | '\uA647' + | '\uA649' + | '\uA64B' + | '\uA64D' + | '\uA64F' + | '\uA651' + | '\uA653' + | '\uA655' + | '\uA657' + | '\uA659' + | '\uA65B' + | '\uA65D' + | '\uA65F' + | '\uA661' + | '\uA663' + | '\uA665' + | '\uA667' + | '\uA669' + | '\uA66B' + | '\uA66D' + | '\uA681' + | '\uA683' + | '\uA685' + | '\uA687' + | '\uA689' + | '\uA68B' + | '\uA68D' + | '\uA68F' + | '\uA691' + | '\uA693' + | '\uA695' + | '\uA697' + | '\uA723' + | '\uA725' + | '\uA727' + | '\uA729' + | '\uA72B' + | '\uA72D' + | '\uA72F' ..'\uA731' + | '\uA733' + | '\uA735' + | '\uA737' + | '\uA739' + | '\uA73B' + | '\uA73D' + | '\uA73F' + | '\uA741' + | '\uA743' + | '\uA745' + | '\uA747' + | '\uA749' + | '\uA74B' + | '\uA74D' + | '\uA74F' + | '\uA751' + | '\uA753' + | '\uA755' + | '\uA757' + | '\uA759' + | '\uA75B' + | '\uA75D' + | '\uA75F' + | '\uA761' + | '\uA763' + | '\uA765' + | '\uA767' + | '\uA769' + | '\uA76B' + | '\uA76D' + | '\uA76F' + | '\uA771' ..'\uA778' + | '\uA77A' + | '\uA77C' + | '\uA77F' + | '\uA781' + | '\uA783' + | '\uA785' + | '\uA787' + | '\uA78C' + | '\uA78E' + | '\uA791' + | '\uA793' + | '\uA7A1' + | '\uA7A3' + | '\uA7A5' + | '\uA7A7' + | '\uA7A9' + | '\uA7FA' + | '\uFB00' ..'\uFB06' + | '\uFB13' ..'\uFB17' + | '\uFF41' ..'\uFF5A' +; + +UNICODE_CLASS_LM: + '\u02B0' ..'\u02C1' + | '\u02C6' ..'\u02D1' + | '\u02E0' ..'\u02E4' + | '\u02EC' + | '\u02EE' + | '\u0374' + | '\u037A' + | '\u0559' + | '\u0640' + | '\u06E5' + | '\u06E6' + | '\u07F4' + | '\u07F5' + | '\u07FA' + | '\u081A' + | '\u0824' + | '\u0828' + | '\u0971' + | '\u0E46' + | '\u0EC6' + | '\u10FC' + | '\u17D7' + | '\u1843' + | '\u1AA7' + | '\u1C78' ..'\u1C7D' + | '\u1D2C' ..'\u1D6A' + | '\u1D78' + | '\u1D9B' ..'\u1DBF' + | '\u2071' + | '\u207F' + | '\u2090' ..'\u209C' + | '\u2C7C' + | '\u2C7D' + | '\u2D6F' + | '\u2E2F' + | '\u3005' + | '\u3031' ..'\u3035' + | '\u303B' + | '\u309D' + | '\u309E' + | '\u30FC' ..'\u30FE' + | '\uA015' + | '\uA4F8' ..'\uA4FD' + | '\uA60C' + | '\uA67F' + | '\uA717' ..'\uA71F' + | '\uA770' + | '\uA788' + | '\uA7F8' + | '\uA7F9' + | '\uA9CF' + | '\uAA70' + | '\uAADD' + | '\uAAF3' + | '\uAAF4' + | '\uFF70' + | '\uFF9E' + | '\uFF9F' +; + +UNICODE_CLASS_LO: + '\u00AA' + | '\u00BA' + | '\u01BB' + | '\u01C0' ..'\u01C3' + | '\u0294' + | '\u05D0' ..'\u05EA' + | '\u05F0' ..'\u05F2' + | '\u0620' ..'\u063F' + | '\u0641' ..'\u064A' + | '\u066E' + | '\u066F' + | '\u0671' ..'\u06D3' + | '\u06D5' + | '\u06EE' + | '\u06EF' + | '\u06FA' ..'\u06FC' + | '\u06FF' + | '\u0710' + | '\u0712' ..'\u072F' + | '\u074D' ..'\u07A5' + | '\u07B1' + | '\u07CA' ..'\u07EA' + | '\u0800' ..'\u0815' + | '\u0840' ..'\u0858' + | '\u08A0' + | '\u08A2' ..'\u08AC' + | '\u0904' ..'\u0939' + | '\u093D' + | '\u0950' + | '\u0958' ..'\u0961' + | '\u0972' ..'\u0977' + | '\u0979' ..'\u097F' + | '\u0985' ..'\u098C' + | '\u098F' + | '\u0990' + | '\u0993' ..'\u09A8' + | '\u09AA' ..'\u09B0' + | '\u09B2' + | '\u09B6' ..'\u09B9' + | '\u09BD' + | '\u09CE' + | '\u09DC' + | '\u09DD' + | '\u09DF' ..'\u09E1' + | '\u09F0' + | '\u09F1' + | '\u0A05' ..'\u0A0A' + | '\u0A0F' + | '\u0A10' + | '\u0A13' ..'\u0A28' + | '\u0A2A' ..'\u0A30' + | '\u0A32' + | '\u0A33' + | '\u0A35' + | '\u0A36' + | '\u0A38' + | '\u0A39' + | '\u0A59' ..'\u0A5C' + | '\u0A5E' + | '\u0A72' ..'\u0A74' + | '\u0A85' ..'\u0A8D' + | '\u0A8F' ..'\u0A91' + | '\u0A93' ..'\u0AA8' + | '\u0AAA' ..'\u0AB0' + | '\u0AB2' + | '\u0AB3' + | '\u0AB5' ..'\u0AB9' + | '\u0ABD' + | '\u0AD0' + | '\u0AE0' + | '\u0AE1' + | '\u0B05' ..'\u0B0C' + | '\u0B0F' + | '\u0B10' + | '\u0B13' ..'\u0B28' + | '\u0B2A' ..'\u0B30' + | '\u0B32' + | '\u0B33' + | '\u0B35' ..'\u0B39' + | '\u0B3D' + | '\u0B5C' + | '\u0B5D' + | '\u0B5F' ..'\u0B61' + | '\u0B71' + | '\u0B83' + | '\u0B85' ..'\u0B8A' + | '\u0B8E' ..'\u0B90' + | '\u0B92' ..'\u0B95' + | '\u0B99' + | '\u0B9A' + | '\u0B9C' + | '\u0B9E' + | '\u0B9F' + | '\u0BA3' + | '\u0BA4' + | '\u0BA8' ..'\u0BAA' + | '\u0BAE' ..'\u0BB9' + | '\u0BD0' + | '\u0C05' ..'\u0C0C' + | '\u0C0E' ..'\u0C10' + | '\u0C12' ..'\u0C28' + | '\u0C2A' ..'\u0C33' + | '\u0C35' ..'\u0C39' + | '\u0C3D' + | '\u0C58' + | '\u0C59' + | '\u0C60' + | '\u0C61' + | '\u0C85' ..'\u0C8C' + | '\u0C8E' ..'\u0C90' + | '\u0C92' ..'\u0CA8' + | '\u0CAA' ..'\u0CB3' + | '\u0CB5' ..'\u0CB9' + | '\u0CBD' + | '\u0CDE' + | '\u0CE0' + | '\u0CE1' + | '\u0CF1' + | '\u0CF2' + | '\u0D05' ..'\u0D0C' + | '\u0D0E' ..'\u0D10' + | '\u0D12' ..'\u0D3A' + | '\u0D3D' + | '\u0D4E' + | '\u0D60' + | '\u0D61' + | '\u0D7A' ..'\u0D7F' + | '\u0D85' ..'\u0D96' + | '\u0D9A' ..'\u0DB1' + | '\u0DB3' ..'\u0DBB' + | '\u0DBD' + | '\u0DC0' ..'\u0DC6' + | '\u0E01' ..'\u0E30' + | '\u0E32' + | '\u0E33' + | '\u0E40' ..'\u0E45' + | '\u0E81' + | '\u0E82' + | '\u0E84' + | '\u0E87' + | '\u0E88' + | '\u0E8A' + | '\u0E8D' + | '\u0E94' ..'\u0E97' + | '\u0E99' ..'\u0E9F' + | '\u0EA1' ..'\u0EA3' + | '\u0EA5' + | '\u0EA7' + | '\u0EAA' + | '\u0EAB' + | '\u0EAD' ..'\u0EB0' + | '\u0EB2' + | '\u0EB3' + | '\u0EBD' + | '\u0EC0' ..'\u0EC4' + | '\u0EDC' ..'\u0EDF' + | '\u0F00' + | '\u0F40' ..'\u0F47' + | '\u0F49' ..'\u0F6C' + | '\u0F88' ..'\u0F8C' + | '\u1000' ..'\u102A' + | '\u103F' + | '\u1050' ..'\u1055' + | '\u105A' ..'\u105D' + | '\u1061' + | '\u1065' + | '\u1066' + | '\u106E' ..'\u1070' + | '\u1075' ..'\u1081' + | '\u108E' + | '\u10D0' ..'\u10FA' + | '\u10FD' ..'\u1248' + | '\u124A' ..'\u124D' + | '\u1250' ..'\u1256' + | '\u1258' + | '\u125A' ..'\u125D' + | '\u1260' ..'\u1288' + | '\u128A' ..'\u128D' + | '\u1290' ..'\u12B0' + | '\u12B2' ..'\u12B5' + | '\u12B8' ..'\u12BE' + | '\u12C0' + | '\u12C2' ..'\u12C5' + | '\u12C8' ..'\u12D6' + | '\u12D8' ..'\u1310' + | '\u1312' ..'\u1315' + | '\u1318' ..'\u135A' + | '\u1380' ..'\u138F' + | '\u13A0' ..'\u13F4' + | '\u1401' ..'\u166C' + | '\u166F' ..'\u167F' + | '\u1681' ..'\u169A' + | '\u16A0' ..'\u16EA' + | '\u1700' ..'\u170C' + | '\u170E' ..'\u1711' + | '\u1720' ..'\u1731' + | '\u1740' ..'\u1751' + | '\u1760' ..'\u176C' + | '\u176E' ..'\u1770' + | '\u1780' ..'\u17B3' + | '\u17DC' + | '\u1820' ..'\u1842' + | '\u1844' ..'\u1877' + | '\u1880' ..'\u18A8' + | '\u18AA' + | '\u18B0' ..'\u18F5' + | '\u1900' ..'\u191C' + | '\u1950' ..'\u196D' + | '\u1970' ..'\u1974' + | '\u1980' ..'\u19AB' + | '\u19C1' ..'\u19C7' + | '\u1A00' ..'\u1A16' + | '\u1A20' ..'\u1A54' + | '\u1B05' ..'\u1B33' + | '\u1B45' ..'\u1B4B' + | '\u1B83' ..'\u1BA0' + | '\u1BAE' + | '\u1BAF' + | '\u1BBA' ..'\u1BE5' + | '\u1C00' ..'\u1C23' + | '\u1C4D' ..'\u1C4F' + | '\u1C5A' ..'\u1C77' + | '\u1CE9' ..'\u1CEC' + | '\u1CEE' ..'\u1CF1' + | '\u1CF5' + | '\u1CF6' + | '\u2135' ..'\u2138' + | '\u2D30' ..'\u2D67' + | '\u2D80' ..'\u2D96' + | '\u2DA0' ..'\u2DA6' + | '\u2DA8' ..'\u2DAE' + | '\u2DB0' ..'\u2DB6' + | '\u2DB8' ..'\u2DBE' + | '\u2DC0' ..'\u2DC6' + | '\u2DC8' ..'\u2DCE' + | '\u2DD0' ..'\u2DD6' + | '\u2DD8' ..'\u2DDE' + | '\u3006' + | '\u303C' + | '\u3041' ..'\u3096' + | '\u309F' + | '\u30A1' ..'\u30FA' + | '\u30FF' + | '\u3105' ..'\u312D' + | '\u3131' ..'\u318E' + | '\u31A0' ..'\u31BA' + | '\u31F0' ..'\u31FF' + | '\u3400' + | '\u4DB5' + | '\u4E00' + | '\u9FCC' + | '\uA000' ..'\uA014' + | '\uA016' ..'\uA48C' + | '\uA4D0' ..'\uA4F7' + | '\uA500' ..'\uA60B' + | '\uA610' ..'\uA61F' + | '\uA62A' + | '\uA62B' + | '\uA66E' + | '\uA6A0' ..'\uA6E5' + | '\uA7FB' ..'\uA801' + | '\uA803' ..'\uA805' + | '\uA807' ..'\uA80A' + | '\uA80C' ..'\uA822' + | '\uA840' ..'\uA873' + | '\uA882' ..'\uA8B3' + | '\uA8F2' ..'\uA8F7' + | '\uA8FB' + | '\uA90A' ..'\uA925' + | '\uA930' ..'\uA946' + | '\uA960' ..'\uA97C' + | '\uA984' ..'\uA9B2' + | '\uAA00' ..'\uAA28' + | '\uAA40' ..'\uAA42' + | '\uAA44' ..'\uAA4B' + | '\uAA60' ..'\uAA6F' + | '\uAA71' ..'\uAA76' + | '\uAA7A' + | '\uAA80' ..'\uAAAF' + | '\uAAB1' + | '\uAAB5' + | '\uAAB6' + | '\uAAB9' ..'\uAABD' + | '\uAAC0' + | '\uAAC2' + | '\uAADB' + | '\uAADC' + | '\uAAE0' ..'\uAAEA' + | '\uAAF2' + | '\uAB01' ..'\uAB06' + | '\uAB09' ..'\uAB0E' + | '\uAB11' ..'\uAB16' + | '\uAB20' ..'\uAB26' + | '\uAB28' ..'\uAB2E' + | '\uABC0' ..'\uABE2' + | '\uAC00' + | '\uD7A3' + | '\uD7B0' ..'\uD7C6' + | '\uD7CB' ..'\uD7FB' + | '\uF900' ..'\uFA6D' + | '\uFA70' ..'\uFAD9' + | '\uFB1D' + | '\uFB1F' ..'\uFB28' + | '\uFB2A' ..'\uFB36' + | '\uFB38' ..'\uFB3C' + | '\uFB3E' + | '\uFB40' + | '\uFB41' + | '\uFB43' + | '\uFB44' + | '\uFB46' ..'\uFBB1' + | '\uFBD3' ..'\uFD3D' + | '\uFD50' ..'\uFD8F' + | '\uFD92' ..'\uFDC7' + | '\uFDF0' ..'\uFDFB' + | '\uFE70' ..'\uFE74' + | '\uFE76' ..'\uFEFC' + | '\uFF66' ..'\uFF6F' + | '\uFF71' ..'\uFF9D' + | '\uFFA0' ..'\uFFBE' + | '\uFFC2' ..'\uFFC7' + | '\uFFCA' ..'\uFFCF' + | '\uFFD2' ..'\uFFD7' + | '\uFFDA' ..'\uFFDC' +; + +UNICODE_CLASS_LT: + '\u01C5' + | '\u01C8' + | '\u01CB' + | '\u01F2' + | '\u1F88' ..'\u1F8F' + | '\u1F98' ..'\u1F9F' + | '\u1FA8' ..'\u1FAF' + | '\u1FBC' + | '\u1FCC' + | '\u1FFC' +; + +UNICODE_CLASS_LU: + '\u0041' ..'\u005A' + | '\u00C0' ..'\u00D6' + | '\u00D8' ..'\u00DE' + | '\u0100' + | '\u0102' + | '\u0104' + | '\u0106' + | '\u0108' + | '\u010A' + | '\u010C' + | '\u010E' + | '\u0110' + | '\u0112' + | '\u0114' + | '\u0116' + | '\u0118' + | '\u011A' + | '\u011C' + | '\u011E' + | '\u0120' + | '\u0122' + | '\u0124' + | '\u0126' + | '\u0128' + | '\u012A' + | '\u012C' + | '\u012E' + | '\u0130' + | '\u0132' + | '\u0134' + | '\u0136' + | '\u0139' + | '\u013B' + | '\u013D' + | '\u013F' + | '\u0141' + | '\u0143' + | '\u0145' + | '\u0147' + | '\u014A' + | '\u014C' + | '\u014E' + | '\u0150' + | '\u0152' + | '\u0154' + | '\u0156' + | '\u0158' + | '\u015A' + | '\u015C' + | '\u015E' + | '\u0160' + | '\u0162' + | '\u0164' + | '\u0166' + | '\u0168' + | '\u016A' + | '\u016C' + | '\u016E' + | '\u0170' + | '\u0172' + | '\u0174' + | '\u0176' + | '\u0178' + | '\u0179' + | '\u017B' + | '\u017D' + | '\u0181' + | '\u0182' + | '\u0184' + | '\u0186' + | '\u0187' + | '\u0189' ..'\u018B' + | '\u018E' ..'\u0191' + | '\u0193' + | '\u0194' + | '\u0196' ..'\u0198' + | '\u019C' + | '\u019D' + | '\u019F' + | '\u01A0' + | '\u01A2' + | '\u01A4' + | '\u01A6' + | '\u01A7' + | '\u01A9' + | '\u01AC' + | '\u01AE' + | '\u01AF' + | '\u01B1' ..'\u01B3' + | '\u01B5' + | '\u01B7' + | '\u01B8' + | '\u01BC' + | '\u01C4' + | '\u01C7' + | '\u01CA' + | '\u01CD' + | '\u01CF' + | '\u01D1' + | '\u01D3' + | '\u01D5' + | '\u01D7' + | '\u01D9' + | '\u01DB' + | '\u01DE' + | '\u01E0' + | '\u01E2' + | '\u01E4' + | '\u01E6' + | '\u01E8' + | '\u01EA' + | '\u01EC' + | '\u01EE' + | '\u01F1' + | '\u01F4' + | '\u01F6' ..'\u01F8' + | '\u01FA' + | '\u01FC' + | '\u01FE' + | '\u0200' + | '\u0202' + | '\u0204' + | '\u0206' + | '\u0208' + | '\u020A' + | '\u020C' + | '\u020E' + | '\u0210' + | '\u0212' + | '\u0214' + | '\u0216' + | '\u0218' + | '\u021A' + | '\u021C' + | '\u021E' + | '\u0220' + | '\u0222' + | '\u0224' + | '\u0226' + | '\u0228' + | '\u022A' + | '\u022C' + | '\u022E' + | '\u0230' + | '\u0232' + | '\u023A' + | '\u023B' + | '\u023D' + | '\u023E' + | '\u0241' + | '\u0243' ..'\u0246' + | '\u0248' + | '\u024A' + | '\u024C' + | '\u024E' + | '\u0370' + | '\u0372' + | '\u0376' + | '\u0386' + | '\u0388' ..'\u038A' + | '\u038C' + | '\u038E' + | '\u038F' + | '\u0391' ..'\u03A1' + | '\u03A3' ..'\u03AB' + | '\u03CF' + | '\u03D2' ..'\u03D4' + | '\u03D8' + | '\u03DA' + | '\u03DC' + | '\u03DE' + | '\u03E0' + | '\u03E2' + | '\u03E4' + | '\u03E6' + | '\u03E8' + | '\u03EA' + | '\u03EC' + | '\u03EE' + | '\u03F4' + | '\u03F7' + | '\u03F9' + | '\u03FA' + | '\u03FD' ..'\u042F' + | '\u0460' + | '\u0462' + | '\u0464' + | '\u0466' + | '\u0468' + | '\u046A' + | '\u046C' + | '\u046E' + | '\u0470' + | '\u0472' + | '\u0474' + | '\u0476' + | '\u0478' + | '\u047A' + | '\u047C' + | '\u047E' + | '\u0480' + | '\u048A' + | '\u048C' + | '\u048E' + | '\u0490' + | '\u0492' + | '\u0494' + | '\u0496' + | '\u0498' + | '\u049A' + | '\u049C' + | '\u049E' + | '\u04A0' + | '\u04A2' + | '\u04A4' + | '\u04A6' + | '\u04A8' + | '\u04AA' + | '\u04AC' + | '\u04AE' + | '\u04B0' + | '\u04B2' + | '\u04B4' + | '\u04B6' + | '\u04B8' + | '\u04BA' + | '\u04BC' + | '\u04BE' + | '\u04C0' + | '\u04C1' + | '\u04C3' + | '\u04C5' + | '\u04C7' + | '\u04C9' + | '\u04CB' + | '\u04CD' + | '\u04D0' + | '\u04D2' + | '\u04D4' + | '\u04D6' + | '\u04D8' + | '\u04DA' + | '\u04DC' + | '\u04DE' + | '\u04E0' + | '\u04E2' + | '\u04E4' + | '\u04E6' + | '\u04E8' + | '\u04EA' + | '\u04EC' + | '\u04EE' + | '\u04F0' + | '\u04F2' + | '\u04F4' + | '\u04F6' + | '\u04F8' + | '\u04FA' + | '\u04FC' + | '\u04FE' + | '\u0500' + | '\u0502' + | '\u0504' + | '\u0506' + | '\u0508' + | '\u050A' + | '\u050C' + | '\u050E' + | '\u0510' + | '\u0512' + | '\u0514' + | '\u0516' + | '\u0518' + | '\u051A' + | '\u051C' + | '\u051E' + | '\u0520' + | '\u0522' + | '\u0524' + | '\u0526' + | '\u0531' ..'\u0556' + | '\u10A0' ..'\u10C5' + | '\u10C7' + | '\u10CD' + | '\u1E00' + | '\u1E02' + | '\u1E04' + | '\u1E06' + | '\u1E08' + | '\u1E0A' + | '\u1E0C' + | '\u1E0E' + | '\u1E10' + | '\u1E12' + | '\u1E14' + | '\u1E16' + | '\u1E18' + | '\u1E1A' + | '\u1E1C' + | '\u1E1E' + | '\u1E20' + | '\u1E22' + | '\u1E24' + | '\u1E26' + | '\u1E28' + | '\u1E2A' + | '\u1E2C' + | '\u1E2E' + | '\u1E30' + | '\u1E32' + | '\u1E34' + | '\u1E36' + | '\u1E38' + | '\u1E3A' + | '\u1E3C' + | '\u1E3E' + | '\u1E40' + | '\u1E42' + | '\u1E44' + | '\u1E46' + | '\u1E48' + | '\u1E4A' + | '\u1E4C' + | '\u1E4E' + | '\u1E50' + | '\u1E52' + | '\u1E54' + | '\u1E56' + | '\u1E58' + | '\u1E5A' + | '\u1E5C' + | '\u1E5E' + | '\u1E60' + | '\u1E62' + | '\u1E64' + | '\u1E66' + | '\u1E68' + | '\u1E6A' + | '\u1E6C' + | '\u1E6E' + | '\u1E70' + | '\u1E72' + | '\u1E74' + | '\u1E76' + | '\u1E78' + | '\u1E7A' + | '\u1E7C' + | '\u1E7E' + | '\u1E80' + | '\u1E82' + | '\u1E84' + | '\u1E86' + | '\u1E88' + | '\u1E8A' + | '\u1E8C' + | '\u1E8E' + | '\u1E90' + | '\u1E92' + | '\u1E94' + | '\u1E9E' + | '\u1EA0' + | '\u1EA2' + | '\u1EA4' + | '\u1EA6' + | '\u1EA8' + | '\u1EAA' + | '\u1EAC' + | '\u1EAE' + | '\u1EB0' + | '\u1EB2' + | '\u1EB4' + | '\u1EB6' + | '\u1EB8' + | '\u1EBA' + | '\u1EBC' + | '\u1EBE' + | '\u1EC0' + | '\u1EC2' + | '\u1EC4' + | '\u1EC6' + | '\u1EC8' + | '\u1ECA' + | '\u1ECC' + | '\u1ECE' + | '\u1ED0' + | '\u1ED2' + | '\u1ED4' + | '\u1ED6' + | '\u1ED8' + | '\u1EDA' + | '\u1EDC' + | '\u1EDE' + | '\u1EE0' + | '\u1EE2' + | '\u1EE4' + | '\u1EE6' + | '\u1EE8' + | '\u1EEA' + | '\u1EEC' + | '\u1EEE' + | '\u1EF0' + | '\u1EF2' + | '\u1EF4' + | '\u1EF6' + | '\u1EF8' + | '\u1EFA' + | '\u1EFC' + | '\u1EFE' + | '\u1F08' ..'\u1F0F' + | '\u1F18' ..'\u1F1D' + | '\u1F28' ..'\u1F2F' + | '\u1F38' ..'\u1F3F' + | '\u1F48' ..'\u1F4D' + | '\u1F59' + | '\u1F5B' + | '\u1F5D' + | '\u1F5F' + | '\u1F68' ..'\u1F6F' + | '\u1FB8' ..'\u1FBB' + | '\u1FC8' ..'\u1FCB' + | '\u1FD8' ..'\u1FDB' + | '\u1FE8' ..'\u1FEC' + | '\u1FF8' ..'\u1FFB' + | '\u2102' + | '\u2107' + | '\u210B' ..'\u210D' + | '\u2110' ..'\u2112' + | '\u2115' + | '\u2119' ..'\u211D' + | '\u2124' + | '\u2126' + | '\u2128' + | '\u212A' ..'\u212D' + | '\u2130' ..'\u2133' + | '\u213E' + | '\u213F' + | '\u2145' + | '\u2183' + | '\u2C00' ..'\u2C2E' + | '\u2C60' + | '\u2C62' ..'\u2C64' + | '\u2C67' + | '\u2C69' + | '\u2C6B' + | '\u2C6D' ..'\u2C70' + | '\u2C72' + | '\u2C75' + | '\u2C7E' ..'\u2C80' + | '\u2C82' + | '\u2C84' + | '\u2C86' + | '\u2C88' + | '\u2C8A' + | '\u2C8C' + | '\u2C8E' + | '\u2C90' + | '\u2C92' + | '\u2C94' + | '\u2C96' + | '\u2C98' + | '\u2C9A' + | '\u2C9C' + | '\u2C9E' + | '\u2CA0' + | '\u2CA2' + | '\u2CA4' + | '\u2CA6' + | '\u2CA8' + | '\u2CAA' + | '\u2CAC' + | '\u2CAE' + | '\u2CB0' + | '\u2CB2' + | '\u2CB4' + | '\u2CB6' + | '\u2CB8' + | '\u2CBA' + | '\u2CBC' + | '\u2CBE' + | '\u2CC0' + | '\u2CC2' + | '\u2CC4' + | '\u2CC6' + | '\u2CC8' + | '\u2CCA' + | '\u2CCC' + | '\u2CCE' + | '\u2CD0' + | '\u2CD2' + | '\u2CD4' + | '\u2CD6' + | '\u2CD8' + | '\u2CDA' + | '\u2CDC' + | '\u2CDE' + | '\u2CE0' + | '\u2CE2' + | '\u2CEB' + | '\u2CED' + | '\u2CF2' + | '\uA640' + | '\uA642' + | '\uA644' + | '\uA646' + | '\uA648' + | '\uA64A' + | '\uA64C' + | '\uA64E' + | '\uA650' + | '\uA652' + | '\uA654' + | '\uA656' + | '\uA658' + | '\uA65A' + | '\uA65C' + | '\uA65E' + | '\uA660' + | '\uA662' + | '\uA664' + | '\uA666' + | '\uA668' + | '\uA66A' + | '\uA66C' + | '\uA680' + | '\uA682' + | '\uA684' + | '\uA686' + | '\uA688' + | '\uA68A' + | '\uA68C' + | '\uA68E' + | '\uA690' + | '\uA692' + | '\uA694' + | '\uA696' + | '\uA722' + | '\uA724' + | '\uA726' + | '\uA728' + | '\uA72A' + | '\uA72C' + | '\uA72E' + | '\uA732' + | '\uA734' + | '\uA736' + | '\uA738' + | '\uA73A' + | '\uA73C' + | '\uA73E' + | '\uA740' + | '\uA742' + | '\uA744' + | '\uA746' + | '\uA748' + | '\uA74A' + | '\uA74C' + | '\uA74E' + | '\uA750' + | '\uA752' + | '\uA754' + | '\uA756' + | '\uA758' + | '\uA75A' + | '\uA75C' + | '\uA75E' + | '\uA760' + | '\uA762' + | '\uA764' + | '\uA766' + | '\uA768' + | '\uA76A' + | '\uA76C' + | '\uA76E' + | '\uA779' + | '\uA77B' + | '\uA77D' + | '\uA77E' + | '\uA780' + | '\uA782' + | '\uA784' + | '\uA786' + | '\uA78B' + | '\uA78D' + | '\uA790' + | '\uA792' + | '\uA7A0' + | '\uA7A2' + | '\uA7A4' + | '\uA7A6' + | '\uA7A8' + | '\uA7AA' + | '\uFF21' ..'\uFF3A' +; + +UNICODE_CLASS_ND: + '\u0030' ..'\u0039' + | '\u0660' ..'\u0669' + | '\u06F0' ..'\u06F9' + | '\u07C0' ..'\u07C9' + | '\u0966' ..'\u096F' + | '\u09E6' ..'\u09EF' + | '\u0A66' ..'\u0A6F' + | '\u0AE6' ..'\u0AEF' + | '\u0B66' ..'\u0B6F' + | '\u0BE6' ..'\u0BEF' + | '\u0C66' ..'\u0C6F' + | '\u0CE6' ..'\u0CEF' + | '\u0D66' ..'\u0D6F' + | '\u0E50' ..'\u0E59' + | '\u0ED0' ..'\u0ED9' + | '\u0F20' ..'\u0F29' + | '\u1040' ..'\u1049' + | '\u1090' ..'\u1099' + | '\u17E0' ..'\u17E9' + | '\u1810' ..'\u1819' + | '\u1946' ..'\u194F' + | '\u19D0' ..'\u19D9' + | '\u1A80' ..'\u1A89' + | '\u1A90' ..'\u1A99' + | '\u1B50' ..'\u1B59' + | '\u1BB0' ..'\u1BB9' + | '\u1C40' ..'\u1C49' + | '\u1C50' ..'\u1C59' + | '\uA620' ..'\uA629' + | '\uA8D0' ..'\uA8D9' + | '\uA900' ..'\uA909' + | '\uA9D0' ..'\uA9D9' + | '\uAA50' ..'\uAA59' + | '\uABF0' ..'\uABF9' + | '\uFF10' ..'\uFF19' +; + +UNICODE_CLASS_NL: + '\u16EE' ..'\u16F0' + | '\u2160' ..'\u2182' + | '\u2185' ..'\u2188' + | '\u3007' + | '\u3021' ..'\u3029' + | '\u3038' ..'\u303A' + | '\uA6E6' ..'\uA6EF' +; diff --git a/src/main/java/CPP14Lexer.interp b/src/main/java/CPP14Lexer.interp new file mode 100644 index 0000000..abbf5d2 --- /dev/null +++ b/src/main/java/CPP14Lexer.interp @@ -0,0 +1,478 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +'alignas' +'alignof' +'asm' +'auto' +'bool' +'break' +'case' +'catch' +'char' +'char16_t' +'char32_t' +'class' +'const' +'constexpr' +'const_cast' +'continue' +'decltype' +'default' +'delete' +'do' +'double' +'dynamic_cast' +'else' +'enum' +'explicit' +'export' +'extern' +'false' +'final' +'float' +'for' +'friend' +'goto' +'if' +'inline' +'int' +'long' +'mutable' +'namespace' +'new' +'noexcept' +'nullptr' +'operator' +'override' +'private' +'protected' +'public' +'register' +'reinterpret_cast' +'return' +'short' +'signed' +'sizeof' +'static' +'static_assert' +'static_cast' +'struct' +'switch' +'template' +'this' +'thread_local' +'throw' +'true' +'try' +'typedef' +'typeid' +'typename' +'union' +'unsigned' +'using' +'virtual' +'void' +'volatile' +'wchar_t' +'while' +'(' +')' +'[' +']' +'{' +'}' +'+' +'-' +'*' +'/' +'%' +'^' +'&' +'|' +'~' +null +'=' +'<' +'>' +'+=' +'-=' +'*=' +'/=' +'%=' +'^=' +'&=' +'|=' +'<<=' +'>>=' +'==' +'!=' +'<=' +'>=' +null +null +'++' +'--' +',' +'->*' +'->' +'?' +':' +'::' +';' +'.' +'.*' +'...' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Identifier +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +Integersuffix +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Whitespace +Newline +BlockComment +LineComment + +rule names: +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Hexquad +Universalcharactername +Identifier +Identifiernondigit +NONDIGIT +DIGIT +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +NONZERODIGIT +OCTALDIGIT +HEXADECIMALDIGIT +BINARYDIGIT +Integersuffix +Unsignedsuffix +Longsuffix +Longlongsuffix +Cchar +Escapesequence +Simpleescapesequence +Octalescapesequence +Hexadecimalescapesequence +Fractionalconstant +Exponentpart +SIGN +Digitsequence +Floatingsuffix +Encodingprefix +Schar +Rawstring +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Udsuffix +Whitespace +Newline +BlockComment +LineComment + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 145, 1458, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 1, 0, 1, 0, 3, 0, 346, 8, 0, 1, 0, 1, 0, 3, 0, 350, 8, 0, 1, 0, 1, 0, 3, 0, 354, 8, 0, 1, 0, 1, 0, 3, 0, 358, 8, 0, 3, 0, 360, 8, 0, 1, 1, 3, 1, 363, 8, 1, 1, 1, 1, 1, 4, 1, 367, 8, 1, 11, 1, 12, 1, 368, 1, 1, 1, 1, 1, 2, 1, 2, 3, 2, 375, 8, 2, 1, 2, 3, 2, 378, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 383, 8, 2, 3, 2, 385, 8, 2, 1, 3, 3, 3, 388, 8, 3, 1, 3, 1, 3, 5, 3, 392, 8, 3, 10, 3, 12, 3, 395, 9, 3, 1, 3, 1, 3, 3, 3, 399, 8, 3, 1, 3, 1, 3, 3, 3, 403, 8, 3, 1, 4, 1, 4, 3, 4, 407, 8, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 415, 8, 6, 1, 7, 1, 7, 5, 7, 419, 8, 7, 10, 7, 12, 7, 422, 9, 7, 1, 7, 1, 7, 3, 7, 426, 8, 7, 1, 7, 4, 7, 429, 8, 7, 11, 7, 12, 7, 430, 1, 7, 4, 7, 434, 8, 7, 11, 7, 12, 7, 435, 1, 7, 1, 7, 1, 8, 1, 8, 5, 8, 442, 8, 8, 10, 8, 12, 8, 445, 9, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 96, 1, 96, 1, 97, 1, 97, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1033, 8, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1090, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 1096, 8, 118, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1146, 8, 132, 1, 133, 1, 133, 1, 133, 5, 133, 1151, 8, 133, 10, 133, 12, 133, 1154, 9, 133, 1, 134, 1, 134, 3, 134, 1158, 8, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 1166, 8, 137, 1, 137, 5, 137, 1169, 8, 137, 10, 137, 12, 137, 1172, 9, 137, 1, 138, 1, 138, 3, 138, 1176, 8, 138, 1, 138, 5, 138, 1179, 8, 138, 10, 138, 12, 138, 1182, 9, 138, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 1188, 8, 139, 1, 139, 1, 139, 3, 139, 1192, 8, 139, 1, 139, 5, 139, 1195, 8, 139, 10, 139, 12, 139, 1198, 9, 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1204, 8, 140, 1, 140, 1, 140, 3, 140, 1208, 8, 140, 1, 140, 5, 140, 1211, 8, 140, 10, 140, 12, 140, 1214, 9, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, 1, 145, 3, 145, 1226, 8, 145, 1, 145, 1, 145, 3, 145, 1230, 8, 145, 1, 145, 1, 145, 3, 145, 1234, 8, 145, 1, 145, 1, 145, 3, 145, 1238, 8, 145, 3, 145, 1240, 8, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 1250, 8, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1255, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 1260, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 3, 151, 1283, 8, 151, 1, 151, 3, 151, 1286, 8, 151, 1, 151, 1, 151, 1, 151, 1, 151, 3, 151, 1292, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 1305, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 4, 153, 1311, 8, 153, 11, 153, 12, 153, 1312, 1, 154, 3, 154, 1316, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 1323, 8, 154, 1, 155, 1, 155, 3, 155, 1327, 8, 155, 1, 155, 1, 155, 1, 155, 3, 155, 1332, 8, 155, 1, 155, 3, 155, 1335, 8, 155, 1, 156, 1, 156, 1, 157, 1, 157, 3, 157, 1341, 8, 157, 1, 157, 5, 157, 1344, 8, 157, 10, 157, 12, 157, 1347, 9, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 3, 159, 1354, 8, 159, 1, 160, 1, 160, 1, 160, 3, 160, 1359, 8, 160, 1, 161, 1, 161, 5, 161, 1363, 8, 161, 10, 161, 12, 161, 1366, 9, 161, 1, 161, 1, 161, 5, 161, 1370, 8, 161, 10, 161, 12, 161, 1373, 9, 161, 1, 161, 1, 161, 5, 161, 1377, 8, 161, 10, 161, 12, 161, 1380, 9, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 1396, 8, 162, 1, 163, 1, 163, 3, 163, 1400, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 1408, 8, 163, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 4, 167, 1419, 8, 167, 11, 167, 12, 167, 1420, 1, 167, 1, 167, 1, 168, 1, 168, 3, 168, 1427, 8, 168, 1, 168, 3, 168, 1430, 8, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 5, 169, 1438, 8, 169, 10, 169, 12, 169, 1441, 9, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 5, 170, 1452, 8, 170, 10, 170, 12, 170, 1455, 9, 170, 1, 170, 1, 170, 2, 420, 1439, 0, 171, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 0, 265, 0, 267, 132, 269, 0, 271, 0, 273, 0, 275, 133, 277, 134, 279, 135, 281, 136, 283, 0, 285, 0, 287, 0, 289, 0, 291, 137, 293, 0, 295, 0, 297, 0, 299, 0, 301, 0, 303, 0, 305, 0, 307, 0, 309, 0, 311, 0, 313, 0, 315, 0, 317, 0, 319, 0, 321, 0, 323, 0, 325, 138, 327, 139, 329, 140, 331, 141, 333, 0, 335, 142, 337, 143, 339, 144, 341, 145, 1, 0, 19, 3, 0, 76, 76, 85, 85, 117, 117, 1, 0, 10, 10, 3, 0, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 1, 0, 49, 57, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 48, 49, 2, 0, 85, 85, 117, 117, 2, 0, 76, 76, 108, 108, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 2, 0, 43, 43, 45, 45, 4, 0, 70, 70, 76, 76, 102, 102, 108, 108, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 3, 0, 10, 10, 13, 13, 40, 40, 3, 0, 10, 10, 13, 13, 41, 41, 3, 0, 10, 10, 13, 13, 34, 34, 2, 0, 9, 9, 32, 32, 2, 0, 10, 10, 13, 13, 1525, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 1, 359, 1, 0, 0, 0, 3, 362, 1, 0, 0, 0, 5, 384, 1, 0, 0, 0, 7, 402, 1, 0, 0, 0, 9, 406, 1, 0, 0, 0, 11, 408, 1, 0, 0, 0, 13, 414, 1, 0, 0, 0, 15, 416, 1, 0, 0, 0, 17, 439, 1, 0, 0, 0, 19, 448, 1, 0, 0, 0, 21, 456, 1, 0, 0, 0, 23, 464, 1, 0, 0, 0, 25, 468, 1, 0, 0, 0, 27, 473, 1, 0, 0, 0, 29, 478, 1, 0, 0, 0, 31, 484, 1, 0, 0, 0, 33, 489, 1, 0, 0, 0, 35, 495, 1, 0, 0, 0, 37, 500, 1, 0, 0, 0, 39, 509, 1, 0, 0, 0, 41, 518, 1, 0, 0, 0, 43, 524, 1, 0, 0, 0, 45, 530, 1, 0, 0, 0, 47, 540, 1, 0, 0, 0, 49, 551, 1, 0, 0, 0, 51, 560, 1, 0, 0, 0, 53, 569, 1, 0, 0, 0, 55, 577, 1, 0, 0, 0, 57, 584, 1, 0, 0, 0, 59, 587, 1, 0, 0, 0, 61, 594, 1, 0, 0, 0, 63, 607, 1, 0, 0, 0, 65, 612, 1, 0, 0, 0, 67, 617, 1, 0, 0, 0, 69, 626, 1, 0, 0, 0, 71, 633, 1, 0, 0, 0, 73, 640, 1, 0, 0, 0, 75, 646, 1, 0, 0, 0, 77, 652, 1, 0, 0, 0, 79, 658, 1, 0, 0, 0, 81, 662, 1, 0, 0, 0, 83, 669, 1, 0, 0, 0, 85, 674, 1, 0, 0, 0, 87, 677, 1, 0, 0, 0, 89, 684, 1, 0, 0, 0, 91, 688, 1, 0, 0, 0, 93, 693, 1, 0, 0, 0, 95, 701, 1, 0, 0, 0, 97, 711, 1, 0, 0, 0, 99, 715, 1, 0, 0, 0, 101, 724, 1, 0, 0, 0, 103, 732, 1, 0, 0, 0, 105, 741, 1, 0, 0, 0, 107, 750, 1, 0, 0, 0, 109, 758, 1, 0, 0, 0, 111, 768, 1, 0, 0, 0, 113, 775, 1, 0, 0, 0, 115, 784, 1, 0, 0, 0, 117, 801, 1, 0, 0, 0, 119, 808, 1, 0, 0, 0, 121, 814, 1, 0, 0, 0, 123, 821, 1, 0, 0, 0, 125, 828, 1, 0, 0, 0, 127, 835, 1, 0, 0, 0, 129, 849, 1, 0, 0, 0, 131, 861, 1, 0, 0, 0, 133, 868, 1, 0, 0, 0, 135, 875, 1, 0, 0, 0, 137, 884, 1, 0, 0, 0, 139, 889, 1, 0, 0, 0, 141, 902, 1, 0, 0, 0, 143, 908, 1, 0, 0, 0, 145, 913, 1, 0, 0, 0, 147, 917, 1, 0, 0, 0, 149, 925, 1, 0, 0, 0, 151, 932, 1, 0, 0, 0, 153, 941, 1, 0, 0, 0, 155, 947, 1, 0, 0, 0, 157, 956, 1, 0, 0, 0, 159, 962, 1, 0, 0, 0, 161, 970, 1, 0, 0, 0, 163, 975, 1, 0, 0, 0, 165, 984, 1, 0, 0, 0, 167, 992, 1, 0, 0, 0, 169, 998, 1, 0, 0, 0, 171, 1000, 1, 0, 0, 0, 173, 1002, 1, 0, 0, 0, 175, 1004, 1, 0, 0, 0, 177, 1006, 1, 0, 0, 0, 179, 1008, 1, 0, 0, 0, 181, 1010, 1, 0, 0, 0, 183, 1012, 1, 0, 0, 0, 185, 1014, 1, 0, 0, 0, 187, 1016, 1, 0, 0, 0, 189, 1018, 1, 0, 0, 0, 191, 1020, 1, 0, 0, 0, 193, 1022, 1, 0, 0, 0, 195, 1024, 1, 0, 0, 0, 197, 1026, 1, 0, 0, 0, 199, 1032, 1, 0, 0, 0, 201, 1034, 1, 0, 0, 0, 203, 1036, 1, 0, 0, 0, 205, 1038, 1, 0, 0, 0, 207, 1040, 1, 0, 0, 0, 209, 1043, 1, 0, 0, 0, 211, 1046, 1, 0, 0, 0, 213, 1049, 1, 0, 0, 0, 215, 1052, 1, 0, 0, 0, 217, 1055, 1, 0, 0, 0, 219, 1058, 1, 0, 0, 0, 221, 1061, 1, 0, 0, 0, 223, 1064, 1, 0, 0, 0, 225, 1068, 1, 0, 0, 0, 227, 1072, 1, 0, 0, 0, 229, 1075, 1, 0, 0, 0, 231, 1078, 1, 0, 0, 0, 233, 1081, 1, 0, 0, 0, 235, 1089, 1, 0, 0, 0, 237, 1095, 1, 0, 0, 0, 239, 1097, 1, 0, 0, 0, 241, 1100, 1, 0, 0, 0, 243, 1103, 1, 0, 0, 0, 245, 1105, 1, 0, 0, 0, 247, 1109, 1, 0, 0, 0, 249, 1112, 1, 0, 0, 0, 251, 1114, 1, 0, 0, 0, 253, 1116, 1, 0, 0, 0, 255, 1119, 1, 0, 0, 0, 257, 1121, 1, 0, 0, 0, 259, 1123, 1, 0, 0, 0, 261, 1126, 1, 0, 0, 0, 263, 1130, 1, 0, 0, 0, 265, 1145, 1, 0, 0, 0, 267, 1147, 1, 0, 0, 0, 269, 1157, 1, 0, 0, 0, 271, 1159, 1, 0, 0, 0, 273, 1161, 1, 0, 0, 0, 275, 1163, 1, 0, 0, 0, 277, 1173, 1, 0, 0, 0, 279, 1187, 1, 0, 0, 0, 281, 1203, 1, 0, 0, 0, 283, 1215, 1, 0, 0, 0, 285, 1217, 1, 0, 0, 0, 287, 1219, 1, 0, 0, 0, 289, 1221, 1, 0, 0, 0, 291, 1239, 1, 0, 0, 0, 293, 1241, 1, 0, 0, 0, 295, 1243, 1, 0, 0, 0, 297, 1249, 1, 0, 0, 0, 299, 1254, 1, 0, 0, 0, 301, 1259, 1, 0, 0, 0, 303, 1291, 1, 0, 0, 0, 305, 1304, 1, 0, 0, 0, 307, 1306, 1, 0, 0, 0, 309, 1322, 1, 0, 0, 0, 311, 1334, 1, 0, 0, 0, 313, 1336, 1, 0, 0, 0, 315, 1338, 1, 0, 0, 0, 317, 1348, 1, 0, 0, 0, 319, 1353, 1, 0, 0, 0, 321, 1358, 1, 0, 0, 0, 323, 1360, 1, 0, 0, 0, 325, 1395, 1, 0, 0, 0, 327, 1407, 1, 0, 0, 0, 329, 1409, 1, 0, 0, 0, 331, 1412, 1, 0, 0, 0, 333, 1415, 1, 0, 0, 0, 335, 1418, 1, 0, 0, 0, 337, 1429, 1, 0, 0, 0, 339, 1433, 1, 0, 0, 0, 341, 1447, 1, 0, 0, 0, 343, 345, 3, 275, 137, 0, 344, 346, 3, 291, 145, 0, 345, 344, 1, 0, 0, 0, 345, 346, 1, 0, 0, 0, 346, 360, 1, 0, 0, 0, 347, 349, 3, 277, 138, 0, 348, 350, 3, 291, 145, 0, 349, 348, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 360, 1, 0, 0, 0, 351, 353, 3, 279, 139, 0, 352, 354, 3, 291, 145, 0, 353, 352, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 360, 1, 0, 0, 0, 355, 357, 3, 281, 140, 0, 356, 358, 3, 291, 145, 0, 357, 356, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 360, 1, 0, 0, 0, 359, 343, 1, 0, 0, 0, 359, 347, 1, 0, 0, 0, 359, 351, 1, 0, 0, 0, 359, 355, 1, 0, 0, 0, 360, 2, 1, 0, 0, 0, 361, 363, 7, 0, 0, 0, 362, 361, 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 364, 1, 0, 0, 0, 364, 366, 5, 39, 0, 0, 365, 367, 3, 299, 149, 0, 366, 365, 1, 0, 0, 0, 367, 368, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 370, 1, 0, 0, 0, 370, 371, 5, 39, 0, 0, 371, 4, 1, 0, 0, 0, 372, 374, 3, 309, 154, 0, 373, 375, 3, 311, 155, 0, 374, 373, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 378, 3, 317, 158, 0, 377, 376, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 385, 1, 0, 0, 0, 379, 380, 3, 315, 157, 0, 380, 382, 3, 311, 155, 0, 381, 383, 3, 317, 158, 0, 382, 381, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 385, 1, 0, 0, 0, 384, 372, 1, 0, 0, 0, 384, 379, 1, 0, 0, 0, 385, 6, 1, 0, 0, 0, 386, 388, 3, 319, 159, 0, 387, 386, 1, 0, 0, 0, 387, 388, 1, 0, 0, 0, 388, 389, 1, 0, 0, 0, 389, 393, 5, 34, 0, 0, 390, 392, 3, 321, 160, 0, 391, 390, 1, 0, 0, 0, 392, 395, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 393, 394, 1, 0, 0, 0, 394, 396, 1, 0, 0, 0, 395, 393, 1, 0, 0, 0, 396, 403, 5, 34, 0, 0, 397, 399, 3, 319, 159, 0, 398, 397, 1, 0, 0, 0, 398, 399, 1, 0, 0, 0, 399, 400, 1, 0, 0, 0, 400, 401, 5, 82, 0, 0, 401, 403, 3, 323, 161, 0, 402, 387, 1, 0, 0, 0, 402, 398, 1, 0, 0, 0, 403, 8, 1, 0, 0, 0, 404, 407, 3, 73, 36, 0, 405, 407, 3, 143, 71, 0, 406, 404, 1, 0, 0, 0, 406, 405, 1, 0, 0, 0, 407, 10, 1, 0, 0, 0, 408, 409, 3, 101, 50, 0, 409, 12, 1, 0, 0, 0, 410, 415, 3, 325, 162, 0, 411, 415, 3, 327, 163, 0, 412, 415, 3, 329, 164, 0, 413, 415, 3, 331, 165, 0, 414, 410, 1, 0, 0, 0, 414, 411, 1, 0, 0, 0, 414, 412, 1, 0, 0, 0, 414, 413, 1, 0, 0, 0, 415, 14, 1, 0, 0, 0, 416, 428, 5, 35, 0, 0, 417, 419, 8, 1, 0, 0, 418, 417, 1, 0, 0, 0, 419, 422, 1, 0, 0, 0, 420, 421, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 421, 423, 1, 0, 0, 0, 422, 420, 1, 0, 0, 0, 423, 425, 5, 92, 0, 0, 424, 426, 5, 13, 0, 0, 425, 424, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 429, 5, 10, 0, 0, 428, 420, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 428, 1, 0, 0, 0, 430, 431, 1, 0, 0, 0, 431, 433, 1, 0, 0, 0, 432, 434, 8, 1, 0, 0, 433, 432, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 433, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 437, 1, 0, 0, 0, 437, 438, 6, 7, 0, 0, 438, 16, 1, 0, 0, 0, 439, 443, 5, 35, 0, 0, 440, 442, 8, 1, 0, 0, 441, 440, 1, 0, 0, 0, 442, 445, 1, 0, 0, 0, 443, 441, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 446, 1, 0, 0, 0, 445, 443, 1, 0, 0, 0, 446, 447, 6, 8, 0, 0, 447, 18, 1, 0, 0, 0, 448, 449, 5, 97, 0, 0, 449, 450, 5, 108, 0, 0, 450, 451, 5, 105, 0, 0, 451, 452, 5, 103, 0, 0, 452, 453, 5, 110, 0, 0, 453, 454, 5, 97, 0, 0, 454, 455, 5, 115, 0, 0, 455, 20, 1, 0, 0, 0, 456, 457, 5, 97, 0, 0, 457, 458, 5, 108, 0, 0, 458, 459, 5, 105, 0, 0, 459, 460, 5, 103, 0, 0, 460, 461, 5, 110, 0, 0, 461, 462, 5, 111, 0, 0, 462, 463, 5, 102, 0, 0, 463, 22, 1, 0, 0, 0, 464, 465, 5, 97, 0, 0, 465, 466, 5, 115, 0, 0, 466, 467, 5, 109, 0, 0, 467, 24, 1, 0, 0, 0, 468, 469, 5, 97, 0, 0, 469, 470, 5, 117, 0, 0, 470, 471, 5, 116, 0, 0, 471, 472, 5, 111, 0, 0, 472, 26, 1, 0, 0, 0, 473, 474, 5, 98, 0, 0, 474, 475, 5, 111, 0, 0, 475, 476, 5, 111, 0, 0, 476, 477, 5, 108, 0, 0, 477, 28, 1, 0, 0, 0, 478, 479, 5, 98, 0, 0, 479, 480, 5, 114, 0, 0, 480, 481, 5, 101, 0, 0, 481, 482, 5, 97, 0, 0, 482, 483, 5, 107, 0, 0, 483, 30, 1, 0, 0, 0, 484, 485, 5, 99, 0, 0, 485, 486, 5, 97, 0, 0, 486, 487, 5, 115, 0, 0, 487, 488, 5, 101, 0, 0, 488, 32, 1, 0, 0, 0, 489, 490, 5, 99, 0, 0, 490, 491, 5, 97, 0, 0, 491, 492, 5, 116, 0, 0, 492, 493, 5, 99, 0, 0, 493, 494, 5, 104, 0, 0, 494, 34, 1, 0, 0, 0, 495, 496, 5, 99, 0, 0, 496, 497, 5, 104, 0, 0, 497, 498, 5, 97, 0, 0, 498, 499, 5, 114, 0, 0, 499, 36, 1, 0, 0, 0, 500, 501, 5, 99, 0, 0, 501, 502, 5, 104, 0, 0, 502, 503, 5, 97, 0, 0, 503, 504, 5, 114, 0, 0, 504, 505, 5, 49, 0, 0, 505, 506, 5, 54, 0, 0, 506, 507, 5, 95, 0, 0, 507, 508, 5, 116, 0, 0, 508, 38, 1, 0, 0, 0, 509, 510, 5, 99, 0, 0, 510, 511, 5, 104, 0, 0, 511, 512, 5, 97, 0, 0, 512, 513, 5, 114, 0, 0, 513, 514, 5, 51, 0, 0, 514, 515, 5, 50, 0, 0, 515, 516, 5, 95, 0, 0, 516, 517, 5, 116, 0, 0, 517, 40, 1, 0, 0, 0, 518, 519, 5, 99, 0, 0, 519, 520, 5, 108, 0, 0, 520, 521, 5, 97, 0, 0, 521, 522, 5, 115, 0, 0, 522, 523, 5, 115, 0, 0, 523, 42, 1, 0, 0, 0, 524, 525, 5, 99, 0, 0, 525, 526, 5, 111, 0, 0, 526, 527, 5, 110, 0, 0, 527, 528, 5, 115, 0, 0, 528, 529, 5, 116, 0, 0, 529, 44, 1, 0, 0, 0, 530, 531, 5, 99, 0, 0, 531, 532, 5, 111, 0, 0, 532, 533, 5, 110, 0, 0, 533, 534, 5, 115, 0, 0, 534, 535, 5, 116, 0, 0, 535, 536, 5, 101, 0, 0, 536, 537, 5, 120, 0, 0, 537, 538, 5, 112, 0, 0, 538, 539, 5, 114, 0, 0, 539, 46, 1, 0, 0, 0, 540, 541, 5, 99, 0, 0, 541, 542, 5, 111, 0, 0, 542, 543, 5, 110, 0, 0, 543, 544, 5, 115, 0, 0, 544, 545, 5, 116, 0, 0, 545, 546, 5, 95, 0, 0, 546, 547, 5, 99, 0, 0, 547, 548, 5, 97, 0, 0, 548, 549, 5, 115, 0, 0, 549, 550, 5, 116, 0, 0, 550, 48, 1, 0, 0, 0, 551, 552, 5, 99, 0, 0, 552, 553, 5, 111, 0, 0, 553, 554, 5, 110, 0, 0, 554, 555, 5, 116, 0, 0, 555, 556, 5, 105, 0, 0, 556, 557, 5, 110, 0, 0, 557, 558, 5, 117, 0, 0, 558, 559, 5, 101, 0, 0, 559, 50, 1, 0, 0, 0, 560, 561, 5, 100, 0, 0, 561, 562, 5, 101, 0, 0, 562, 563, 5, 99, 0, 0, 563, 564, 5, 108, 0, 0, 564, 565, 5, 116, 0, 0, 565, 566, 5, 121, 0, 0, 566, 567, 5, 112, 0, 0, 567, 568, 5, 101, 0, 0, 568, 52, 1, 0, 0, 0, 569, 570, 5, 100, 0, 0, 570, 571, 5, 101, 0, 0, 571, 572, 5, 102, 0, 0, 572, 573, 5, 97, 0, 0, 573, 574, 5, 117, 0, 0, 574, 575, 5, 108, 0, 0, 575, 576, 5, 116, 0, 0, 576, 54, 1, 0, 0, 0, 577, 578, 5, 100, 0, 0, 578, 579, 5, 101, 0, 0, 579, 580, 5, 108, 0, 0, 580, 581, 5, 101, 0, 0, 581, 582, 5, 116, 0, 0, 582, 583, 5, 101, 0, 0, 583, 56, 1, 0, 0, 0, 584, 585, 5, 100, 0, 0, 585, 586, 5, 111, 0, 0, 586, 58, 1, 0, 0, 0, 587, 588, 5, 100, 0, 0, 588, 589, 5, 111, 0, 0, 589, 590, 5, 117, 0, 0, 590, 591, 5, 98, 0, 0, 591, 592, 5, 108, 0, 0, 592, 593, 5, 101, 0, 0, 593, 60, 1, 0, 0, 0, 594, 595, 5, 100, 0, 0, 595, 596, 5, 121, 0, 0, 596, 597, 5, 110, 0, 0, 597, 598, 5, 97, 0, 0, 598, 599, 5, 109, 0, 0, 599, 600, 5, 105, 0, 0, 600, 601, 5, 99, 0, 0, 601, 602, 5, 95, 0, 0, 602, 603, 5, 99, 0, 0, 603, 604, 5, 97, 0, 0, 604, 605, 5, 115, 0, 0, 605, 606, 5, 116, 0, 0, 606, 62, 1, 0, 0, 0, 607, 608, 5, 101, 0, 0, 608, 609, 5, 108, 0, 0, 609, 610, 5, 115, 0, 0, 610, 611, 5, 101, 0, 0, 611, 64, 1, 0, 0, 0, 612, 613, 5, 101, 0, 0, 613, 614, 5, 110, 0, 0, 614, 615, 5, 117, 0, 0, 615, 616, 5, 109, 0, 0, 616, 66, 1, 0, 0, 0, 617, 618, 5, 101, 0, 0, 618, 619, 5, 120, 0, 0, 619, 620, 5, 112, 0, 0, 620, 621, 5, 108, 0, 0, 621, 622, 5, 105, 0, 0, 622, 623, 5, 99, 0, 0, 623, 624, 5, 105, 0, 0, 624, 625, 5, 116, 0, 0, 625, 68, 1, 0, 0, 0, 626, 627, 5, 101, 0, 0, 627, 628, 5, 120, 0, 0, 628, 629, 5, 112, 0, 0, 629, 630, 5, 111, 0, 0, 630, 631, 5, 114, 0, 0, 631, 632, 5, 116, 0, 0, 632, 70, 1, 0, 0, 0, 633, 634, 5, 101, 0, 0, 634, 635, 5, 120, 0, 0, 635, 636, 5, 116, 0, 0, 636, 637, 5, 101, 0, 0, 637, 638, 5, 114, 0, 0, 638, 639, 5, 110, 0, 0, 639, 72, 1, 0, 0, 0, 640, 641, 5, 102, 0, 0, 641, 642, 5, 97, 0, 0, 642, 643, 5, 108, 0, 0, 643, 644, 5, 115, 0, 0, 644, 645, 5, 101, 0, 0, 645, 74, 1, 0, 0, 0, 646, 647, 5, 102, 0, 0, 647, 648, 5, 105, 0, 0, 648, 649, 5, 110, 0, 0, 649, 650, 5, 97, 0, 0, 650, 651, 5, 108, 0, 0, 651, 76, 1, 0, 0, 0, 652, 653, 5, 102, 0, 0, 653, 654, 5, 108, 0, 0, 654, 655, 5, 111, 0, 0, 655, 656, 5, 97, 0, 0, 656, 657, 5, 116, 0, 0, 657, 78, 1, 0, 0, 0, 658, 659, 5, 102, 0, 0, 659, 660, 5, 111, 0, 0, 660, 661, 5, 114, 0, 0, 661, 80, 1, 0, 0, 0, 662, 663, 5, 102, 0, 0, 663, 664, 5, 114, 0, 0, 664, 665, 5, 105, 0, 0, 665, 666, 5, 101, 0, 0, 666, 667, 5, 110, 0, 0, 667, 668, 5, 100, 0, 0, 668, 82, 1, 0, 0, 0, 669, 670, 5, 103, 0, 0, 670, 671, 5, 111, 0, 0, 671, 672, 5, 116, 0, 0, 672, 673, 5, 111, 0, 0, 673, 84, 1, 0, 0, 0, 674, 675, 5, 105, 0, 0, 675, 676, 5, 102, 0, 0, 676, 86, 1, 0, 0, 0, 677, 678, 5, 105, 0, 0, 678, 679, 5, 110, 0, 0, 679, 680, 5, 108, 0, 0, 680, 681, 5, 105, 0, 0, 681, 682, 5, 110, 0, 0, 682, 683, 5, 101, 0, 0, 683, 88, 1, 0, 0, 0, 684, 685, 5, 105, 0, 0, 685, 686, 5, 110, 0, 0, 686, 687, 5, 116, 0, 0, 687, 90, 1, 0, 0, 0, 688, 689, 5, 108, 0, 0, 689, 690, 5, 111, 0, 0, 690, 691, 5, 110, 0, 0, 691, 692, 5, 103, 0, 0, 692, 92, 1, 0, 0, 0, 693, 694, 5, 109, 0, 0, 694, 695, 5, 117, 0, 0, 695, 696, 5, 116, 0, 0, 696, 697, 5, 97, 0, 0, 697, 698, 5, 98, 0, 0, 698, 699, 5, 108, 0, 0, 699, 700, 5, 101, 0, 0, 700, 94, 1, 0, 0, 0, 701, 702, 5, 110, 0, 0, 702, 703, 5, 97, 0, 0, 703, 704, 5, 109, 0, 0, 704, 705, 5, 101, 0, 0, 705, 706, 5, 115, 0, 0, 706, 707, 5, 112, 0, 0, 707, 708, 5, 97, 0, 0, 708, 709, 5, 99, 0, 0, 709, 710, 5, 101, 0, 0, 710, 96, 1, 0, 0, 0, 711, 712, 5, 110, 0, 0, 712, 713, 5, 101, 0, 0, 713, 714, 5, 119, 0, 0, 714, 98, 1, 0, 0, 0, 715, 716, 5, 110, 0, 0, 716, 717, 5, 111, 0, 0, 717, 718, 5, 101, 0, 0, 718, 719, 5, 120, 0, 0, 719, 720, 5, 99, 0, 0, 720, 721, 5, 101, 0, 0, 721, 722, 5, 112, 0, 0, 722, 723, 5, 116, 0, 0, 723, 100, 1, 0, 0, 0, 724, 725, 5, 110, 0, 0, 725, 726, 5, 117, 0, 0, 726, 727, 5, 108, 0, 0, 727, 728, 5, 108, 0, 0, 728, 729, 5, 112, 0, 0, 729, 730, 5, 116, 0, 0, 730, 731, 5, 114, 0, 0, 731, 102, 1, 0, 0, 0, 732, 733, 5, 111, 0, 0, 733, 734, 5, 112, 0, 0, 734, 735, 5, 101, 0, 0, 735, 736, 5, 114, 0, 0, 736, 737, 5, 97, 0, 0, 737, 738, 5, 116, 0, 0, 738, 739, 5, 111, 0, 0, 739, 740, 5, 114, 0, 0, 740, 104, 1, 0, 0, 0, 741, 742, 5, 111, 0, 0, 742, 743, 5, 118, 0, 0, 743, 744, 5, 101, 0, 0, 744, 745, 5, 114, 0, 0, 745, 746, 5, 114, 0, 0, 746, 747, 5, 105, 0, 0, 747, 748, 5, 100, 0, 0, 748, 749, 5, 101, 0, 0, 749, 106, 1, 0, 0, 0, 750, 751, 5, 112, 0, 0, 751, 752, 5, 114, 0, 0, 752, 753, 5, 105, 0, 0, 753, 754, 5, 118, 0, 0, 754, 755, 5, 97, 0, 0, 755, 756, 5, 116, 0, 0, 756, 757, 5, 101, 0, 0, 757, 108, 1, 0, 0, 0, 758, 759, 5, 112, 0, 0, 759, 760, 5, 114, 0, 0, 760, 761, 5, 111, 0, 0, 761, 762, 5, 116, 0, 0, 762, 763, 5, 101, 0, 0, 763, 764, 5, 99, 0, 0, 764, 765, 5, 116, 0, 0, 765, 766, 5, 101, 0, 0, 766, 767, 5, 100, 0, 0, 767, 110, 1, 0, 0, 0, 768, 769, 5, 112, 0, 0, 769, 770, 5, 117, 0, 0, 770, 771, 5, 98, 0, 0, 771, 772, 5, 108, 0, 0, 772, 773, 5, 105, 0, 0, 773, 774, 5, 99, 0, 0, 774, 112, 1, 0, 0, 0, 775, 776, 5, 114, 0, 0, 776, 777, 5, 101, 0, 0, 777, 778, 5, 103, 0, 0, 778, 779, 5, 105, 0, 0, 779, 780, 5, 115, 0, 0, 780, 781, 5, 116, 0, 0, 781, 782, 5, 101, 0, 0, 782, 783, 5, 114, 0, 0, 783, 114, 1, 0, 0, 0, 784, 785, 5, 114, 0, 0, 785, 786, 5, 101, 0, 0, 786, 787, 5, 105, 0, 0, 787, 788, 5, 110, 0, 0, 788, 789, 5, 116, 0, 0, 789, 790, 5, 101, 0, 0, 790, 791, 5, 114, 0, 0, 791, 792, 5, 112, 0, 0, 792, 793, 5, 114, 0, 0, 793, 794, 5, 101, 0, 0, 794, 795, 5, 116, 0, 0, 795, 796, 5, 95, 0, 0, 796, 797, 5, 99, 0, 0, 797, 798, 5, 97, 0, 0, 798, 799, 5, 115, 0, 0, 799, 800, 5, 116, 0, 0, 800, 116, 1, 0, 0, 0, 801, 802, 5, 114, 0, 0, 802, 803, 5, 101, 0, 0, 803, 804, 5, 116, 0, 0, 804, 805, 5, 117, 0, 0, 805, 806, 5, 114, 0, 0, 806, 807, 5, 110, 0, 0, 807, 118, 1, 0, 0, 0, 808, 809, 5, 115, 0, 0, 809, 810, 5, 104, 0, 0, 810, 811, 5, 111, 0, 0, 811, 812, 5, 114, 0, 0, 812, 813, 5, 116, 0, 0, 813, 120, 1, 0, 0, 0, 814, 815, 5, 115, 0, 0, 815, 816, 5, 105, 0, 0, 816, 817, 5, 103, 0, 0, 817, 818, 5, 110, 0, 0, 818, 819, 5, 101, 0, 0, 819, 820, 5, 100, 0, 0, 820, 122, 1, 0, 0, 0, 821, 822, 5, 115, 0, 0, 822, 823, 5, 105, 0, 0, 823, 824, 5, 122, 0, 0, 824, 825, 5, 101, 0, 0, 825, 826, 5, 111, 0, 0, 826, 827, 5, 102, 0, 0, 827, 124, 1, 0, 0, 0, 828, 829, 5, 115, 0, 0, 829, 830, 5, 116, 0, 0, 830, 831, 5, 97, 0, 0, 831, 832, 5, 116, 0, 0, 832, 833, 5, 105, 0, 0, 833, 834, 5, 99, 0, 0, 834, 126, 1, 0, 0, 0, 835, 836, 5, 115, 0, 0, 836, 837, 5, 116, 0, 0, 837, 838, 5, 97, 0, 0, 838, 839, 5, 116, 0, 0, 839, 840, 5, 105, 0, 0, 840, 841, 5, 99, 0, 0, 841, 842, 5, 95, 0, 0, 842, 843, 5, 97, 0, 0, 843, 844, 5, 115, 0, 0, 844, 845, 5, 115, 0, 0, 845, 846, 5, 101, 0, 0, 846, 847, 5, 114, 0, 0, 847, 848, 5, 116, 0, 0, 848, 128, 1, 0, 0, 0, 849, 850, 5, 115, 0, 0, 850, 851, 5, 116, 0, 0, 851, 852, 5, 97, 0, 0, 852, 853, 5, 116, 0, 0, 853, 854, 5, 105, 0, 0, 854, 855, 5, 99, 0, 0, 855, 856, 5, 95, 0, 0, 856, 857, 5, 99, 0, 0, 857, 858, 5, 97, 0, 0, 858, 859, 5, 115, 0, 0, 859, 860, 5, 116, 0, 0, 860, 130, 1, 0, 0, 0, 861, 862, 5, 115, 0, 0, 862, 863, 5, 116, 0, 0, 863, 864, 5, 114, 0, 0, 864, 865, 5, 117, 0, 0, 865, 866, 5, 99, 0, 0, 866, 867, 5, 116, 0, 0, 867, 132, 1, 0, 0, 0, 868, 869, 5, 115, 0, 0, 869, 870, 5, 119, 0, 0, 870, 871, 5, 105, 0, 0, 871, 872, 5, 116, 0, 0, 872, 873, 5, 99, 0, 0, 873, 874, 5, 104, 0, 0, 874, 134, 1, 0, 0, 0, 875, 876, 5, 116, 0, 0, 876, 877, 5, 101, 0, 0, 877, 878, 5, 109, 0, 0, 878, 879, 5, 112, 0, 0, 879, 880, 5, 108, 0, 0, 880, 881, 5, 97, 0, 0, 881, 882, 5, 116, 0, 0, 882, 883, 5, 101, 0, 0, 883, 136, 1, 0, 0, 0, 884, 885, 5, 116, 0, 0, 885, 886, 5, 104, 0, 0, 886, 887, 5, 105, 0, 0, 887, 888, 5, 115, 0, 0, 888, 138, 1, 0, 0, 0, 889, 890, 5, 116, 0, 0, 890, 891, 5, 104, 0, 0, 891, 892, 5, 114, 0, 0, 892, 893, 5, 101, 0, 0, 893, 894, 5, 97, 0, 0, 894, 895, 5, 100, 0, 0, 895, 896, 5, 95, 0, 0, 896, 897, 5, 108, 0, 0, 897, 898, 5, 111, 0, 0, 898, 899, 5, 99, 0, 0, 899, 900, 5, 97, 0, 0, 900, 901, 5, 108, 0, 0, 901, 140, 1, 0, 0, 0, 902, 903, 5, 116, 0, 0, 903, 904, 5, 104, 0, 0, 904, 905, 5, 114, 0, 0, 905, 906, 5, 111, 0, 0, 906, 907, 5, 119, 0, 0, 907, 142, 1, 0, 0, 0, 908, 909, 5, 116, 0, 0, 909, 910, 5, 114, 0, 0, 910, 911, 5, 117, 0, 0, 911, 912, 5, 101, 0, 0, 912, 144, 1, 0, 0, 0, 913, 914, 5, 116, 0, 0, 914, 915, 5, 114, 0, 0, 915, 916, 5, 121, 0, 0, 916, 146, 1, 0, 0, 0, 917, 918, 5, 116, 0, 0, 918, 919, 5, 121, 0, 0, 919, 920, 5, 112, 0, 0, 920, 921, 5, 101, 0, 0, 921, 922, 5, 100, 0, 0, 922, 923, 5, 101, 0, 0, 923, 924, 5, 102, 0, 0, 924, 148, 1, 0, 0, 0, 925, 926, 5, 116, 0, 0, 926, 927, 5, 121, 0, 0, 927, 928, 5, 112, 0, 0, 928, 929, 5, 101, 0, 0, 929, 930, 5, 105, 0, 0, 930, 931, 5, 100, 0, 0, 931, 150, 1, 0, 0, 0, 932, 933, 5, 116, 0, 0, 933, 934, 5, 121, 0, 0, 934, 935, 5, 112, 0, 0, 935, 936, 5, 101, 0, 0, 936, 937, 5, 110, 0, 0, 937, 938, 5, 97, 0, 0, 938, 939, 5, 109, 0, 0, 939, 940, 5, 101, 0, 0, 940, 152, 1, 0, 0, 0, 941, 942, 5, 117, 0, 0, 942, 943, 5, 110, 0, 0, 943, 944, 5, 105, 0, 0, 944, 945, 5, 111, 0, 0, 945, 946, 5, 110, 0, 0, 946, 154, 1, 0, 0, 0, 947, 948, 5, 117, 0, 0, 948, 949, 5, 110, 0, 0, 949, 950, 5, 115, 0, 0, 950, 951, 5, 105, 0, 0, 951, 952, 5, 103, 0, 0, 952, 953, 5, 110, 0, 0, 953, 954, 5, 101, 0, 0, 954, 955, 5, 100, 0, 0, 955, 156, 1, 0, 0, 0, 956, 957, 5, 117, 0, 0, 957, 958, 5, 115, 0, 0, 958, 959, 5, 105, 0, 0, 959, 960, 5, 110, 0, 0, 960, 961, 5, 103, 0, 0, 961, 158, 1, 0, 0, 0, 962, 963, 5, 118, 0, 0, 963, 964, 5, 105, 0, 0, 964, 965, 5, 114, 0, 0, 965, 966, 5, 116, 0, 0, 966, 967, 5, 117, 0, 0, 967, 968, 5, 97, 0, 0, 968, 969, 5, 108, 0, 0, 969, 160, 1, 0, 0, 0, 970, 971, 5, 118, 0, 0, 971, 972, 5, 111, 0, 0, 972, 973, 5, 105, 0, 0, 973, 974, 5, 100, 0, 0, 974, 162, 1, 0, 0, 0, 975, 976, 5, 118, 0, 0, 976, 977, 5, 111, 0, 0, 977, 978, 5, 108, 0, 0, 978, 979, 5, 97, 0, 0, 979, 980, 5, 116, 0, 0, 980, 981, 5, 105, 0, 0, 981, 982, 5, 108, 0, 0, 982, 983, 5, 101, 0, 0, 983, 164, 1, 0, 0, 0, 984, 985, 5, 119, 0, 0, 985, 986, 5, 99, 0, 0, 986, 987, 5, 104, 0, 0, 987, 988, 5, 97, 0, 0, 988, 989, 5, 114, 0, 0, 989, 990, 5, 95, 0, 0, 990, 991, 5, 116, 0, 0, 991, 166, 1, 0, 0, 0, 992, 993, 5, 119, 0, 0, 993, 994, 5, 104, 0, 0, 994, 995, 5, 105, 0, 0, 995, 996, 5, 108, 0, 0, 996, 997, 5, 101, 0, 0, 997, 168, 1, 0, 0, 0, 998, 999, 5, 40, 0, 0, 999, 170, 1, 0, 0, 0, 1000, 1001, 5, 41, 0, 0, 1001, 172, 1, 0, 0, 0, 1002, 1003, 5, 91, 0, 0, 1003, 174, 1, 0, 0, 0, 1004, 1005, 5, 93, 0, 0, 1005, 176, 1, 0, 0, 0, 1006, 1007, 5, 123, 0, 0, 1007, 178, 1, 0, 0, 0, 1008, 1009, 5, 125, 0, 0, 1009, 180, 1, 0, 0, 0, 1010, 1011, 5, 43, 0, 0, 1011, 182, 1, 0, 0, 0, 1012, 1013, 5, 45, 0, 0, 1013, 184, 1, 0, 0, 0, 1014, 1015, 5, 42, 0, 0, 1015, 186, 1, 0, 0, 0, 1016, 1017, 5, 47, 0, 0, 1017, 188, 1, 0, 0, 0, 1018, 1019, 5, 37, 0, 0, 1019, 190, 1, 0, 0, 0, 1020, 1021, 5, 94, 0, 0, 1021, 192, 1, 0, 0, 0, 1022, 1023, 5, 38, 0, 0, 1023, 194, 1, 0, 0, 0, 1024, 1025, 5, 124, 0, 0, 1025, 196, 1, 0, 0, 0, 1026, 1027, 5, 126, 0, 0, 1027, 198, 1, 0, 0, 0, 1028, 1033, 5, 33, 0, 0, 1029, 1030, 5, 110, 0, 0, 1030, 1031, 5, 111, 0, 0, 1031, 1033, 5, 116, 0, 0, 1032, 1028, 1, 0, 0, 0, 1032, 1029, 1, 0, 0, 0, 1033, 200, 1, 0, 0, 0, 1034, 1035, 5, 61, 0, 0, 1035, 202, 1, 0, 0, 0, 1036, 1037, 5, 60, 0, 0, 1037, 204, 1, 0, 0, 0, 1038, 1039, 5, 62, 0, 0, 1039, 206, 1, 0, 0, 0, 1040, 1041, 5, 43, 0, 0, 1041, 1042, 5, 61, 0, 0, 1042, 208, 1, 0, 0, 0, 1043, 1044, 5, 45, 0, 0, 1044, 1045, 5, 61, 0, 0, 1045, 210, 1, 0, 0, 0, 1046, 1047, 5, 42, 0, 0, 1047, 1048, 5, 61, 0, 0, 1048, 212, 1, 0, 0, 0, 1049, 1050, 5, 47, 0, 0, 1050, 1051, 5, 61, 0, 0, 1051, 214, 1, 0, 0, 0, 1052, 1053, 5, 37, 0, 0, 1053, 1054, 5, 61, 0, 0, 1054, 216, 1, 0, 0, 0, 1055, 1056, 5, 94, 0, 0, 1056, 1057, 5, 61, 0, 0, 1057, 218, 1, 0, 0, 0, 1058, 1059, 5, 38, 0, 0, 1059, 1060, 5, 61, 0, 0, 1060, 220, 1, 0, 0, 0, 1061, 1062, 5, 124, 0, 0, 1062, 1063, 5, 61, 0, 0, 1063, 222, 1, 0, 0, 0, 1064, 1065, 5, 60, 0, 0, 1065, 1066, 5, 60, 0, 0, 1066, 1067, 5, 61, 0, 0, 1067, 224, 1, 0, 0, 0, 1068, 1069, 5, 62, 0, 0, 1069, 1070, 5, 62, 0, 0, 1070, 1071, 5, 61, 0, 0, 1071, 226, 1, 0, 0, 0, 1072, 1073, 5, 61, 0, 0, 1073, 1074, 5, 61, 0, 0, 1074, 228, 1, 0, 0, 0, 1075, 1076, 5, 33, 0, 0, 1076, 1077, 5, 61, 0, 0, 1077, 230, 1, 0, 0, 0, 1078, 1079, 5, 60, 0, 0, 1079, 1080, 5, 61, 0, 0, 1080, 232, 1, 0, 0, 0, 1081, 1082, 5, 62, 0, 0, 1082, 1083, 5, 61, 0, 0, 1083, 234, 1, 0, 0, 0, 1084, 1085, 5, 38, 0, 0, 1085, 1090, 5, 38, 0, 0, 1086, 1087, 5, 97, 0, 0, 1087, 1088, 5, 110, 0, 0, 1088, 1090, 5, 100, 0, 0, 1089, 1084, 1, 0, 0, 0, 1089, 1086, 1, 0, 0, 0, 1090, 236, 1, 0, 0, 0, 1091, 1092, 5, 124, 0, 0, 1092, 1096, 5, 124, 0, 0, 1093, 1094, 5, 111, 0, 0, 1094, 1096, 5, 114, 0, 0, 1095, 1091, 1, 0, 0, 0, 1095, 1093, 1, 0, 0, 0, 1096, 238, 1, 0, 0, 0, 1097, 1098, 5, 43, 0, 0, 1098, 1099, 5, 43, 0, 0, 1099, 240, 1, 0, 0, 0, 1100, 1101, 5, 45, 0, 0, 1101, 1102, 5, 45, 0, 0, 1102, 242, 1, 0, 0, 0, 1103, 1104, 5, 44, 0, 0, 1104, 244, 1, 0, 0, 0, 1105, 1106, 5, 45, 0, 0, 1106, 1107, 5, 62, 0, 0, 1107, 1108, 5, 42, 0, 0, 1108, 246, 1, 0, 0, 0, 1109, 1110, 5, 45, 0, 0, 1110, 1111, 5, 62, 0, 0, 1111, 248, 1, 0, 0, 0, 1112, 1113, 5, 63, 0, 0, 1113, 250, 1, 0, 0, 0, 1114, 1115, 5, 58, 0, 0, 1115, 252, 1, 0, 0, 0, 1116, 1117, 5, 58, 0, 0, 1117, 1118, 5, 58, 0, 0, 1118, 254, 1, 0, 0, 0, 1119, 1120, 5, 59, 0, 0, 1120, 256, 1, 0, 0, 0, 1121, 1122, 5, 46, 0, 0, 1122, 258, 1, 0, 0, 0, 1123, 1124, 5, 46, 0, 0, 1124, 1125, 5, 42, 0, 0, 1125, 260, 1, 0, 0, 0, 1126, 1127, 5, 46, 0, 0, 1127, 1128, 5, 46, 0, 0, 1128, 1129, 5, 46, 0, 0, 1129, 262, 1, 0, 0, 0, 1130, 1131, 3, 287, 143, 0, 1131, 1132, 3, 287, 143, 0, 1132, 1133, 3, 287, 143, 0, 1133, 1134, 3, 287, 143, 0, 1134, 264, 1, 0, 0, 0, 1135, 1136, 5, 92, 0, 0, 1136, 1137, 5, 117, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1146, 3, 263, 131, 0, 1139, 1140, 5, 92, 0, 0, 1140, 1141, 5, 85, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 1143, 3, 263, 131, 0, 1143, 1144, 3, 263, 131, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1135, 1, 0, 0, 0, 1145, 1139, 1, 0, 0, 0, 1146, 266, 1, 0, 0, 0, 1147, 1152, 3, 269, 134, 0, 1148, 1151, 3, 269, 134, 0, 1149, 1151, 3, 273, 136, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1149, 1, 0, 0, 0, 1151, 1154, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 268, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1155, 1158, 3, 271, 135, 0, 1156, 1158, 3, 265, 132, 0, 1157, 1155, 1, 0, 0, 0, 1157, 1156, 1, 0, 0, 0, 1158, 270, 1, 0, 0, 0, 1159, 1160, 7, 2, 0, 0, 1160, 272, 1, 0, 0, 0, 1161, 1162, 7, 3, 0, 0, 1162, 274, 1, 0, 0, 0, 1163, 1170, 3, 283, 141, 0, 1164, 1166, 5, 39, 0, 0, 1165, 1164, 1, 0, 0, 0, 1165, 1166, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1169, 3, 273, 136, 0, 1168, 1165, 1, 0, 0, 0, 1169, 1172, 1, 0, 0, 0, 1170, 1168, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 276, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1173, 1180, 5, 48, 0, 0, 1174, 1176, 5, 39, 0, 0, 1175, 1174, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1177, 1, 0, 0, 0, 1177, 1179, 3, 285, 142, 0, 1178, 1175, 1, 0, 0, 0, 1179, 1182, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 278, 1, 0, 0, 0, 1182, 1180, 1, 0, 0, 0, 1183, 1184, 5, 48, 0, 0, 1184, 1188, 5, 120, 0, 0, 1185, 1186, 5, 48, 0, 0, 1186, 1188, 5, 88, 0, 0, 1187, 1183, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1196, 3, 287, 143, 0, 1190, 1192, 5, 39, 0, 0, 1191, 1190, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1195, 3, 287, 143, 0, 1194, 1191, 1, 0, 0, 0, 1195, 1198, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1196, 1197, 1, 0, 0, 0, 1197, 280, 1, 0, 0, 0, 1198, 1196, 1, 0, 0, 0, 1199, 1200, 5, 48, 0, 0, 1200, 1204, 5, 98, 0, 0, 1201, 1202, 5, 48, 0, 0, 1202, 1204, 5, 66, 0, 0, 1203, 1199, 1, 0, 0, 0, 1203, 1201, 1, 0, 0, 0, 1204, 1205, 1, 0, 0, 0, 1205, 1212, 3, 289, 144, 0, 1206, 1208, 5, 39, 0, 0, 1207, 1206, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1211, 3, 289, 144, 0, 1210, 1207, 1, 0, 0, 0, 1211, 1214, 1, 0, 0, 0, 1212, 1210, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 282, 1, 0, 0, 0, 1214, 1212, 1, 0, 0, 0, 1215, 1216, 7, 4, 0, 0, 1216, 284, 1, 0, 0, 0, 1217, 1218, 7, 5, 0, 0, 1218, 286, 1, 0, 0, 0, 1219, 1220, 7, 6, 0, 0, 1220, 288, 1, 0, 0, 0, 1221, 1222, 7, 7, 0, 0, 1222, 290, 1, 0, 0, 0, 1223, 1225, 3, 293, 146, 0, 1224, 1226, 3, 295, 147, 0, 1225, 1224, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1240, 1, 0, 0, 0, 1227, 1229, 3, 293, 146, 0, 1228, 1230, 3, 297, 148, 0, 1229, 1228, 1, 0, 0, 0, 1229, 1230, 1, 0, 0, 0, 1230, 1240, 1, 0, 0, 0, 1231, 1233, 3, 295, 147, 0, 1232, 1234, 3, 293, 146, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1240, 1, 0, 0, 0, 1235, 1237, 3, 297, 148, 0, 1236, 1238, 3, 293, 146, 0, 1237, 1236, 1, 0, 0, 0, 1237, 1238, 1, 0, 0, 0, 1238, 1240, 1, 0, 0, 0, 1239, 1223, 1, 0, 0, 0, 1239, 1227, 1, 0, 0, 0, 1239, 1231, 1, 0, 0, 0, 1239, 1235, 1, 0, 0, 0, 1240, 292, 1, 0, 0, 0, 1241, 1242, 7, 8, 0, 0, 1242, 294, 1, 0, 0, 0, 1243, 1244, 7, 9, 0, 0, 1244, 296, 1, 0, 0, 0, 1245, 1246, 5, 108, 0, 0, 1246, 1250, 5, 108, 0, 0, 1247, 1248, 5, 76, 0, 0, 1248, 1250, 5, 76, 0, 0, 1249, 1245, 1, 0, 0, 0, 1249, 1247, 1, 0, 0, 0, 1250, 298, 1, 0, 0, 0, 1251, 1255, 8, 10, 0, 0, 1252, 1255, 3, 301, 150, 0, 1253, 1255, 3, 265, 132, 0, 1254, 1251, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1254, 1253, 1, 0, 0, 0, 1255, 300, 1, 0, 0, 0, 1256, 1260, 3, 303, 151, 0, 1257, 1260, 3, 305, 152, 0, 1258, 1260, 3, 307, 153, 0, 1259, 1256, 1, 0, 0, 0, 1259, 1257, 1, 0, 0, 0, 1259, 1258, 1, 0, 0, 0, 1260, 302, 1, 0, 0, 0, 1261, 1262, 5, 92, 0, 0, 1262, 1292, 5, 39, 0, 0, 1263, 1264, 5, 92, 0, 0, 1264, 1292, 5, 34, 0, 0, 1265, 1266, 5, 92, 0, 0, 1266, 1292, 5, 63, 0, 0, 1267, 1268, 5, 92, 0, 0, 1268, 1292, 5, 92, 0, 0, 1269, 1270, 5, 92, 0, 0, 1270, 1292, 5, 97, 0, 0, 1271, 1272, 5, 92, 0, 0, 1272, 1292, 5, 98, 0, 0, 1273, 1274, 5, 92, 0, 0, 1274, 1292, 5, 102, 0, 0, 1275, 1276, 5, 92, 0, 0, 1276, 1292, 5, 110, 0, 0, 1277, 1278, 5, 92, 0, 0, 1278, 1292, 5, 114, 0, 0, 1279, 1285, 5, 92, 0, 0, 1280, 1282, 5, 13, 0, 0, 1281, 1283, 5, 10, 0, 0, 1282, 1281, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1286, 5, 10, 0, 0, 1285, 1280, 1, 0, 0, 0, 1285, 1284, 1, 0, 0, 0, 1286, 1292, 1, 0, 0, 0, 1287, 1288, 5, 92, 0, 0, 1288, 1292, 5, 116, 0, 0, 1289, 1290, 5, 92, 0, 0, 1290, 1292, 5, 118, 0, 0, 1291, 1261, 1, 0, 0, 0, 1291, 1263, 1, 0, 0, 0, 1291, 1265, 1, 0, 0, 0, 1291, 1267, 1, 0, 0, 0, 1291, 1269, 1, 0, 0, 0, 1291, 1271, 1, 0, 0, 0, 1291, 1273, 1, 0, 0, 0, 1291, 1275, 1, 0, 0, 0, 1291, 1277, 1, 0, 0, 0, 1291, 1279, 1, 0, 0, 0, 1291, 1287, 1, 0, 0, 0, 1291, 1289, 1, 0, 0, 0, 1292, 304, 1, 0, 0, 0, 1293, 1294, 5, 92, 0, 0, 1294, 1305, 3, 285, 142, 0, 1295, 1296, 5, 92, 0, 0, 1296, 1297, 3, 285, 142, 0, 1297, 1298, 3, 285, 142, 0, 1298, 1305, 1, 0, 0, 0, 1299, 1300, 5, 92, 0, 0, 1300, 1301, 3, 285, 142, 0, 1301, 1302, 3, 285, 142, 0, 1302, 1303, 3, 285, 142, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1293, 1, 0, 0, 0, 1304, 1295, 1, 0, 0, 0, 1304, 1299, 1, 0, 0, 0, 1305, 306, 1, 0, 0, 0, 1306, 1307, 5, 92, 0, 0, 1307, 1308, 5, 120, 0, 0, 1308, 1310, 1, 0, 0, 0, 1309, 1311, 3, 287, 143, 0, 1310, 1309, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 308, 1, 0, 0, 0, 1314, 1316, 3, 315, 157, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 1318, 5, 46, 0, 0, 1318, 1323, 3, 315, 157, 0, 1319, 1320, 3, 315, 157, 0, 1320, 1321, 5, 46, 0, 0, 1321, 1323, 1, 0, 0, 0, 1322, 1315, 1, 0, 0, 0, 1322, 1319, 1, 0, 0, 0, 1323, 310, 1, 0, 0, 0, 1324, 1326, 5, 101, 0, 0, 1325, 1327, 3, 313, 156, 0, 1326, 1325, 1, 0, 0, 0, 1326, 1327, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 1335, 3, 315, 157, 0, 1329, 1331, 5, 69, 0, 0, 1330, 1332, 3, 313, 156, 0, 1331, 1330, 1, 0, 0, 0, 1331, 1332, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1335, 3, 315, 157, 0, 1334, 1324, 1, 0, 0, 0, 1334, 1329, 1, 0, 0, 0, 1335, 312, 1, 0, 0, 0, 1336, 1337, 7, 11, 0, 0, 1337, 314, 1, 0, 0, 0, 1338, 1345, 3, 273, 136, 0, 1339, 1341, 5, 39, 0, 0, 1340, 1339, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1344, 3, 273, 136, 0, 1343, 1340, 1, 0, 0, 0, 1344, 1347, 1, 0, 0, 0, 1345, 1343, 1, 0, 0, 0, 1345, 1346, 1, 0, 0, 0, 1346, 316, 1, 0, 0, 0, 1347, 1345, 1, 0, 0, 0, 1348, 1349, 7, 12, 0, 0, 1349, 318, 1, 0, 0, 0, 1350, 1351, 5, 117, 0, 0, 1351, 1354, 5, 56, 0, 0, 1352, 1354, 7, 0, 0, 0, 1353, 1350, 1, 0, 0, 0, 1353, 1352, 1, 0, 0, 0, 1354, 320, 1, 0, 0, 0, 1355, 1359, 8, 13, 0, 0, 1356, 1359, 3, 301, 150, 0, 1357, 1359, 3, 265, 132, 0, 1358, 1355, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1358, 1357, 1, 0, 0, 0, 1359, 322, 1, 0, 0, 0, 1360, 1364, 5, 34, 0, 0, 1361, 1363, 8, 14, 0, 0, 1362, 1361, 1, 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1367, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1371, 5, 40, 0, 0, 1368, 1370, 8, 15, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 1373, 1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 1378, 5, 41, 0, 0, 1375, 1377, 8, 16, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 1380, 1, 0, 0, 0, 1378, 1376, 1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1381, 1, 0, 0, 0, 1380, 1378, 1, 0, 0, 0, 1381, 1382, 5, 34, 0, 0, 1382, 324, 1, 0, 0, 0, 1383, 1384, 3, 275, 137, 0, 1384, 1385, 3, 333, 166, 0, 1385, 1396, 1, 0, 0, 0, 1386, 1387, 3, 277, 138, 0, 1387, 1388, 3, 333, 166, 0, 1388, 1396, 1, 0, 0, 0, 1389, 1390, 3, 279, 139, 0, 1390, 1391, 3, 333, 166, 0, 1391, 1396, 1, 0, 0, 0, 1392, 1393, 3, 281, 140, 0, 1393, 1394, 3, 333, 166, 0, 1394, 1396, 1, 0, 0, 0, 1395, 1383, 1, 0, 0, 0, 1395, 1386, 1, 0, 0, 0, 1395, 1389, 1, 0, 0, 0, 1395, 1392, 1, 0, 0, 0, 1396, 326, 1, 0, 0, 0, 1397, 1399, 3, 309, 154, 0, 1398, 1400, 3, 311, 155, 0, 1399, 1398, 1, 0, 0, 0, 1399, 1400, 1, 0, 0, 0, 1400, 1401, 1, 0, 0, 0, 1401, 1402, 3, 333, 166, 0, 1402, 1408, 1, 0, 0, 0, 1403, 1404, 3, 315, 157, 0, 1404, 1405, 3, 311, 155, 0, 1405, 1406, 3, 333, 166, 0, 1406, 1408, 1, 0, 0, 0, 1407, 1397, 1, 0, 0, 0, 1407, 1403, 1, 0, 0, 0, 1408, 328, 1, 0, 0, 0, 1409, 1410, 3, 7, 3, 0, 1410, 1411, 3, 333, 166, 0, 1411, 330, 1, 0, 0, 0, 1412, 1413, 3, 3, 1, 0, 1413, 1414, 3, 333, 166, 0, 1414, 332, 1, 0, 0, 0, 1415, 1416, 3, 267, 133, 0, 1416, 334, 1, 0, 0, 0, 1417, 1419, 7, 17, 0, 0, 1418, 1417, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1418, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1423, 6, 167, 1, 0, 1423, 336, 1, 0, 0, 0, 1424, 1426, 5, 13, 0, 0, 1425, 1427, 5, 10, 0, 0, 1426, 1425, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 1430, 1, 0, 0, 0, 1428, 1430, 5, 10, 0, 0, 1429, 1424, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1432, 6, 168, 1, 0, 1432, 338, 1, 0, 0, 0, 1433, 1434, 5, 47, 0, 0, 1434, 1435, 5, 42, 0, 0, 1435, 1439, 1, 0, 0, 0, 1436, 1438, 9, 0, 0, 0, 1437, 1436, 1, 0, 0, 0, 1438, 1441, 1, 0, 0, 0, 1439, 1440, 1, 0, 0, 0, 1439, 1437, 1, 0, 0, 0, 1440, 1442, 1, 0, 0, 0, 1441, 1439, 1, 0, 0, 0, 1442, 1443, 5, 42, 0, 0, 1443, 1444, 5, 47, 0, 0, 1444, 1445, 1, 0, 0, 0, 1445, 1446, 6, 169, 1, 0, 1446, 340, 1, 0, 0, 0, 1447, 1448, 5, 47, 0, 0, 1448, 1449, 5, 47, 0, 0, 1449, 1453, 1, 0, 0, 0, 1450, 1452, 8, 18, 0, 0, 1451, 1450, 1, 0, 0, 0, 1452, 1455, 1, 0, 0, 0, 1453, 1451, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1456, 1, 0, 0, 0, 1455, 1453, 1, 0, 0, 0, 1456, 1457, 6, 170, 1, 0, 1457, 342, 1, 0, 0, 0, 73, 0, 345, 349, 353, 357, 359, 362, 368, 374, 377, 382, 384, 387, 393, 398, 402, 406, 414, 420, 425, 430, 435, 443, 1032, 1089, 1095, 1145, 1150, 1152, 1157, 1165, 1170, 1175, 1180, 1187, 1191, 1196, 1203, 1207, 1212, 1225, 1229, 1233, 1237, 1239, 1249, 1254, 1259, 1282, 1285, 1291, 1304, 1312, 1315, 1322, 1326, 1331, 1334, 1340, 1345, 1353, 1358, 1364, 1371, 1378, 1395, 1399, 1407, 1420, 1426, 1429, 1439, 1453, 2, 0, 1, 0, 6, 0, 0] \ No newline at end of file diff --git a/src/main/java/CPP14Lexer.java b/src/main/java/CPP14Lexer.java new file mode 100644 index 0000000..aec9dcf --- /dev/null +++ b/src/main/java/CPP14Lexer.java @@ -0,0 +1,1158 @@ +// Generated from CPP14Lexer.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class CPP14Lexer extends Lexer { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + IntegerLiteral = 1, CharacterLiteral = 2, FloatingLiteral = 3, StringLiteral = 4, + BooleanLiteral = 5, PointerLiteral = 6, UserDefinedLiteral = 7, MultiLineMacro = 8, + Directive = 9, Alignas = 10, Alignof = 11, Asm = 12, Auto = 13, Bool = 14, Break = 15, + Case = 16, Catch = 17, Char = 18, Char16 = 19, Char32 = 20, Class = 21, Const = 22, + Constexpr = 23, Const_cast = 24, Continue = 25, Decltype = 26, Default = 27, Delete = 28, + Do = 29, Double = 30, Dynamic_cast = 31, Else = 32, Enum = 33, Explicit = 34, Export = 35, + Extern = 36, False_ = 37, Final = 38, Float = 39, For = 40, Friend = 41, Goto = 42, + If = 43, Inline = 44, Int = 45, Long = 46, Mutable = 47, Namespace = 48, New = 49, Noexcept = 50, + Nullptr = 51, Operator = 52, Override = 53, Private = 54, Protected = 55, Public = 56, + Register = 57, Reinterpret_cast = 58, Return = 59, Short = 60, Signed = 61, Sizeof = 62, + Static = 63, Static_assert = 64, Static_cast = 65, Struct = 66, Switch = 67, Template = 68, + This = 69, Thread_local = 70, Throw = 71, True_ = 72, Try = 73, Typedef = 74, Typeid_ = 75, + Typename_ = 76, Union = 77, Unsigned = 78, Using = 79, Virtual = 80, Void = 81, Volatile = 82, + Wchar = 83, While = 84, LeftParen = 85, RightParen = 86, LeftBracket = 87, RightBracket = 88, + LeftBrace = 89, RightBrace = 90, Plus = 91, Minus = 92, Star = 93, Div = 94, Mod = 95, + Caret = 96, And = 97, Or = 98, Tilde = 99, Not = 100, Assign = 101, Less = 102, Greater = 103, + PlusAssign = 104, MinusAssign = 105, StarAssign = 106, DivAssign = 107, ModAssign = 108, + XorAssign = 109, AndAssign = 110, OrAssign = 111, LeftShiftAssign = 112, RightShiftAssign = 113, + Equal = 114, NotEqual = 115, LessEqual = 116, GreaterEqual = 117, AndAnd = 118, + OrOr = 119, PlusPlus = 120, MinusMinus = 121, Comma = 122, ArrowStar = 123, Arrow = 124, + Question = 125, Colon = 126, Doublecolon = 127, Semi = 128, Dot = 129, DotStar = 130, + Ellipsis = 131, Identifier = 132, DecimalLiteral = 133, OctalLiteral = 134, HexadecimalLiteral = 135, + BinaryLiteral = 136, Integersuffix = 137, UserDefinedIntegerLiteral = 138, UserDefinedFloatingLiteral = 139, + UserDefinedStringLiteral = 140, UserDefinedCharacterLiteral = 141, Whitespace = 142, + Newline = 143, BlockComment = 144, LineComment = 145; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[]{ + "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", + "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", + "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", + "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", + "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", + "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", + "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", + "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", + "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", + "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", + "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", + "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", + "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", + "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", + "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", + "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", + "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Hexquad", "Universalcharactername", + "Identifier", "Identifiernondigit", "NONDIGIT", "DIGIT", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "NONZERODIGIT", + "OCTALDIGIT", "HEXADECIMALDIGIT", "BINARYDIGIT", "Integersuffix", "Unsignedsuffix", + "Longsuffix", "Longlongsuffix", "Cchar", "Escapesequence", "Simpleescapesequence", + "Octalescapesequence", "Hexadecimalescapesequence", "Fractionalconstant", + "Exponentpart", "SIGN", "Digitsequence", "Floatingsuffix", "Encodingprefix", + "Schar", "Rawstring", "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", + "UserDefinedStringLiteral", "UserDefinedCharacterLiteral", "Udsuffix", + "Whitespace", "Newline", "BlockComment", "LineComment" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, null, null, null, null, null, null, null, null, null, "'alignas'", + "'alignof'", "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", + "'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", + "'const_cast'", "'continue'", "'decltype'", "'default'", "'delete'", + "'do'", "'double'", "'dynamic_cast'", "'else'", "'enum'", "'explicit'", + "'export'", "'extern'", "'false'", "'final'", "'float'", "'for'", "'friend'", + "'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", + "'new'", "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", + "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", + "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", "'static_cast'", + "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", "'throw'", + "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", + "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", + "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", + "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", null, "'='", "'<'", "'>'", + "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", "'|='", "'<<='", + "'>>='", "'=='", "'!='", "'<='", "'>='", null, null, "'++'", "'--'", + "','", "'->*'", "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", + "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", + "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", + "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", + "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", + "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", + "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", + "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", + "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", + "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", + "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", + "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", + "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", + "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", + "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", + "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", + "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", + "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", + "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", + "LineComment" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public CPP14Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @Override + public String getGrammarFileName() { + return "CPP14Lexer.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public static final String _serializedATN = + "\u0004\u0000\u0091\u05b2\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002" + + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002" + + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002" + + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002" + + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e" + + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011" + + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014" + + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017" + + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a" + + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d" + + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!" + + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002" + + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002" + + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002" + + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002" + + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002" + + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002" + + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002" + + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002" + + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002" + + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002" + + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002" + + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002" + + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002" + + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002" + + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002" + + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002" + + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002" + + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002" + + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f" + + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082" + + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085" + + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088" + + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b" + + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e" + + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091" + + "\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094" + + "\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097" + + "\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a" + + "\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d" + + "\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0" + + "\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3" + + "\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6" + + "\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9" + + "\u0002\u00aa\u0007\u00aa\u0001\u0000\u0001\u0000\u0003\u0000\u015a\b\u0000" + + "\u0001\u0000\u0001\u0000\u0003\u0000\u015e\b\u0000\u0001\u0000\u0001\u0000" + + "\u0003\u0000\u0162\b\u0000\u0001\u0000\u0001\u0000\u0003\u0000\u0166\b" + + "\u0000\u0003\u0000\u0168\b\u0000\u0001\u0001\u0003\u0001\u016b\b\u0001" + + "\u0001\u0001\u0001\u0001\u0004\u0001\u016f\b\u0001\u000b\u0001\f\u0001" + + "\u0170\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u0177" + + "\b\u0002\u0001\u0002\u0003\u0002\u017a\b\u0002\u0001\u0002\u0001\u0002" + + "\u0001\u0002\u0003\u0002\u017f\b\u0002\u0003\u0002\u0181\b\u0002\u0001" + + "\u0003\u0003\u0003\u0184\b\u0003\u0001\u0003\u0001\u0003\u0005\u0003\u0188" + + "\b\u0003\n\u0003\f\u0003\u018b\t\u0003\u0001\u0003\u0001\u0003\u0003\u0003" + + "\u018f\b\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u0193\b\u0003\u0001" + + "\u0004\u0001\u0004\u0003\u0004\u0197\b\u0004\u0001\u0005\u0001\u0005\u0001" + + "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u019f\b\u0006\u0001" + + "\u0007\u0001\u0007\u0005\u0007\u01a3\b\u0007\n\u0007\f\u0007\u01a6\t\u0007" + + "\u0001\u0007\u0001\u0007\u0003\u0007\u01aa\b\u0007\u0001\u0007\u0004\u0007" + + "\u01ad\b\u0007\u000b\u0007\f\u0007\u01ae\u0001\u0007\u0004\u0007\u01b2" + + "\b\u0007\u000b\u0007\f\u0007\u01b3\u0001\u0007\u0001\u0007\u0001\b\u0001" + + "\b\u0005\b\u01ba\b\b\n\b\f\b\u01bd\t\b\u0001\b\u0001\b\u0001\t\u0001\t" + + "\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001" + + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001" + + "\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\r\u0001" + + "\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e" + + "\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f" + + "\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010" + + "\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011" + + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012" + + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013" + + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013" + + "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014" + + "\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015" + + "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016" + + "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017" + + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017" + + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018" + + "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018" + + "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019" + + "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a" + + "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b" + + "\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b" + + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d" + + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e" + + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e" + + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001f" + + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 " + + "\u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001" + + "!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001&\u0001" + + "&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001" + + "(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0001" + + ")\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001" + + "+\u0001,\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001" + + ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u0001" + + "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u0001" + + "0\u00010\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u0001" + + "1\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00013\u0001" + + "3\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00014\u00014\u0001" + + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00015\u00015\u00015\u0001" + + "5\u00015\u00015\u00015\u00015\u00016\u00016\u00016\u00016\u00016\u0001" + + "6\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u0001" + + "7\u00017\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001" + + "8\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001" + + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001:\u0001:\u0001" + + ":\u0001:\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001" + + ";\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001" + + "=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001" + + ">\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001" + + "?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001" + + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001" + + "A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001" + + "B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001" + + "C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001E\u0001" + + "E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001F\u0001" + + "F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001G\u0001" + + "H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001" + + "I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001K\u0001" + + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001" + + "L\u0001L\u0001L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001" + + "M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001" + + "O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001" + + "P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001" + + "Q\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001" + + "S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001U\u0001U\u0001V\u0001" + + "V\u0001W\u0001W\u0001X\u0001X\u0001Y\u0001Y\u0001Z\u0001Z\u0001[\u0001" + + "[\u0001\\\u0001\\\u0001]\u0001]\u0001^\u0001^\u0001_\u0001_\u0001`\u0001" + + "`\u0001a\u0001a\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0003c\u0409" + + "\bc\u0001d\u0001d\u0001e\u0001e\u0001f\u0001f\u0001g\u0001g\u0001g\u0001" + + "h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001k\u0001" + + "k\u0001k\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001n\u0001n\u0001" + + "n\u0001o\u0001o\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001q\u0001" + + "q\u0001q\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001t\u0001t\u0001" + + "t\u0001u\u0001u\u0001u\u0001u\u0001u\u0003u\u0442\bu\u0001v\u0001v\u0001" + + "v\u0001v\u0003v\u0448\bv\u0001w\u0001w\u0001w\u0001x\u0001x\u0001x\u0001" + + "y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001|\u0001" + + "|\u0001}\u0001}\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u0080" + + "\u0001\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082" + + "\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083" + + "\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084" + + "\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084" + + "\u047a\b\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0005\u0085\u047f\b" + + "\u0085\n\u0085\f\u0085\u0482\t\u0085\u0001\u0086\u0001\u0086\u0003\u0086" + + "\u0486\b\u0086\u0001\u0087\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0089" + + "\u0001\u0089\u0003\u0089\u048e\b\u0089\u0001\u0089\u0005\u0089\u0491\b" + + "\u0089\n\u0089\f\u0089\u0494\t\u0089\u0001\u008a\u0001\u008a\u0003\u008a" + + "\u0498\b\u008a\u0001\u008a\u0005\u008a\u049b\b\u008a\n\u008a\f\u008a\u049e" + + "\t\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u04a4" + + "\b\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u04a8\b\u008b\u0001\u008b" + + "\u0005\u008b\u04ab\b\u008b\n\u008b\f\u008b\u04ae\t\u008b\u0001\u008c\u0001" + + "\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u04b4\b\u008c\u0001\u008c\u0001" + + "\u008c\u0003\u008c\u04b8\b\u008c\u0001\u008c\u0005\u008c\u04bb\b\u008c" + + "\n\u008c\f\u008c\u04be\t\u008c\u0001\u008d\u0001\u008d\u0001\u008e\u0001" + + "\u008e\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0001\u0091\u0001" + + "\u0091\u0003\u0091\u04ca\b\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u04ce" + + "\b\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u04d2\b\u0091\u0001\u0091" + + "\u0001\u0091\u0003\u0091\u04d6\b\u0091\u0003\u0091\u04d8\b\u0091\u0001" + + "\u0092\u0001\u0092\u0001\u0093\u0001\u0093\u0001\u0094\u0001\u0094\u0001" + + "\u0094\u0001\u0094\u0003\u0094\u04e2\b\u0094\u0001\u0095\u0001\u0095\u0001" + + "\u0095\u0003\u0095\u04e7\b\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0003" + + "\u0096\u04ec\b\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001" + + "\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001" + + "\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001" + + "\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0003\u0097\u0503" + + "\b\u0097\u0001\u0097\u0003\u0097\u0506\b\u0097\u0001\u0097\u0001\u0097" + + "\u0001\u0097\u0001\u0097\u0003\u0097\u050c\b\u0097\u0001\u0098\u0001\u0098" + + "\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098" + + "\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0519\b\u0098\u0001\u0099" + + "\u0001\u0099\u0001\u0099\u0001\u0099\u0004\u0099\u051f\b\u0099\u000b\u0099" + + "\f\u0099\u0520\u0001\u009a\u0003\u009a\u0524\b\u009a\u0001\u009a\u0001" + + "\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u052b\b\u009a\u0001" + + "\u009b\u0001\u009b\u0003\u009b\u052f\b\u009b\u0001\u009b\u0001\u009b\u0001" + + "\u009b\u0003\u009b\u0534\b\u009b\u0001\u009b\u0003\u009b\u0537\b\u009b" + + "\u0001\u009c\u0001\u009c\u0001\u009d\u0001\u009d\u0003\u009d\u053d\b\u009d" + + "\u0001\u009d\u0005\u009d\u0540\b\u009d\n\u009d\f\u009d\u0543\t\u009d\u0001" + + "\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u054a" + + "\b\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0\u054f\b\u00a0" + + "\u0001\u00a1\u0001\u00a1\u0005\u00a1\u0553\b\u00a1\n\u00a1\f\u00a1\u0556" + + "\t\u00a1\u0001\u00a1\u0001\u00a1\u0005\u00a1\u055a\b\u00a1\n\u00a1\f\u00a1" + + "\u055d\t\u00a1\u0001\u00a1\u0001\u00a1\u0005\u00a1\u0561\b\u00a1\n\u00a1" + + "\f\u00a1\u0564\t\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2" + + "\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2" + + "\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2\u0574\b\u00a2" + + "\u0001\u00a3\u0001\u00a3\u0003\u00a3\u0578\b\u00a3\u0001\u00a3\u0001\u00a3" + + "\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0003\u00a3\u0580\b\u00a3" + + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5" + + "\u0001\u00a6\u0001\u00a6\u0001\u00a7\u0004\u00a7\u058b\b\u00a7\u000b\u00a7" + + "\f\u00a7\u058c\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0001\u00a8\u0003\u00a8" + + "\u0593\b\u00a8\u0001\u00a8\u0003\u00a8\u0596\b\u00a8\u0001\u00a8\u0001" + + "\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0005\u00a9\u059e" + + "\b\u00a9\n\u00a9\f\u00a9\u05a1\t\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9" + + "\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa" + + "\u0005\u00aa\u05ac\b\u00aa\n\u00aa\f\u00aa\u05af\t\u00aa\u0001\u00aa\u0001" + + "\u00aa\u0002\u01a4\u059f\u0000\u00ab\u0001\u0001\u0003\u0002\u0005\u0003" + + "\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015" + + "\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012" + + "%\u0013\'\u0014)\u0015+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c" + + "9\u001d;\u001e=\u001f? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_0a1c2e3g4i5k6" + + "m7o8q9s:u;w}?\u007f@\u0081A\u0083B\u0085C\u0087D\u0089E\u008bF\u008d" + + "G\u008fH\u0091I\u0093J\u0095K\u0097L\u0099M\u009bN\u009dO\u009fP\u00a1" + + "Q\u00a3R\u00a5S\u00a7T\u00a9U\u00abV\u00adW\u00afX\u00b1Y\u00b3Z\u00b5" + + "[\u00b7\\\u00b9]\u00bb^\u00bd_\u00bf`\u00c1a\u00c3b\u00c5c\u00c7d\u00c9" + + "e\u00cbf\u00cdg\u00cfh\u00d1i\u00d3j\u00d5k\u00d7l\u00d9m\u00dbn\u00dd" + + "o\u00dfp\u00e1q\u00e3r\u00e5s\u00e7t\u00e9u\u00ebv\u00edw\u00efx\u00f1" + + "y\u00f3z\u00f5{\u00f7|\u00f9}\u00fb~\u00fd\u007f\u00ff\u0080\u0101\u0081" + + "\u0103\u0082\u0105\u0083\u0107\u0000\u0109\u0000\u010b\u0084\u010d\u0000" + + "\u010f\u0000\u0111\u0000\u0113\u0085\u0115\u0086\u0117\u0087\u0119\u0088" + + "\u011b\u0000\u011d\u0000\u011f\u0000\u0121\u0000\u0123\u0089\u0125\u0000" + + "\u0127\u0000\u0129\u0000\u012b\u0000\u012d\u0000\u012f\u0000\u0131\u0000" + + "\u0133\u0000\u0135\u0000\u0137\u0000\u0139\u0000\u013b\u0000\u013d\u0000" + + "\u013f\u0000\u0141\u0000\u0143\u0000\u0145\u008a\u0147\u008b\u0149\u008c" + + "\u014b\u008d\u014d\u0000\u014f\u008e\u0151\u008f\u0153\u0090\u0155\u0091" + + "\u0001\u0000\u0013\u0003\u0000LLUUuu\u0001\u0000\n\n\u0003\u0000AZ__a" + + "z\u0001\u000009\u0001\u000019\u0001\u000007\u0003\u000009AFaf\u0001\u0000" + + "01\u0002\u0000UUuu\u0002\u0000LLll\u0004\u0000\n\n\r\r\'\'\\\\\u0002\u0000" + + "++--\u0004\u0000FFLLffll\u0004\u0000\n\n\r\r\"\"\\\\\u0003\u0000\n\n\r" + + "\r((\u0003\u0000\n\n\r\r))\u0003\u0000\n\n\r\r\"\"\u0002\u0000\t\t \u0002" + + "\u0000\n\n\r\r\u05f5\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003\u0001" + + "\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007\u0001" + + "\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000" + + "\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000" + + "\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000" + + "\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000" + + "\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000" + + "\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000" + + "\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000" + + "%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001" + + "\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000" + + "\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u0000" + + "3\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001" + + "\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000" + + "\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000" + + "A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001" + + "\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000" + + "\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000" + + "O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001" + + "\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000" + + "\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000" + + "]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001" + + "\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000" + + "\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000" + + "k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001" + + "\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000" + + "\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000" + + "y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001" + + "\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001" + + "\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001" + + "\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001" + + "\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001" + + "\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001" + + "\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001" + + "\u0000\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001" + + "\u0000\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001" + + "\u0000\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001" + + "\u0000\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001" + + "\u0000\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001" + + "\u0000\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001" + + "\u0000\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001" + + "\u0000\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001" + + "\u0000\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001" + + "\u0000\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001" + + "\u0000\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001" + + "\u0000\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000\u00c5\u0001" + + "\u0000\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000\u00c9\u0001" + + "\u0000\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000\u00cd\u0001" + + "\u0000\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000\u00d1\u0001" + + "\u0000\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000\u00d5\u0001" + + "\u0000\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000\u00d9\u0001" + + "\u0000\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000\u00dd\u0001" + + "\u0000\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0000\u00e1\u0001" + + "\u0000\u0000\u0000\u0000\u00e3\u0001\u0000\u0000\u0000\u0000\u00e5\u0001" + + "\u0000\u0000\u0000\u0000\u00e7\u0001\u0000\u0000\u0000\u0000\u00e9\u0001" + + "\u0000\u0000\u0000\u0000\u00eb\u0001\u0000\u0000\u0000\u0000\u00ed\u0001" + + "\u0000\u0000\u0000\u0000\u00ef\u0001\u0000\u0000\u0000\u0000\u00f1\u0001" + + "\u0000\u0000\u0000\u0000\u00f3\u0001\u0000\u0000\u0000\u0000\u00f5\u0001" + + "\u0000\u0000\u0000\u0000\u00f7\u0001\u0000\u0000\u0000\u0000\u00f9\u0001" + + "\u0000\u0000\u0000\u0000\u00fb\u0001\u0000\u0000\u0000\u0000\u00fd\u0001" + + "\u0000\u0000\u0000\u0000\u00ff\u0001\u0000\u0000\u0000\u0000\u0101\u0001" + + "\u0000\u0000\u0000\u0000\u0103\u0001\u0000\u0000\u0000\u0000\u0105\u0001" + + "\u0000\u0000\u0000\u0000\u010b\u0001\u0000\u0000\u0000\u0000\u0113\u0001" + + "\u0000\u0000\u0000\u0000\u0115\u0001\u0000\u0000\u0000\u0000\u0117\u0001" + + "\u0000\u0000\u0000\u0000\u0119\u0001\u0000\u0000\u0000\u0000\u0123\u0001" + + "\u0000\u0000\u0000\u0000\u0145\u0001\u0000\u0000\u0000\u0000\u0147\u0001" + + "\u0000\u0000\u0000\u0000\u0149\u0001\u0000\u0000\u0000\u0000\u014b\u0001" + + "\u0000\u0000\u0000\u0000\u014f\u0001\u0000\u0000\u0000\u0000\u0151\u0001" + + "\u0000\u0000\u0000\u0000\u0153\u0001\u0000\u0000\u0000\u0000\u0155\u0001" + + "\u0000\u0000\u0000\u0001\u0167\u0001\u0000\u0000\u0000\u0003\u016a\u0001" + + "\u0000\u0000\u0000\u0005\u0180\u0001\u0000\u0000\u0000\u0007\u0192\u0001" + + "\u0000\u0000\u0000\t\u0196\u0001\u0000\u0000\u0000\u000b\u0198\u0001\u0000" + + "\u0000\u0000\r\u019e\u0001\u0000\u0000\u0000\u000f\u01a0\u0001\u0000\u0000" + + "\u0000\u0011\u01b7\u0001\u0000\u0000\u0000\u0013\u01c0\u0001\u0000\u0000" + + "\u0000\u0015\u01c8\u0001\u0000\u0000\u0000\u0017\u01d0\u0001\u0000\u0000" + + "\u0000\u0019\u01d4\u0001\u0000\u0000\u0000\u001b\u01d9\u0001\u0000\u0000" + + "\u0000\u001d\u01de\u0001\u0000\u0000\u0000\u001f\u01e4\u0001\u0000\u0000" + + "\u0000!\u01e9\u0001\u0000\u0000\u0000#\u01ef\u0001\u0000\u0000\u0000%" + + "\u01f4\u0001\u0000\u0000\u0000\'\u01fd\u0001\u0000\u0000\u0000)\u0206" + + "\u0001\u0000\u0000\u0000+\u020c\u0001\u0000\u0000\u0000-\u0212\u0001\u0000" + + "\u0000\u0000/\u021c\u0001\u0000\u0000\u00001\u0227\u0001\u0000\u0000\u0000" + + "3\u0230\u0001\u0000\u0000\u00005\u0239\u0001\u0000\u0000\u00007\u0241" + + "\u0001\u0000\u0000\u00009\u0248\u0001\u0000\u0000\u0000;\u024b\u0001\u0000" + + "\u0000\u0000=\u0252\u0001\u0000\u0000\u0000?\u025f\u0001\u0000\u0000\u0000" + + "A\u0264\u0001\u0000\u0000\u0000C\u0269\u0001\u0000\u0000\u0000E\u0272" + + "\u0001\u0000\u0000\u0000G\u0279\u0001\u0000\u0000\u0000I\u0280\u0001\u0000" + + "\u0000\u0000K\u0286\u0001\u0000\u0000\u0000M\u028c\u0001\u0000\u0000\u0000" + + "O\u0292\u0001\u0000\u0000\u0000Q\u0296\u0001\u0000\u0000\u0000S\u029d" + + "\u0001\u0000\u0000\u0000U\u02a2\u0001\u0000\u0000\u0000W\u02a5\u0001\u0000" + + "\u0000\u0000Y\u02ac\u0001\u0000\u0000\u0000[\u02b0\u0001\u0000\u0000\u0000" + + "]\u02b5\u0001\u0000\u0000\u0000_\u02bd\u0001\u0000\u0000\u0000a\u02c7" + + "\u0001\u0000\u0000\u0000c\u02cb\u0001\u0000\u0000\u0000e\u02d4\u0001\u0000" + + "\u0000\u0000g\u02dc\u0001\u0000\u0000\u0000i\u02e5\u0001\u0000\u0000\u0000" + + "k\u02ee\u0001\u0000\u0000\u0000m\u02f6\u0001\u0000\u0000\u0000o\u0300" + + "\u0001\u0000\u0000\u0000q\u0307\u0001\u0000\u0000\u0000s\u0310\u0001\u0000" + + "\u0000\u0000u\u0321\u0001\u0000\u0000\u0000w\u0328\u0001\u0000\u0000\u0000" + + "y\u032e\u0001\u0000\u0000\u0000{\u0335\u0001\u0000\u0000\u0000}\u033c" + + "\u0001\u0000\u0000\u0000\u007f\u0343\u0001\u0000\u0000\u0000\u0081\u0351" + + "\u0001\u0000\u0000\u0000\u0083\u035d\u0001\u0000\u0000\u0000\u0085\u0364" + + "\u0001\u0000\u0000\u0000\u0087\u036b\u0001\u0000\u0000\u0000\u0089\u0374" + + "\u0001\u0000\u0000\u0000\u008b\u0379\u0001\u0000\u0000\u0000\u008d\u0386" + + "\u0001\u0000\u0000\u0000\u008f\u038c\u0001\u0000\u0000\u0000\u0091\u0391" + + "\u0001\u0000\u0000\u0000\u0093\u0395\u0001\u0000\u0000\u0000\u0095\u039d" + + "\u0001\u0000\u0000\u0000\u0097\u03a4\u0001\u0000\u0000\u0000\u0099\u03ad" + + "\u0001\u0000\u0000\u0000\u009b\u03b3\u0001\u0000\u0000\u0000\u009d\u03bc" + + "\u0001\u0000\u0000\u0000\u009f\u03c2\u0001\u0000\u0000\u0000\u00a1\u03ca" + + "\u0001\u0000\u0000\u0000\u00a3\u03cf\u0001\u0000\u0000\u0000\u00a5\u03d8" + + "\u0001\u0000\u0000\u0000\u00a7\u03e0\u0001\u0000\u0000\u0000\u00a9\u03e6" + + "\u0001\u0000\u0000\u0000\u00ab\u03e8\u0001\u0000\u0000\u0000\u00ad\u03ea" + + "\u0001\u0000\u0000\u0000\u00af\u03ec\u0001\u0000\u0000\u0000\u00b1\u03ee" + + "\u0001\u0000\u0000\u0000\u00b3\u03f0\u0001\u0000\u0000\u0000\u00b5\u03f2" + + "\u0001\u0000\u0000\u0000\u00b7\u03f4\u0001\u0000\u0000\u0000\u00b9\u03f6" + + "\u0001\u0000\u0000\u0000\u00bb\u03f8\u0001\u0000\u0000\u0000\u00bd\u03fa" + + "\u0001\u0000\u0000\u0000\u00bf\u03fc\u0001\u0000\u0000\u0000\u00c1\u03fe" + + "\u0001\u0000\u0000\u0000\u00c3\u0400\u0001\u0000\u0000\u0000\u00c5\u0402" + + "\u0001\u0000\u0000\u0000\u00c7\u0408\u0001\u0000\u0000\u0000\u00c9\u040a" + + "\u0001\u0000\u0000\u0000\u00cb\u040c\u0001\u0000\u0000\u0000\u00cd\u040e" + + "\u0001\u0000\u0000\u0000\u00cf\u0410\u0001\u0000\u0000\u0000\u00d1\u0413" + + "\u0001\u0000\u0000\u0000\u00d3\u0416\u0001\u0000\u0000\u0000\u00d5\u0419" + + "\u0001\u0000\u0000\u0000\u00d7\u041c\u0001\u0000\u0000\u0000\u00d9\u041f" + + "\u0001\u0000\u0000\u0000\u00db\u0422\u0001\u0000\u0000\u0000\u00dd\u0425" + + "\u0001\u0000\u0000\u0000\u00df\u0428\u0001\u0000\u0000\u0000\u00e1\u042c" + + "\u0001\u0000\u0000\u0000\u00e3\u0430\u0001\u0000\u0000\u0000\u00e5\u0433" + + "\u0001\u0000\u0000\u0000\u00e7\u0436\u0001\u0000\u0000\u0000\u00e9\u0439" + + "\u0001\u0000\u0000\u0000\u00eb\u0441\u0001\u0000\u0000\u0000\u00ed\u0447" + + "\u0001\u0000\u0000\u0000\u00ef\u0449\u0001\u0000\u0000\u0000\u00f1\u044c" + + "\u0001\u0000\u0000\u0000\u00f3\u044f\u0001\u0000\u0000\u0000\u00f5\u0451" + + "\u0001\u0000\u0000\u0000\u00f7\u0455\u0001\u0000\u0000\u0000\u00f9\u0458" + + "\u0001\u0000\u0000\u0000\u00fb\u045a\u0001\u0000\u0000\u0000\u00fd\u045c" + + "\u0001\u0000\u0000\u0000\u00ff\u045f\u0001\u0000\u0000\u0000\u0101\u0461" + + "\u0001\u0000\u0000\u0000\u0103\u0463\u0001\u0000\u0000\u0000\u0105\u0466" + + "\u0001\u0000\u0000\u0000\u0107\u046a\u0001\u0000\u0000\u0000\u0109\u0479" + + "\u0001\u0000\u0000\u0000\u010b\u047b\u0001\u0000\u0000\u0000\u010d\u0485" + + "\u0001\u0000\u0000\u0000\u010f\u0487\u0001\u0000\u0000\u0000\u0111\u0489" + + "\u0001\u0000\u0000\u0000\u0113\u048b\u0001\u0000\u0000\u0000\u0115\u0495" + + "\u0001\u0000\u0000\u0000\u0117\u04a3\u0001\u0000\u0000\u0000\u0119\u04b3" + + "\u0001\u0000\u0000\u0000\u011b\u04bf\u0001\u0000\u0000\u0000\u011d\u04c1" + + "\u0001\u0000\u0000\u0000\u011f\u04c3\u0001\u0000\u0000\u0000\u0121\u04c5" + + "\u0001\u0000\u0000\u0000\u0123\u04d7\u0001\u0000\u0000\u0000\u0125\u04d9" + + "\u0001\u0000\u0000\u0000\u0127\u04db\u0001\u0000\u0000\u0000\u0129\u04e1" + + "\u0001\u0000\u0000\u0000\u012b\u04e6\u0001\u0000\u0000\u0000\u012d\u04eb" + + "\u0001\u0000\u0000\u0000\u012f\u050b\u0001\u0000\u0000\u0000\u0131\u0518" + + "\u0001\u0000\u0000\u0000\u0133\u051a\u0001\u0000\u0000\u0000\u0135\u052a" + + "\u0001\u0000\u0000\u0000\u0137\u0536\u0001\u0000\u0000\u0000\u0139\u0538" + + "\u0001\u0000\u0000\u0000\u013b\u053a\u0001\u0000\u0000\u0000\u013d\u0544" + + "\u0001\u0000\u0000\u0000\u013f\u0549\u0001\u0000\u0000\u0000\u0141\u054e" + + "\u0001\u0000\u0000\u0000\u0143\u0550\u0001\u0000\u0000\u0000\u0145\u0573" + + "\u0001\u0000\u0000\u0000\u0147\u057f\u0001\u0000\u0000\u0000\u0149\u0581" + + "\u0001\u0000\u0000\u0000\u014b\u0584\u0001\u0000\u0000\u0000\u014d\u0587" + + "\u0001\u0000\u0000\u0000\u014f\u058a\u0001\u0000\u0000\u0000\u0151\u0595" + + "\u0001\u0000\u0000\u0000\u0153\u0599\u0001\u0000\u0000\u0000\u0155\u05a7" + + "\u0001\u0000\u0000\u0000\u0157\u0159\u0003\u0113\u0089\u0000\u0158\u015a" + + "\u0003\u0123\u0091\u0000\u0159\u0158\u0001\u0000\u0000\u0000\u0159\u015a" + + "\u0001\u0000\u0000\u0000\u015a\u0168\u0001\u0000\u0000\u0000\u015b\u015d" + + "\u0003\u0115\u008a\u0000\u015c\u015e\u0003\u0123\u0091\u0000\u015d\u015c" + + "\u0001\u0000\u0000\u0000\u015d\u015e\u0001\u0000\u0000\u0000\u015e\u0168" + + "\u0001\u0000\u0000\u0000\u015f\u0161\u0003\u0117\u008b\u0000\u0160\u0162" + + "\u0003\u0123\u0091\u0000\u0161\u0160\u0001\u0000\u0000\u0000\u0161\u0162" + + "\u0001\u0000\u0000\u0000\u0162\u0168\u0001\u0000\u0000\u0000\u0163\u0165" + + "\u0003\u0119\u008c\u0000\u0164\u0166\u0003\u0123\u0091\u0000\u0165\u0164" + + "\u0001\u0000\u0000\u0000\u0165\u0166\u0001\u0000\u0000\u0000\u0166\u0168" + + "\u0001\u0000\u0000\u0000\u0167\u0157\u0001\u0000\u0000\u0000\u0167\u015b" + + "\u0001\u0000\u0000\u0000\u0167\u015f\u0001\u0000\u0000\u0000\u0167\u0163" + + "\u0001\u0000\u0000\u0000\u0168\u0002\u0001\u0000\u0000\u0000\u0169\u016b" + + "\u0007\u0000\u0000\u0000\u016a\u0169\u0001\u0000\u0000\u0000\u016a\u016b" + + "\u0001\u0000\u0000\u0000\u016b\u016c\u0001\u0000\u0000\u0000\u016c\u016e" + + "\u0005\'\u0000\u0000\u016d\u016f\u0003\u012b\u0095\u0000\u016e\u016d\u0001" + + "\u0000\u0000\u0000\u016f\u0170\u0001\u0000\u0000\u0000\u0170\u016e\u0001" + + "\u0000\u0000\u0000\u0170\u0171\u0001\u0000\u0000\u0000\u0171\u0172\u0001" + + "\u0000\u0000\u0000\u0172\u0173\u0005\'\u0000\u0000\u0173\u0004\u0001\u0000" + + "\u0000\u0000\u0174\u0176\u0003\u0135\u009a\u0000\u0175\u0177\u0003\u0137" + + "\u009b\u0000\u0176\u0175\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000" + + "\u0000\u0000\u0177\u0179\u0001\u0000\u0000\u0000\u0178\u017a\u0003\u013d" + + "\u009e\u0000\u0179\u0178\u0001\u0000\u0000\u0000\u0179\u017a\u0001\u0000" + + "\u0000\u0000\u017a\u0181\u0001\u0000\u0000\u0000\u017b\u017c\u0003\u013b" + + "\u009d\u0000\u017c\u017e\u0003\u0137\u009b\u0000\u017d\u017f\u0003\u013d" + + "\u009e\u0000\u017e\u017d\u0001\u0000\u0000\u0000\u017e\u017f\u0001\u0000" + + "\u0000\u0000\u017f\u0181\u0001\u0000\u0000\u0000\u0180\u0174\u0001\u0000" + + "\u0000\u0000\u0180\u017b\u0001\u0000\u0000\u0000\u0181\u0006\u0001\u0000" + + "\u0000\u0000\u0182\u0184\u0003\u013f\u009f\u0000\u0183\u0182\u0001\u0000" + + "\u0000\u0000\u0183\u0184\u0001\u0000\u0000\u0000\u0184\u0185\u0001\u0000" + + "\u0000\u0000\u0185\u0189\u0005\"\u0000\u0000\u0186\u0188\u0003\u0141\u00a0" + + "\u0000\u0187\u0186\u0001\u0000\u0000\u0000\u0188\u018b\u0001\u0000\u0000" + + "\u0000\u0189\u0187\u0001\u0000\u0000\u0000\u0189\u018a\u0001\u0000\u0000" + + "\u0000\u018a\u018c\u0001\u0000\u0000\u0000\u018b\u0189\u0001\u0000\u0000" + + "\u0000\u018c\u0193\u0005\"\u0000\u0000\u018d\u018f\u0003\u013f\u009f\u0000" + + "\u018e\u018d\u0001\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000\u0000" + + "\u018f\u0190\u0001\u0000\u0000\u0000\u0190\u0191\u0005R\u0000\u0000\u0191" + + "\u0193\u0003\u0143\u00a1\u0000\u0192\u0183\u0001\u0000\u0000\u0000\u0192" + + "\u018e\u0001\u0000\u0000\u0000\u0193\b\u0001\u0000\u0000\u0000\u0194\u0197" + + "\u0003I$\u0000\u0195\u0197\u0003\u008fG\u0000\u0196\u0194\u0001\u0000" + + "\u0000\u0000\u0196\u0195\u0001\u0000\u0000\u0000\u0197\n\u0001\u0000\u0000" + + "\u0000\u0198\u0199\u0003e2\u0000\u0199\f\u0001\u0000\u0000\u0000\u019a" + + "\u019f\u0003\u0145\u00a2\u0000\u019b\u019f\u0003\u0147\u00a3\u0000\u019c" + + "\u019f\u0003\u0149\u00a4\u0000\u019d\u019f\u0003\u014b\u00a5\u0000\u019e" + + "\u019a\u0001\u0000\u0000\u0000\u019e\u019b\u0001\u0000\u0000\u0000\u019e" + + "\u019c\u0001\u0000\u0000\u0000\u019e\u019d\u0001\u0000\u0000\u0000\u019f" + + "\u000e\u0001\u0000\u0000\u0000\u01a0\u01ac\u0005#\u0000\u0000\u01a1\u01a3" + + "\b\u0001\u0000\u0000\u01a2\u01a1\u0001\u0000\u0000\u0000\u01a3\u01a6\u0001" + + "\u0000\u0000\u0000\u01a4\u01a5\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001" + + "\u0000\u0000\u0000\u01a5\u01a7\u0001\u0000\u0000\u0000\u01a6\u01a4\u0001" + + "\u0000\u0000\u0000\u01a7\u01a9\u0005\\\u0000\u0000\u01a8\u01aa\u0005\r" + + "\u0000\u0000\u01a9\u01a8\u0001\u0000\u0000\u0000\u01a9\u01aa\u0001\u0000" + + "\u0000\u0000\u01aa\u01ab\u0001\u0000\u0000\u0000\u01ab\u01ad\u0005\n\u0000" + + "\u0000\u01ac\u01a4\u0001\u0000\u0000\u0000\u01ad\u01ae\u0001\u0000\u0000" + + "\u0000\u01ae\u01ac\u0001\u0000\u0000\u0000\u01ae\u01af\u0001\u0000\u0000" + + "\u0000\u01af\u01b1\u0001\u0000\u0000\u0000\u01b0\u01b2\b\u0001\u0000\u0000" + + "\u01b1\u01b0\u0001\u0000\u0000\u0000\u01b2\u01b3\u0001\u0000\u0000\u0000" + + "\u01b3\u01b1\u0001\u0000\u0000\u0000\u01b3\u01b4\u0001\u0000\u0000\u0000" + + "\u01b4\u01b5\u0001\u0000\u0000\u0000\u01b5\u01b6\u0006\u0007\u0000\u0000" + + "\u01b6\u0010\u0001\u0000\u0000\u0000\u01b7\u01bb\u0005#\u0000\u0000\u01b8" + + "\u01ba\b\u0001\u0000\u0000\u01b9\u01b8\u0001\u0000\u0000\u0000\u01ba\u01bd" + + "\u0001\u0000\u0000\u0000\u01bb\u01b9\u0001\u0000\u0000\u0000\u01bb\u01bc" + + "\u0001\u0000\u0000\u0000\u01bc\u01be\u0001\u0000\u0000\u0000\u01bd\u01bb" + + "\u0001\u0000\u0000\u0000\u01be\u01bf\u0006\b\u0000\u0000\u01bf\u0012\u0001" + + "\u0000\u0000\u0000\u01c0\u01c1\u0005a\u0000\u0000\u01c1\u01c2\u0005l\u0000" + + "\u0000\u01c2\u01c3\u0005i\u0000\u0000\u01c3\u01c4\u0005g\u0000\u0000\u01c4" + + "\u01c5\u0005n\u0000\u0000\u01c5\u01c6\u0005a\u0000\u0000\u01c6\u01c7\u0005" + + "s\u0000\u0000\u01c7\u0014\u0001\u0000\u0000\u0000\u01c8\u01c9\u0005a\u0000" + + "\u0000\u01c9\u01ca\u0005l\u0000\u0000\u01ca\u01cb\u0005i\u0000\u0000\u01cb" + + "\u01cc\u0005g\u0000\u0000\u01cc\u01cd\u0005n\u0000\u0000\u01cd\u01ce\u0005" + + "o\u0000\u0000\u01ce\u01cf\u0005f\u0000\u0000\u01cf\u0016\u0001\u0000\u0000" + + "\u0000\u01d0\u01d1\u0005a\u0000\u0000\u01d1\u01d2\u0005s\u0000\u0000\u01d2" + + "\u01d3\u0005m\u0000\u0000\u01d3\u0018\u0001\u0000\u0000\u0000\u01d4\u01d5" + + "\u0005a\u0000\u0000\u01d5\u01d6\u0005u\u0000\u0000\u01d6\u01d7\u0005t" + + "\u0000\u0000\u01d7\u01d8\u0005o\u0000\u0000\u01d8\u001a\u0001\u0000\u0000" + + "\u0000\u01d9\u01da\u0005b\u0000\u0000\u01da\u01db\u0005o\u0000\u0000\u01db" + + "\u01dc\u0005o\u0000\u0000\u01dc\u01dd\u0005l\u0000\u0000\u01dd\u001c\u0001" + + "\u0000\u0000\u0000\u01de\u01df\u0005b\u0000\u0000\u01df\u01e0\u0005r\u0000" + + "\u0000\u01e0\u01e1\u0005e\u0000\u0000\u01e1\u01e2\u0005a\u0000\u0000\u01e2" + + "\u01e3\u0005k\u0000\u0000\u01e3\u001e\u0001\u0000\u0000\u0000\u01e4\u01e5" + + "\u0005c\u0000\u0000\u01e5\u01e6\u0005a\u0000\u0000\u01e6\u01e7\u0005s" + + "\u0000\u0000\u01e7\u01e8\u0005e\u0000\u0000\u01e8 \u0001\u0000\u0000\u0000" + + "\u01e9\u01ea\u0005c\u0000\u0000\u01ea\u01eb\u0005a\u0000\u0000\u01eb\u01ec" + + "\u0005t\u0000\u0000\u01ec\u01ed\u0005c\u0000\u0000\u01ed\u01ee\u0005h" + + "\u0000\u0000\u01ee\"\u0001\u0000\u0000\u0000\u01ef\u01f0\u0005c\u0000" + + "\u0000\u01f0\u01f1\u0005h\u0000\u0000\u01f1\u01f2\u0005a\u0000\u0000\u01f2" + + "\u01f3\u0005r\u0000\u0000\u01f3$\u0001\u0000\u0000\u0000\u01f4\u01f5\u0005" + + "c\u0000\u0000\u01f5\u01f6\u0005h\u0000\u0000\u01f6\u01f7\u0005a\u0000" + + "\u0000\u01f7\u01f8\u0005r\u0000\u0000\u01f8\u01f9\u00051\u0000\u0000\u01f9" + + "\u01fa\u00056\u0000\u0000\u01fa\u01fb\u0005_\u0000\u0000\u01fb\u01fc\u0005" + + "t\u0000\u0000\u01fc&\u0001\u0000\u0000\u0000\u01fd\u01fe\u0005c\u0000" + + "\u0000\u01fe\u01ff\u0005h\u0000\u0000\u01ff\u0200\u0005a\u0000\u0000\u0200" + + "\u0201\u0005r\u0000\u0000\u0201\u0202\u00053\u0000\u0000\u0202\u0203\u0005" + + "2\u0000\u0000\u0203\u0204\u0005_\u0000\u0000\u0204\u0205\u0005t\u0000" + + "\u0000\u0205(\u0001\u0000\u0000\u0000\u0206\u0207\u0005c\u0000\u0000\u0207" + + "\u0208\u0005l\u0000\u0000\u0208\u0209\u0005a\u0000\u0000\u0209\u020a\u0005" + + "s\u0000\u0000\u020a\u020b\u0005s\u0000\u0000\u020b*\u0001\u0000\u0000" + + "\u0000\u020c\u020d\u0005c\u0000\u0000\u020d\u020e\u0005o\u0000\u0000\u020e" + + "\u020f\u0005n\u0000\u0000\u020f\u0210\u0005s\u0000\u0000\u0210\u0211\u0005" + + "t\u0000\u0000\u0211,\u0001\u0000\u0000\u0000\u0212\u0213\u0005c\u0000" + + "\u0000\u0213\u0214\u0005o\u0000\u0000\u0214\u0215\u0005n\u0000\u0000\u0215" + + "\u0216\u0005s\u0000\u0000\u0216\u0217\u0005t\u0000\u0000\u0217\u0218\u0005" + + "e\u0000\u0000\u0218\u0219\u0005x\u0000\u0000\u0219\u021a\u0005p\u0000" + + "\u0000\u021a\u021b\u0005r\u0000\u0000\u021b.\u0001\u0000\u0000\u0000\u021c" + + "\u021d\u0005c\u0000\u0000\u021d\u021e\u0005o\u0000\u0000\u021e\u021f\u0005" + + "n\u0000\u0000\u021f\u0220\u0005s\u0000\u0000\u0220\u0221\u0005t\u0000" + + "\u0000\u0221\u0222\u0005_\u0000\u0000\u0222\u0223\u0005c\u0000\u0000\u0223" + + "\u0224\u0005a\u0000\u0000\u0224\u0225\u0005s\u0000\u0000\u0225\u0226\u0005" + + "t\u0000\u0000\u02260\u0001\u0000\u0000\u0000\u0227\u0228\u0005c\u0000" + + "\u0000\u0228\u0229\u0005o\u0000\u0000\u0229\u022a\u0005n\u0000\u0000\u022a" + + "\u022b\u0005t\u0000\u0000\u022b\u022c\u0005i\u0000\u0000\u022c\u022d\u0005" + + "n\u0000\u0000\u022d\u022e\u0005u\u0000\u0000\u022e\u022f\u0005e\u0000" + + "\u0000\u022f2\u0001\u0000\u0000\u0000\u0230\u0231\u0005d\u0000\u0000\u0231" + + "\u0232\u0005e\u0000\u0000\u0232\u0233\u0005c\u0000\u0000\u0233\u0234\u0005" + + "l\u0000\u0000\u0234\u0235\u0005t\u0000\u0000\u0235\u0236\u0005y\u0000" + + "\u0000\u0236\u0237\u0005p\u0000\u0000\u0237\u0238\u0005e\u0000\u0000\u0238" + + "4\u0001\u0000\u0000\u0000\u0239\u023a\u0005d\u0000\u0000\u023a\u023b\u0005" + + "e\u0000\u0000\u023b\u023c\u0005f\u0000\u0000\u023c\u023d\u0005a\u0000" + + "\u0000\u023d\u023e\u0005u\u0000\u0000\u023e\u023f\u0005l\u0000\u0000\u023f" + + "\u0240\u0005t\u0000\u0000\u02406\u0001\u0000\u0000\u0000\u0241\u0242\u0005" + + "d\u0000\u0000\u0242\u0243\u0005e\u0000\u0000\u0243\u0244\u0005l\u0000" + + "\u0000\u0244\u0245\u0005e\u0000\u0000\u0245\u0246\u0005t\u0000\u0000\u0246" + + "\u0247\u0005e\u0000\u0000\u02478\u0001\u0000\u0000\u0000\u0248\u0249\u0005" + + "d\u0000\u0000\u0249\u024a\u0005o\u0000\u0000\u024a:\u0001\u0000\u0000" + + "\u0000\u024b\u024c\u0005d\u0000\u0000\u024c\u024d\u0005o\u0000\u0000\u024d" + + "\u024e\u0005u\u0000\u0000\u024e\u024f\u0005b\u0000\u0000\u024f\u0250\u0005" + + "l\u0000\u0000\u0250\u0251\u0005e\u0000\u0000\u0251<\u0001\u0000\u0000" + + "\u0000\u0252\u0253\u0005d\u0000\u0000\u0253\u0254\u0005y\u0000\u0000\u0254" + + "\u0255\u0005n\u0000\u0000\u0255\u0256\u0005a\u0000\u0000\u0256\u0257\u0005" + + "m\u0000\u0000\u0257\u0258\u0005i\u0000\u0000\u0258\u0259\u0005c\u0000" + + "\u0000\u0259\u025a\u0005_\u0000\u0000\u025a\u025b\u0005c\u0000\u0000\u025b" + + "\u025c\u0005a\u0000\u0000\u025c\u025d\u0005s\u0000\u0000\u025d\u025e\u0005" + + "t\u0000\u0000\u025e>\u0001\u0000\u0000\u0000\u025f\u0260\u0005e\u0000" + + "\u0000\u0260\u0261\u0005l\u0000\u0000\u0261\u0262\u0005s\u0000\u0000\u0262" + + "\u0263\u0005e\u0000\u0000\u0263@\u0001\u0000\u0000\u0000\u0264\u0265\u0005" + + "e\u0000\u0000\u0265\u0266\u0005n\u0000\u0000\u0266\u0267\u0005u\u0000" + + "\u0000\u0267\u0268\u0005m\u0000\u0000\u0268B\u0001\u0000\u0000\u0000\u0269" + + "\u026a\u0005e\u0000\u0000\u026a\u026b\u0005x\u0000\u0000\u026b\u026c\u0005" + + "p\u0000\u0000\u026c\u026d\u0005l\u0000\u0000\u026d\u026e\u0005i\u0000" + + "\u0000\u026e\u026f\u0005c\u0000\u0000\u026f\u0270\u0005i\u0000\u0000\u0270" + + "\u0271\u0005t\u0000\u0000\u0271D\u0001\u0000\u0000\u0000\u0272\u0273\u0005" + + "e\u0000\u0000\u0273\u0274\u0005x\u0000\u0000\u0274\u0275\u0005p\u0000" + + "\u0000\u0275\u0276\u0005o\u0000\u0000\u0276\u0277\u0005r\u0000\u0000\u0277" + + "\u0278\u0005t\u0000\u0000\u0278F\u0001\u0000\u0000\u0000\u0279\u027a\u0005" + + "e\u0000\u0000\u027a\u027b\u0005x\u0000\u0000\u027b\u027c\u0005t\u0000" + + "\u0000\u027c\u027d\u0005e\u0000\u0000\u027d\u027e\u0005r\u0000\u0000\u027e" + + "\u027f\u0005n\u0000\u0000\u027fH\u0001\u0000\u0000\u0000\u0280\u0281\u0005" + + "f\u0000\u0000\u0281\u0282\u0005a\u0000\u0000\u0282\u0283\u0005l\u0000" + + "\u0000\u0283\u0284\u0005s\u0000\u0000\u0284\u0285\u0005e\u0000\u0000\u0285" + + "J\u0001\u0000\u0000\u0000\u0286\u0287\u0005f\u0000\u0000\u0287\u0288\u0005" + + "i\u0000\u0000\u0288\u0289\u0005n\u0000\u0000\u0289\u028a\u0005a\u0000" + + "\u0000\u028a\u028b\u0005l\u0000\u0000\u028bL\u0001\u0000\u0000\u0000\u028c" + + "\u028d\u0005f\u0000\u0000\u028d\u028e\u0005l\u0000\u0000\u028e\u028f\u0005" + + "o\u0000\u0000\u028f\u0290\u0005a\u0000\u0000\u0290\u0291\u0005t\u0000" + + "\u0000\u0291N\u0001\u0000\u0000\u0000\u0292\u0293\u0005f\u0000\u0000\u0293" + + "\u0294\u0005o\u0000\u0000\u0294\u0295\u0005r\u0000\u0000\u0295P\u0001" + + "\u0000\u0000\u0000\u0296\u0297\u0005f\u0000\u0000\u0297\u0298\u0005r\u0000" + + "\u0000\u0298\u0299\u0005i\u0000\u0000\u0299\u029a\u0005e\u0000\u0000\u029a" + + "\u029b\u0005n\u0000\u0000\u029b\u029c\u0005d\u0000\u0000\u029cR\u0001" + + "\u0000\u0000\u0000\u029d\u029e\u0005g\u0000\u0000\u029e\u029f\u0005o\u0000" + + "\u0000\u029f\u02a0\u0005t\u0000\u0000\u02a0\u02a1\u0005o\u0000\u0000\u02a1" + + "T\u0001\u0000\u0000\u0000\u02a2\u02a3\u0005i\u0000\u0000\u02a3\u02a4\u0005" + + "f\u0000\u0000\u02a4V\u0001\u0000\u0000\u0000\u02a5\u02a6\u0005i\u0000" + + "\u0000\u02a6\u02a7\u0005n\u0000\u0000\u02a7\u02a8\u0005l\u0000\u0000\u02a8" + + "\u02a9\u0005i\u0000\u0000\u02a9\u02aa\u0005n\u0000\u0000\u02aa\u02ab\u0005" + + "e\u0000\u0000\u02abX\u0001\u0000\u0000\u0000\u02ac\u02ad\u0005i\u0000" + + "\u0000\u02ad\u02ae\u0005n\u0000\u0000\u02ae\u02af\u0005t\u0000\u0000\u02af" + + "Z\u0001\u0000\u0000\u0000\u02b0\u02b1\u0005l\u0000\u0000\u02b1\u02b2\u0005" + + "o\u0000\u0000\u02b2\u02b3\u0005n\u0000\u0000\u02b3\u02b4\u0005g\u0000" + + "\u0000\u02b4\\\u0001\u0000\u0000\u0000\u02b5\u02b6\u0005m\u0000\u0000" + + "\u02b6\u02b7\u0005u\u0000\u0000\u02b7\u02b8\u0005t\u0000\u0000\u02b8\u02b9" + + "\u0005a\u0000\u0000\u02b9\u02ba\u0005b\u0000\u0000\u02ba\u02bb\u0005l" + + "\u0000\u0000\u02bb\u02bc\u0005e\u0000\u0000\u02bc^\u0001\u0000\u0000\u0000" + + "\u02bd\u02be\u0005n\u0000\u0000\u02be\u02bf\u0005a\u0000\u0000\u02bf\u02c0" + + "\u0005m\u0000\u0000\u02c0\u02c1\u0005e\u0000\u0000\u02c1\u02c2\u0005s" + + "\u0000\u0000\u02c2\u02c3\u0005p\u0000\u0000\u02c3\u02c4\u0005a\u0000\u0000" + + "\u02c4\u02c5\u0005c\u0000\u0000\u02c5\u02c6\u0005e\u0000\u0000\u02c6`" + + "\u0001\u0000\u0000\u0000\u02c7\u02c8\u0005n\u0000\u0000\u02c8\u02c9\u0005" + + "e\u0000\u0000\u02c9\u02ca\u0005w\u0000\u0000\u02cab\u0001\u0000\u0000" + + "\u0000\u02cb\u02cc\u0005n\u0000\u0000\u02cc\u02cd\u0005o\u0000\u0000\u02cd" + + "\u02ce\u0005e\u0000\u0000\u02ce\u02cf\u0005x\u0000\u0000\u02cf\u02d0\u0005" + + "c\u0000\u0000\u02d0\u02d1\u0005e\u0000\u0000\u02d1\u02d2\u0005p\u0000" + + "\u0000\u02d2\u02d3\u0005t\u0000\u0000\u02d3d\u0001\u0000\u0000\u0000\u02d4" + + "\u02d5\u0005n\u0000\u0000\u02d5\u02d6\u0005u\u0000\u0000\u02d6\u02d7\u0005" + + "l\u0000\u0000\u02d7\u02d8\u0005l\u0000\u0000\u02d8\u02d9\u0005p\u0000" + + "\u0000\u02d9\u02da\u0005t\u0000\u0000\u02da\u02db\u0005r\u0000\u0000\u02db" + + "f\u0001\u0000\u0000\u0000\u02dc\u02dd\u0005o\u0000\u0000\u02dd\u02de\u0005" + + "p\u0000\u0000\u02de\u02df\u0005e\u0000\u0000\u02df\u02e0\u0005r\u0000" + + "\u0000\u02e0\u02e1\u0005a\u0000\u0000\u02e1\u02e2\u0005t\u0000\u0000\u02e2" + + "\u02e3\u0005o\u0000\u0000\u02e3\u02e4\u0005r\u0000\u0000\u02e4h\u0001" + + "\u0000\u0000\u0000\u02e5\u02e6\u0005o\u0000\u0000\u02e6\u02e7\u0005v\u0000" + + "\u0000\u02e7\u02e8\u0005e\u0000\u0000\u02e8\u02e9\u0005r\u0000\u0000\u02e9" + + "\u02ea\u0005r\u0000\u0000\u02ea\u02eb\u0005i\u0000\u0000\u02eb\u02ec\u0005" + + "d\u0000\u0000\u02ec\u02ed\u0005e\u0000\u0000\u02edj\u0001\u0000\u0000" + + "\u0000\u02ee\u02ef\u0005p\u0000\u0000\u02ef\u02f0\u0005r\u0000\u0000\u02f0" + + "\u02f1\u0005i\u0000\u0000\u02f1\u02f2\u0005v\u0000\u0000\u02f2\u02f3\u0005" + + "a\u0000\u0000\u02f3\u02f4\u0005t\u0000\u0000\u02f4\u02f5\u0005e\u0000" + + "\u0000\u02f5l\u0001\u0000\u0000\u0000\u02f6\u02f7\u0005p\u0000\u0000\u02f7" + + "\u02f8\u0005r\u0000\u0000\u02f8\u02f9\u0005o\u0000\u0000\u02f9\u02fa\u0005" + + "t\u0000\u0000\u02fa\u02fb\u0005e\u0000\u0000\u02fb\u02fc\u0005c\u0000" + + "\u0000\u02fc\u02fd\u0005t\u0000\u0000\u02fd\u02fe\u0005e\u0000\u0000\u02fe" + + "\u02ff\u0005d\u0000\u0000\u02ffn\u0001\u0000\u0000\u0000\u0300\u0301\u0005" + + "p\u0000\u0000\u0301\u0302\u0005u\u0000\u0000\u0302\u0303\u0005b\u0000" + + "\u0000\u0303\u0304\u0005l\u0000\u0000\u0304\u0305\u0005i\u0000\u0000\u0305" + + "\u0306\u0005c\u0000\u0000\u0306p\u0001\u0000\u0000\u0000\u0307\u0308\u0005" + + "r\u0000\u0000\u0308\u0309\u0005e\u0000\u0000\u0309\u030a\u0005g\u0000" + + "\u0000\u030a\u030b\u0005i\u0000\u0000\u030b\u030c\u0005s\u0000\u0000\u030c" + + "\u030d\u0005t\u0000\u0000\u030d\u030e\u0005e\u0000\u0000\u030e\u030f\u0005" + + "r\u0000\u0000\u030fr\u0001\u0000\u0000\u0000\u0310\u0311\u0005r\u0000" + + "\u0000\u0311\u0312\u0005e\u0000\u0000\u0312\u0313\u0005i\u0000\u0000\u0313" + + "\u0314\u0005n\u0000\u0000\u0314\u0315\u0005t\u0000\u0000\u0315\u0316\u0005" + + "e\u0000\u0000\u0316\u0317\u0005r\u0000\u0000\u0317\u0318\u0005p\u0000" + + "\u0000\u0318\u0319\u0005r\u0000\u0000\u0319\u031a\u0005e\u0000\u0000\u031a" + + "\u031b\u0005t\u0000\u0000\u031b\u031c\u0005_\u0000\u0000\u031c\u031d\u0005" + + "c\u0000\u0000\u031d\u031e\u0005a\u0000\u0000\u031e\u031f\u0005s\u0000" + + "\u0000\u031f\u0320\u0005t\u0000\u0000\u0320t\u0001\u0000\u0000\u0000\u0321" + + "\u0322\u0005r\u0000\u0000\u0322\u0323\u0005e\u0000\u0000\u0323\u0324\u0005" + + "t\u0000\u0000\u0324\u0325\u0005u\u0000\u0000\u0325\u0326\u0005r\u0000" + + "\u0000\u0326\u0327\u0005n\u0000\u0000\u0327v\u0001\u0000\u0000\u0000\u0328" + + "\u0329\u0005s\u0000\u0000\u0329\u032a\u0005h\u0000\u0000\u032a\u032b\u0005" + + "o\u0000\u0000\u032b\u032c\u0005r\u0000\u0000\u032c\u032d\u0005t\u0000" + + "\u0000\u032dx\u0001\u0000\u0000\u0000\u032e\u032f\u0005s\u0000\u0000\u032f" + + "\u0330\u0005i\u0000\u0000\u0330\u0331\u0005g\u0000\u0000\u0331\u0332\u0005" + + "n\u0000\u0000\u0332\u0333\u0005e\u0000\u0000\u0333\u0334\u0005d\u0000" + + "\u0000\u0334z\u0001\u0000\u0000\u0000\u0335\u0336\u0005s\u0000\u0000\u0336" + + "\u0337\u0005i\u0000\u0000\u0337\u0338\u0005z\u0000\u0000\u0338\u0339\u0005" + + "e\u0000\u0000\u0339\u033a\u0005o\u0000\u0000\u033a\u033b\u0005f\u0000" + + "\u0000\u033b|\u0001\u0000\u0000\u0000\u033c\u033d\u0005s\u0000\u0000\u033d" + + "\u033e\u0005t\u0000\u0000\u033e\u033f\u0005a\u0000\u0000\u033f\u0340\u0005" + + "t\u0000\u0000\u0340\u0341\u0005i\u0000\u0000\u0341\u0342\u0005c\u0000" + + "\u0000\u0342~\u0001\u0000\u0000\u0000\u0343\u0344\u0005s\u0000\u0000\u0344" + + "\u0345\u0005t\u0000\u0000\u0345\u0346\u0005a\u0000\u0000\u0346\u0347\u0005" + + "t\u0000\u0000\u0347\u0348\u0005i\u0000\u0000\u0348\u0349\u0005c\u0000" + + "\u0000\u0349\u034a\u0005_\u0000\u0000\u034a\u034b\u0005a\u0000\u0000\u034b" + + "\u034c\u0005s\u0000\u0000\u034c\u034d\u0005s\u0000\u0000\u034d\u034e\u0005" + + "e\u0000\u0000\u034e\u034f\u0005r\u0000\u0000\u034f\u0350\u0005t\u0000" + + "\u0000\u0350\u0080\u0001\u0000\u0000\u0000\u0351\u0352\u0005s\u0000\u0000" + + "\u0352\u0353\u0005t\u0000\u0000\u0353\u0354\u0005a\u0000\u0000\u0354\u0355" + + "\u0005t\u0000\u0000\u0355\u0356\u0005i\u0000\u0000\u0356\u0357\u0005c" + + "\u0000\u0000\u0357\u0358\u0005_\u0000\u0000\u0358\u0359\u0005c\u0000\u0000" + + "\u0359\u035a\u0005a\u0000\u0000\u035a\u035b\u0005s\u0000\u0000\u035b\u035c" + + "\u0005t\u0000\u0000\u035c\u0082\u0001\u0000\u0000\u0000\u035d\u035e\u0005" + + "s\u0000\u0000\u035e\u035f\u0005t\u0000\u0000\u035f\u0360\u0005r\u0000" + + "\u0000\u0360\u0361\u0005u\u0000\u0000\u0361\u0362\u0005c\u0000\u0000\u0362" + + "\u0363\u0005t\u0000\u0000\u0363\u0084\u0001\u0000\u0000\u0000\u0364\u0365" + + "\u0005s\u0000\u0000\u0365\u0366\u0005w\u0000\u0000\u0366\u0367\u0005i" + + "\u0000\u0000\u0367\u0368\u0005t\u0000\u0000\u0368\u0369\u0005c\u0000\u0000" + + "\u0369\u036a\u0005h\u0000\u0000\u036a\u0086\u0001\u0000\u0000\u0000\u036b" + + "\u036c\u0005t\u0000\u0000\u036c\u036d\u0005e\u0000\u0000\u036d\u036e\u0005" + + "m\u0000\u0000\u036e\u036f\u0005p\u0000\u0000\u036f\u0370\u0005l\u0000" + + "\u0000\u0370\u0371\u0005a\u0000\u0000\u0371\u0372\u0005t\u0000\u0000\u0372" + + "\u0373\u0005e\u0000\u0000\u0373\u0088\u0001\u0000\u0000\u0000\u0374\u0375" + + "\u0005t\u0000\u0000\u0375\u0376\u0005h\u0000\u0000\u0376\u0377\u0005i" + + "\u0000\u0000\u0377\u0378\u0005s\u0000\u0000\u0378\u008a\u0001\u0000\u0000" + + "\u0000\u0379\u037a\u0005t\u0000\u0000\u037a\u037b\u0005h\u0000\u0000\u037b" + + "\u037c\u0005r\u0000\u0000\u037c\u037d\u0005e\u0000\u0000\u037d\u037e\u0005" + + "a\u0000\u0000\u037e\u037f\u0005d\u0000\u0000\u037f\u0380\u0005_\u0000" + + "\u0000\u0380\u0381\u0005l\u0000\u0000\u0381\u0382\u0005o\u0000\u0000\u0382" + + "\u0383\u0005c\u0000\u0000\u0383\u0384\u0005a\u0000\u0000\u0384\u0385\u0005" + + "l\u0000\u0000\u0385\u008c\u0001\u0000\u0000\u0000\u0386\u0387\u0005t\u0000" + + "\u0000\u0387\u0388\u0005h\u0000\u0000\u0388\u0389\u0005r\u0000\u0000\u0389" + + "\u038a\u0005o\u0000\u0000\u038a\u038b\u0005w\u0000\u0000\u038b\u008e\u0001" + + "\u0000\u0000\u0000\u038c\u038d\u0005t\u0000\u0000\u038d\u038e\u0005r\u0000" + + "\u0000\u038e\u038f\u0005u\u0000\u0000\u038f\u0390\u0005e\u0000\u0000\u0390" + + "\u0090\u0001\u0000\u0000\u0000\u0391\u0392\u0005t\u0000\u0000\u0392\u0393" + + "\u0005r\u0000\u0000\u0393\u0394\u0005y\u0000\u0000\u0394\u0092\u0001\u0000" + + "\u0000\u0000\u0395\u0396\u0005t\u0000\u0000\u0396\u0397\u0005y\u0000\u0000" + + "\u0397\u0398\u0005p\u0000\u0000\u0398\u0399\u0005e\u0000\u0000\u0399\u039a" + + "\u0005d\u0000\u0000\u039a\u039b\u0005e\u0000\u0000\u039b\u039c\u0005f" + + "\u0000\u0000\u039c\u0094\u0001\u0000\u0000\u0000\u039d\u039e\u0005t\u0000" + + "\u0000\u039e\u039f\u0005y\u0000\u0000\u039f\u03a0\u0005p\u0000\u0000\u03a0" + + "\u03a1\u0005e\u0000\u0000\u03a1\u03a2\u0005i\u0000\u0000\u03a2\u03a3\u0005" + + "d\u0000\u0000\u03a3\u0096\u0001\u0000\u0000\u0000\u03a4\u03a5\u0005t\u0000" + + "\u0000\u03a5\u03a6\u0005y\u0000\u0000\u03a6\u03a7\u0005p\u0000\u0000\u03a7" + + "\u03a8\u0005e\u0000\u0000\u03a8\u03a9\u0005n\u0000\u0000\u03a9\u03aa\u0005" + + "a\u0000\u0000\u03aa\u03ab\u0005m\u0000\u0000\u03ab\u03ac\u0005e\u0000" + + "\u0000\u03ac\u0098\u0001\u0000\u0000\u0000\u03ad\u03ae\u0005u\u0000\u0000" + + "\u03ae\u03af\u0005n\u0000\u0000\u03af\u03b0\u0005i\u0000\u0000\u03b0\u03b1" + + "\u0005o\u0000\u0000\u03b1\u03b2\u0005n\u0000\u0000\u03b2\u009a\u0001\u0000" + + "\u0000\u0000\u03b3\u03b4\u0005u\u0000\u0000\u03b4\u03b5\u0005n\u0000\u0000" + + "\u03b5\u03b6\u0005s\u0000\u0000\u03b6\u03b7\u0005i\u0000\u0000\u03b7\u03b8" + + "\u0005g\u0000\u0000\u03b8\u03b9\u0005n\u0000\u0000\u03b9\u03ba\u0005e" + + "\u0000\u0000\u03ba\u03bb\u0005d\u0000\u0000\u03bb\u009c\u0001\u0000\u0000" + + "\u0000\u03bc\u03bd\u0005u\u0000\u0000\u03bd\u03be\u0005s\u0000\u0000\u03be" + + "\u03bf\u0005i\u0000\u0000\u03bf\u03c0\u0005n\u0000\u0000\u03c0\u03c1\u0005" + + "g\u0000\u0000\u03c1\u009e\u0001\u0000\u0000\u0000\u03c2\u03c3\u0005v\u0000" + + "\u0000\u03c3\u03c4\u0005i\u0000\u0000\u03c4\u03c5\u0005r\u0000\u0000\u03c5" + + "\u03c6\u0005t\u0000\u0000\u03c6\u03c7\u0005u\u0000\u0000\u03c7\u03c8\u0005" + + "a\u0000\u0000\u03c8\u03c9\u0005l\u0000\u0000\u03c9\u00a0\u0001\u0000\u0000" + + "\u0000\u03ca\u03cb\u0005v\u0000\u0000\u03cb\u03cc\u0005o\u0000\u0000\u03cc" + + "\u03cd\u0005i\u0000\u0000\u03cd\u03ce\u0005d\u0000\u0000\u03ce\u00a2\u0001" + + "\u0000\u0000\u0000\u03cf\u03d0\u0005v\u0000\u0000\u03d0\u03d1\u0005o\u0000" + + "\u0000\u03d1\u03d2\u0005l\u0000\u0000\u03d2\u03d3\u0005a\u0000\u0000\u03d3" + + "\u03d4\u0005t\u0000\u0000\u03d4\u03d5\u0005i\u0000\u0000\u03d5\u03d6\u0005" + + "l\u0000\u0000\u03d6\u03d7\u0005e\u0000\u0000\u03d7\u00a4\u0001\u0000\u0000" + + "\u0000\u03d8\u03d9\u0005w\u0000\u0000\u03d9\u03da\u0005c\u0000\u0000\u03da" + + "\u03db\u0005h\u0000\u0000\u03db\u03dc\u0005a\u0000\u0000\u03dc\u03dd\u0005" + + "r\u0000\u0000\u03dd\u03de\u0005_\u0000\u0000\u03de\u03df\u0005t\u0000" + + "\u0000\u03df\u00a6\u0001\u0000\u0000\u0000\u03e0\u03e1\u0005w\u0000\u0000" + + "\u03e1\u03e2\u0005h\u0000\u0000\u03e2\u03e3\u0005i\u0000\u0000\u03e3\u03e4" + + "\u0005l\u0000\u0000\u03e4\u03e5\u0005e\u0000\u0000\u03e5\u00a8\u0001\u0000" + + "\u0000\u0000\u03e6\u03e7\u0005(\u0000\u0000\u03e7\u00aa\u0001\u0000\u0000" + + "\u0000\u03e8\u03e9\u0005)\u0000\u0000\u03e9\u00ac\u0001\u0000\u0000\u0000" + + "\u03ea\u03eb\u0005[\u0000\u0000\u03eb\u00ae\u0001\u0000\u0000\u0000\u03ec" + + "\u03ed\u0005]\u0000\u0000\u03ed\u00b0\u0001\u0000\u0000\u0000\u03ee\u03ef" + + "\u0005{\u0000\u0000\u03ef\u00b2\u0001\u0000\u0000\u0000\u03f0\u03f1\u0005" + + "}\u0000\u0000\u03f1\u00b4\u0001\u0000\u0000\u0000\u03f2\u03f3\u0005+\u0000" + + "\u0000\u03f3\u00b6\u0001\u0000\u0000\u0000\u03f4\u03f5\u0005-\u0000\u0000" + + "\u03f5\u00b8\u0001\u0000\u0000\u0000\u03f6\u03f7\u0005*\u0000\u0000\u03f7" + + "\u00ba\u0001\u0000\u0000\u0000\u03f8\u03f9\u0005/\u0000\u0000\u03f9\u00bc" + + "\u0001\u0000\u0000\u0000\u03fa\u03fb\u0005%\u0000\u0000\u03fb\u00be\u0001" + + "\u0000\u0000\u0000\u03fc\u03fd\u0005^\u0000\u0000\u03fd\u00c0\u0001\u0000" + + "\u0000\u0000\u03fe\u03ff\u0005&\u0000\u0000\u03ff\u00c2\u0001\u0000\u0000" + + "\u0000\u0400\u0401\u0005|\u0000\u0000\u0401\u00c4\u0001\u0000\u0000\u0000" + + "\u0402\u0403\u0005~\u0000\u0000\u0403\u00c6\u0001\u0000\u0000\u0000\u0404" + + "\u0409\u0005!\u0000\u0000\u0405\u0406\u0005n\u0000\u0000\u0406\u0407\u0005" + + "o\u0000\u0000\u0407\u0409\u0005t\u0000\u0000\u0408\u0404\u0001\u0000\u0000" + + "\u0000\u0408\u0405\u0001\u0000\u0000\u0000\u0409\u00c8\u0001\u0000\u0000" + + "\u0000\u040a\u040b\u0005=\u0000\u0000\u040b\u00ca\u0001\u0000\u0000\u0000" + + "\u040c\u040d\u0005<\u0000\u0000\u040d\u00cc\u0001\u0000\u0000\u0000\u040e" + + "\u040f\u0005>\u0000\u0000\u040f\u00ce\u0001\u0000\u0000\u0000\u0410\u0411" + + "\u0005+\u0000\u0000\u0411\u0412\u0005=\u0000\u0000\u0412\u00d0\u0001\u0000" + + "\u0000\u0000\u0413\u0414\u0005-\u0000\u0000\u0414\u0415\u0005=\u0000\u0000" + + "\u0415\u00d2\u0001\u0000\u0000\u0000\u0416\u0417\u0005*\u0000\u0000\u0417" + + "\u0418\u0005=\u0000\u0000\u0418\u00d4\u0001\u0000\u0000\u0000\u0419\u041a" + + "\u0005/\u0000\u0000\u041a\u041b\u0005=\u0000\u0000\u041b\u00d6\u0001\u0000" + + "\u0000\u0000\u041c\u041d\u0005%\u0000\u0000\u041d\u041e\u0005=\u0000\u0000" + + "\u041e\u00d8\u0001\u0000\u0000\u0000\u041f\u0420\u0005^\u0000\u0000\u0420" + + "\u0421\u0005=\u0000\u0000\u0421\u00da\u0001\u0000\u0000\u0000\u0422\u0423" + + "\u0005&\u0000\u0000\u0423\u0424\u0005=\u0000\u0000\u0424\u00dc\u0001\u0000" + + "\u0000\u0000\u0425\u0426\u0005|\u0000\u0000\u0426\u0427\u0005=\u0000\u0000" + + "\u0427\u00de\u0001\u0000\u0000\u0000\u0428\u0429\u0005<\u0000\u0000\u0429" + + "\u042a\u0005<\u0000\u0000\u042a\u042b\u0005=\u0000\u0000\u042b\u00e0\u0001" + + "\u0000\u0000\u0000\u042c\u042d\u0005>\u0000\u0000\u042d\u042e\u0005>\u0000" + + "\u0000\u042e\u042f\u0005=\u0000\u0000\u042f\u00e2\u0001\u0000\u0000\u0000" + + "\u0430\u0431\u0005=\u0000\u0000\u0431\u0432\u0005=\u0000\u0000\u0432\u00e4" + + "\u0001\u0000\u0000\u0000\u0433\u0434\u0005!\u0000\u0000\u0434\u0435\u0005" + + "=\u0000\u0000\u0435\u00e6\u0001\u0000\u0000\u0000\u0436\u0437\u0005<\u0000" + + "\u0000\u0437\u0438\u0005=\u0000\u0000\u0438\u00e8\u0001\u0000\u0000\u0000" + + "\u0439\u043a\u0005>\u0000\u0000\u043a\u043b\u0005=\u0000\u0000\u043b\u00ea" + + "\u0001\u0000\u0000\u0000\u043c\u043d\u0005&\u0000\u0000\u043d\u0442\u0005" + + "&\u0000\u0000\u043e\u043f\u0005a\u0000\u0000\u043f\u0440\u0005n\u0000" + + "\u0000\u0440\u0442\u0005d\u0000\u0000\u0441\u043c\u0001\u0000\u0000\u0000" + + "\u0441\u043e\u0001\u0000\u0000\u0000\u0442\u00ec\u0001\u0000\u0000\u0000" + + "\u0443\u0444\u0005|\u0000\u0000\u0444\u0448\u0005|\u0000\u0000\u0445\u0446" + + "\u0005o\u0000\u0000\u0446\u0448\u0005r\u0000\u0000\u0447\u0443\u0001\u0000" + + "\u0000\u0000\u0447\u0445\u0001\u0000\u0000\u0000\u0448\u00ee\u0001\u0000" + + "\u0000\u0000\u0449\u044a\u0005+\u0000\u0000\u044a\u044b\u0005+\u0000\u0000" + + "\u044b\u00f0\u0001\u0000\u0000\u0000\u044c\u044d\u0005-\u0000\u0000\u044d" + + "\u044e\u0005-\u0000\u0000\u044e\u00f2\u0001\u0000\u0000\u0000\u044f\u0450" + + "\u0005,\u0000\u0000\u0450\u00f4\u0001\u0000\u0000\u0000\u0451\u0452\u0005" + + "-\u0000\u0000\u0452\u0453\u0005>\u0000\u0000\u0453\u0454\u0005*\u0000" + + "\u0000\u0454\u00f6\u0001\u0000\u0000\u0000\u0455\u0456\u0005-\u0000\u0000" + + "\u0456\u0457\u0005>\u0000\u0000\u0457\u00f8\u0001\u0000\u0000\u0000\u0458" + + "\u0459\u0005?\u0000\u0000\u0459\u00fa\u0001\u0000\u0000\u0000\u045a\u045b" + + "\u0005:\u0000\u0000\u045b\u00fc\u0001\u0000\u0000\u0000\u045c\u045d\u0005" + + ":\u0000\u0000\u045d\u045e\u0005:\u0000\u0000\u045e\u00fe\u0001\u0000\u0000" + + "\u0000\u045f\u0460\u0005;\u0000\u0000\u0460\u0100\u0001\u0000\u0000\u0000" + + "\u0461\u0462\u0005.\u0000\u0000\u0462\u0102\u0001\u0000\u0000\u0000\u0463" + + "\u0464\u0005.\u0000\u0000\u0464\u0465\u0005*\u0000\u0000\u0465\u0104\u0001" + + "\u0000\u0000\u0000\u0466\u0467\u0005.\u0000\u0000\u0467\u0468\u0005.\u0000" + + "\u0000\u0468\u0469\u0005.\u0000\u0000\u0469\u0106\u0001\u0000\u0000\u0000" + + "\u046a\u046b\u0003\u011f\u008f\u0000\u046b\u046c\u0003\u011f\u008f\u0000" + + "\u046c\u046d\u0003\u011f\u008f\u0000\u046d\u046e\u0003\u011f\u008f\u0000" + + "\u046e\u0108\u0001\u0000\u0000\u0000\u046f\u0470\u0005\\\u0000\u0000\u0470" + + "\u0471\u0005u\u0000\u0000\u0471\u0472\u0001\u0000\u0000\u0000\u0472\u047a" + + "\u0003\u0107\u0083\u0000\u0473\u0474\u0005\\\u0000\u0000\u0474\u0475\u0005" + + "U\u0000\u0000\u0475\u0476\u0001\u0000\u0000\u0000\u0476\u0477\u0003\u0107" + + "\u0083\u0000\u0477\u0478\u0003\u0107\u0083\u0000\u0478\u047a\u0001\u0000" + + "\u0000\u0000\u0479\u046f\u0001\u0000\u0000\u0000\u0479\u0473\u0001\u0000" + + "\u0000\u0000\u047a\u010a\u0001\u0000\u0000\u0000\u047b\u0480\u0003\u010d" + + "\u0086\u0000\u047c\u047f\u0003\u010d\u0086\u0000\u047d\u047f\u0003\u0111" + + "\u0088\u0000\u047e\u047c\u0001\u0000\u0000\u0000\u047e\u047d\u0001\u0000" + + "\u0000\u0000\u047f\u0482\u0001\u0000\u0000\u0000\u0480\u047e\u0001\u0000" + + "\u0000\u0000\u0480\u0481\u0001\u0000\u0000\u0000\u0481\u010c\u0001\u0000" + + "\u0000\u0000\u0482\u0480\u0001\u0000\u0000\u0000\u0483\u0486\u0003\u010f" + + "\u0087\u0000\u0484\u0486\u0003\u0109\u0084\u0000\u0485\u0483\u0001\u0000" + + "\u0000\u0000\u0485\u0484\u0001\u0000\u0000\u0000\u0486\u010e\u0001\u0000" + + "\u0000\u0000\u0487\u0488\u0007\u0002\u0000\u0000\u0488\u0110\u0001\u0000" + + "\u0000\u0000\u0489\u048a\u0007\u0003\u0000\u0000\u048a\u0112\u0001\u0000" + + "\u0000\u0000\u048b\u0492\u0003\u011b\u008d\u0000\u048c\u048e\u0005\'\u0000" + + "\u0000\u048d\u048c\u0001\u0000\u0000\u0000\u048d\u048e\u0001\u0000\u0000" + + "\u0000\u048e\u048f\u0001\u0000\u0000\u0000\u048f\u0491\u0003\u0111\u0088" + + "\u0000\u0490\u048d\u0001\u0000\u0000\u0000\u0491\u0494\u0001\u0000\u0000" + + "\u0000\u0492\u0490\u0001\u0000\u0000\u0000\u0492\u0493\u0001\u0000\u0000" + + "\u0000\u0493\u0114\u0001\u0000\u0000\u0000\u0494\u0492\u0001\u0000\u0000" + + "\u0000\u0495\u049c\u00050\u0000\u0000\u0496\u0498\u0005\'\u0000\u0000" + + "\u0497\u0496\u0001\u0000\u0000\u0000\u0497\u0498\u0001\u0000\u0000\u0000" + + "\u0498\u0499\u0001\u0000\u0000\u0000\u0499\u049b\u0003\u011d\u008e\u0000" + + "\u049a\u0497\u0001\u0000\u0000\u0000\u049b\u049e\u0001\u0000\u0000\u0000" + + "\u049c\u049a\u0001\u0000\u0000\u0000\u049c\u049d\u0001\u0000\u0000\u0000" + + "\u049d\u0116\u0001\u0000\u0000\u0000\u049e\u049c\u0001\u0000\u0000\u0000" + + "\u049f\u04a0\u00050\u0000\u0000\u04a0\u04a4\u0005x\u0000\u0000\u04a1\u04a2" + + "\u00050\u0000\u0000\u04a2\u04a4\u0005X\u0000\u0000\u04a3\u049f\u0001\u0000" + + "\u0000\u0000\u04a3\u04a1\u0001\u0000\u0000\u0000\u04a4\u04a5\u0001\u0000" + + "\u0000\u0000\u04a5\u04ac\u0003\u011f\u008f\u0000\u04a6\u04a8\u0005\'\u0000" + + "\u0000\u04a7\u04a6\u0001\u0000\u0000\u0000\u04a7\u04a8\u0001\u0000\u0000" + + "\u0000\u04a8\u04a9\u0001\u0000\u0000\u0000\u04a9\u04ab\u0003\u011f\u008f" + + "\u0000\u04aa\u04a7\u0001\u0000\u0000\u0000\u04ab\u04ae\u0001\u0000\u0000" + + "\u0000\u04ac\u04aa\u0001\u0000\u0000\u0000\u04ac\u04ad\u0001\u0000\u0000" + + "\u0000\u04ad\u0118\u0001\u0000\u0000\u0000\u04ae\u04ac\u0001\u0000\u0000" + + "\u0000\u04af\u04b0\u00050\u0000\u0000\u04b0\u04b4\u0005b\u0000\u0000\u04b1" + + "\u04b2\u00050\u0000\u0000\u04b2\u04b4\u0005B\u0000\u0000\u04b3\u04af\u0001" + + "\u0000\u0000\u0000\u04b3\u04b1\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001" + + "\u0000\u0000\u0000\u04b5\u04bc\u0003\u0121\u0090\u0000\u04b6\u04b8\u0005" + + "\'\u0000\u0000\u04b7\u04b6\u0001\u0000\u0000\u0000\u04b7\u04b8\u0001\u0000" + + "\u0000\u0000\u04b8\u04b9\u0001\u0000\u0000\u0000\u04b9\u04bb\u0003\u0121" + + "\u0090\u0000\u04ba\u04b7\u0001\u0000\u0000\u0000\u04bb\u04be\u0001\u0000" + + "\u0000\u0000\u04bc\u04ba\u0001\u0000\u0000\u0000\u04bc\u04bd\u0001\u0000" + + "\u0000\u0000\u04bd\u011a\u0001\u0000\u0000\u0000\u04be\u04bc\u0001\u0000" + + "\u0000\u0000\u04bf\u04c0\u0007\u0004\u0000\u0000\u04c0\u011c\u0001\u0000" + + "\u0000\u0000\u04c1\u04c2\u0007\u0005\u0000\u0000\u04c2\u011e\u0001\u0000" + + "\u0000\u0000\u04c3\u04c4\u0007\u0006\u0000\u0000\u04c4\u0120\u0001\u0000" + + "\u0000\u0000\u04c5\u04c6\u0007\u0007\u0000\u0000\u04c6\u0122\u0001\u0000" + + "\u0000\u0000\u04c7\u04c9\u0003\u0125\u0092\u0000\u04c8\u04ca\u0003\u0127" + + "\u0093\u0000\u04c9\u04c8\u0001\u0000\u0000\u0000\u04c9\u04ca\u0001\u0000" + + "\u0000\u0000\u04ca\u04d8\u0001\u0000\u0000\u0000\u04cb\u04cd\u0003\u0125" + + "\u0092\u0000\u04cc\u04ce\u0003\u0129\u0094\u0000\u04cd\u04cc\u0001\u0000" + + "\u0000\u0000\u04cd\u04ce\u0001\u0000\u0000\u0000\u04ce\u04d8\u0001\u0000" + + "\u0000\u0000\u04cf\u04d1\u0003\u0127\u0093\u0000\u04d0\u04d2\u0003\u0125" + + "\u0092\u0000\u04d1\u04d0\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000" + + "\u0000\u0000\u04d2\u04d8\u0001\u0000\u0000\u0000\u04d3\u04d5\u0003\u0129" + + "\u0094\u0000\u04d4\u04d6\u0003\u0125\u0092\u0000\u04d5\u04d4\u0001\u0000" + + "\u0000\u0000\u04d5\u04d6\u0001\u0000\u0000\u0000\u04d6\u04d8\u0001\u0000" + + "\u0000\u0000\u04d7\u04c7\u0001\u0000\u0000\u0000\u04d7\u04cb\u0001\u0000" + + "\u0000\u0000\u04d7\u04cf\u0001\u0000\u0000\u0000\u04d7\u04d3\u0001\u0000" + + "\u0000\u0000\u04d8\u0124\u0001\u0000\u0000\u0000\u04d9\u04da\u0007\b\u0000" + + "\u0000\u04da\u0126\u0001\u0000\u0000\u0000\u04db\u04dc\u0007\t\u0000\u0000" + + "\u04dc\u0128\u0001\u0000\u0000\u0000\u04dd\u04de\u0005l\u0000\u0000\u04de" + + "\u04e2\u0005l\u0000\u0000\u04df\u04e0\u0005L\u0000\u0000\u04e0\u04e2\u0005" + + "L\u0000\u0000\u04e1\u04dd\u0001\u0000\u0000\u0000\u04e1\u04df\u0001\u0000" + + "\u0000\u0000\u04e2\u012a\u0001\u0000\u0000\u0000\u04e3\u04e7\b\n\u0000" + + "\u0000\u04e4\u04e7\u0003\u012d\u0096\u0000\u04e5\u04e7\u0003\u0109\u0084" + + "\u0000\u04e6\u04e3\u0001\u0000\u0000\u0000\u04e6\u04e4\u0001\u0000\u0000" + + "\u0000\u04e6\u04e5\u0001\u0000\u0000\u0000\u04e7\u012c\u0001\u0000\u0000" + + "\u0000\u04e8\u04ec\u0003\u012f\u0097\u0000\u04e9\u04ec\u0003\u0131\u0098" + + "\u0000\u04ea\u04ec\u0003\u0133\u0099\u0000\u04eb\u04e8\u0001\u0000\u0000" + + "\u0000\u04eb\u04e9\u0001\u0000\u0000\u0000\u04eb\u04ea\u0001\u0000\u0000" + + "\u0000\u04ec\u012e\u0001\u0000\u0000\u0000\u04ed\u04ee\u0005\\\u0000\u0000" + + "\u04ee\u050c\u0005\'\u0000\u0000\u04ef\u04f0\u0005\\\u0000\u0000\u04f0" + + "\u050c\u0005\"\u0000\u0000\u04f1\u04f2\u0005\\\u0000\u0000\u04f2\u050c" + + "\u0005?\u0000\u0000\u04f3\u04f4\u0005\\\u0000\u0000\u04f4\u050c\u0005" + + "\\\u0000\u0000\u04f5\u04f6\u0005\\\u0000\u0000\u04f6\u050c\u0005a\u0000" + + "\u0000\u04f7\u04f8\u0005\\\u0000\u0000\u04f8\u050c\u0005b\u0000\u0000" + + "\u04f9\u04fa\u0005\\\u0000\u0000\u04fa\u050c\u0005f\u0000\u0000\u04fb" + + "\u04fc\u0005\\\u0000\u0000\u04fc\u050c\u0005n\u0000\u0000\u04fd\u04fe" + + "\u0005\\\u0000\u0000\u04fe\u050c\u0005r\u0000\u0000\u04ff\u0505\u0005" + + "\\\u0000\u0000\u0500\u0502\u0005\r\u0000\u0000\u0501\u0503\u0005\n\u0000" + + "\u0000\u0502\u0501\u0001\u0000\u0000\u0000\u0502\u0503\u0001\u0000\u0000" + + "\u0000\u0503\u0506\u0001\u0000\u0000\u0000\u0504\u0506\u0005\n\u0000\u0000" + + "\u0505\u0500\u0001\u0000\u0000\u0000\u0505\u0504\u0001\u0000\u0000\u0000" + + "\u0506\u050c\u0001\u0000\u0000\u0000\u0507\u0508\u0005\\\u0000\u0000\u0508" + + "\u050c\u0005t\u0000\u0000\u0509\u050a\u0005\\\u0000\u0000\u050a\u050c" + + "\u0005v\u0000\u0000\u050b\u04ed\u0001\u0000\u0000\u0000\u050b\u04ef\u0001" + + "\u0000\u0000\u0000\u050b\u04f1\u0001\u0000\u0000\u0000\u050b\u04f3\u0001" + + "\u0000\u0000\u0000\u050b\u04f5\u0001\u0000\u0000\u0000\u050b\u04f7\u0001" + + "\u0000\u0000\u0000\u050b\u04f9\u0001\u0000\u0000\u0000\u050b\u04fb\u0001" + + "\u0000\u0000\u0000\u050b\u04fd\u0001\u0000\u0000\u0000\u050b\u04ff\u0001" + + "\u0000\u0000\u0000\u050b\u0507\u0001\u0000\u0000\u0000\u050b\u0509\u0001" + + "\u0000\u0000\u0000\u050c\u0130\u0001\u0000\u0000\u0000\u050d\u050e\u0005" + + "\\\u0000\u0000\u050e\u0519\u0003\u011d\u008e\u0000\u050f\u0510\u0005\\" + + "\u0000\u0000\u0510\u0511\u0003\u011d\u008e\u0000\u0511\u0512\u0003\u011d" + + "\u008e\u0000\u0512\u0519\u0001\u0000\u0000\u0000\u0513\u0514\u0005\\\u0000" + + "\u0000\u0514\u0515\u0003\u011d\u008e\u0000\u0515\u0516\u0003\u011d\u008e" + + "\u0000\u0516\u0517\u0003\u011d\u008e\u0000\u0517\u0519\u0001\u0000\u0000" + + "\u0000\u0518\u050d\u0001\u0000\u0000\u0000\u0518\u050f\u0001\u0000\u0000" + + "\u0000\u0518\u0513\u0001\u0000\u0000\u0000\u0519\u0132\u0001\u0000\u0000" + + "\u0000\u051a\u051b\u0005\\\u0000\u0000\u051b\u051c\u0005x\u0000\u0000" + + "\u051c\u051e\u0001\u0000\u0000\u0000\u051d\u051f\u0003\u011f\u008f\u0000" + + "\u051e\u051d\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000\u0000\u0000" + + "\u0520\u051e\u0001\u0000\u0000\u0000\u0520\u0521\u0001\u0000\u0000\u0000" + + "\u0521\u0134\u0001\u0000\u0000\u0000\u0522\u0524\u0003\u013b\u009d\u0000" + + "\u0523\u0522\u0001\u0000\u0000\u0000\u0523\u0524\u0001\u0000\u0000\u0000" + + "\u0524\u0525\u0001\u0000\u0000\u0000\u0525\u0526\u0005.\u0000\u0000\u0526" + + "\u052b\u0003\u013b\u009d\u0000\u0527\u0528\u0003\u013b\u009d\u0000\u0528" + + "\u0529\u0005.\u0000\u0000\u0529\u052b\u0001\u0000\u0000\u0000\u052a\u0523" + + "\u0001\u0000\u0000\u0000\u052a\u0527\u0001\u0000\u0000\u0000\u052b\u0136" + + "\u0001\u0000\u0000\u0000\u052c\u052e\u0005e\u0000\u0000\u052d\u052f\u0003" + + "\u0139\u009c\u0000\u052e\u052d\u0001\u0000\u0000\u0000\u052e\u052f\u0001" + + "\u0000\u0000\u0000\u052f\u0530\u0001\u0000\u0000\u0000\u0530\u0537\u0003" + + "\u013b\u009d\u0000\u0531\u0533\u0005E\u0000\u0000\u0532\u0534\u0003\u0139" + + "\u009c\u0000\u0533\u0532\u0001\u0000\u0000\u0000\u0533\u0534\u0001\u0000" + + "\u0000\u0000\u0534\u0535\u0001\u0000\u0000\u0000\u0535\u0537\u0003\u013b" + + "\u009d\u0000\u0536\u052c\u0001\u0000\u0000\u0000\u0536\u0531\u0001\u0000" + + "\u0000\u0000\u0537\u0138\u0001\u0000\u0000\u0000\u0538\u0539\u0007\u000b" + + "\u0000\u0000\u0539\u013a\u0001\u0000\u0000\u0000\u053a\u0541\u0003\u0111" + + "\u0088\u0000\u053b\u053d\u0005\'\u0000\u0000\u053c\u053b\u0001\u0000\u0000" + + "\u0000\u053c\u053d\u0001\u0000\u0000\u0000\u053d\u053e\u0001\u0000\u0000" + + "\u0000\u053e\u0540\u0003\u0111\u0088\u0000\u053f\u053c\u0001\u0000\u0000" + + "\u0000\u0540\u0543\u0001\u0000\u0000\u0000\u0541\u053f\u0001\u0000\u0000" + + "\u0000\u0541\u0542\u0001\u0000\u0000\u0000\u0542\u013c\u0001\u0000\u0000" + + "\u0000\u0543\u0541\u0001\u0000\u0000\u0000\u0544\u0545\u0007\f\u0000\u0000" + + "\u0545\u013e\u0001\u0000\u0000\u0000\u0546\u0547\u0005u\u0000\u0000\u0547" + + "\u054a\u00058\u0000\u0000\u0548\u054a\u0007\u0000\u0000\u0000\u0549\u0546" + + "\u0001\u0000\u0000\u0000\u0549\u0548\u0001\u0000\u0000\u0000\u054a\u0140" + + "\u0001\u0000\u0000\u0000\u054b\u054f\b\r\u0000\u0000\u054c\u054f\u0003" + + "\u012d\u0096\u0000\u054d\u054f\u0003\u0109\u0084\u0000\u054e\u054b\u0001" + + "\u0000\u0000\u0000\u054e\u054c\u0001\u0000\u0000\u0000\u054e\u054d\u0001" + + "\u0000\u0000\u0000\u054f\u0142\u0001\u0000\u0000\u0000\u0550\u0554\u0005" + + "\"\u0000\u0000\u0551\u0553\b\u000e\u0000\u0000\u0552\u0551\u0001\u0000" + + "\u0000\u0000\u0553\u0556\u0001\u0000\u0000\u0000\u0554\u0552\u0001\u0000" + + "\u0000\u0000\u0554\u0555\u0001\u0000\u0000\u0000\u0555\u0557\u0001\u0000" + + "\u0000\u0000\u0556\u0554\u0001\u0000\u0000\u0000\u0557\u055b\u0005(\u0000" + + "\u0000\u0558\u055a\b\u000f\u0000\u0000\u0559\u0558\u0001\u0000\u0000\u0000" + + "\u055a\u055d\u0001\u0000\u0000\u0000\u055b\u0559\u0001\u0000\u0000\u0000" + + "\u055b\u055c\u0001\u0000\u0000\u0000\u055c\u055e\u0001\u0000\u0000\u0000" + + "\u055d\u055b\u0001\u0000\u0000\u0000\u055e\u0562\u0005)\u0000\u0000\u055f" + + "\u0561\b\u0010\u0000\u0000\u0560\u055f\u0001\u0000\u0000\u0000\u0561\u0564" + + "\u0001\u0000\u0000\u0000\u0562\u0560\u0001\u0000\u0000\u0000\u0562\u0563" + + "\u0001\u0000\u0000\u0000\u0563\u0565\u0001\u0000\u0000\u0000\u0564\u0562" + + "\u0001\u0000\u0000\u0000\u0565\u0566\u0005\"\u0000\u0000\u0566\u0144\u0001" + + "\u0000\u0000\u0000\u0567\u0568\u0003\u0113\u0089\u0000\u0568\u0569\u0003" + + "\u014d\u00a6\u0000\u0569\u0574\u0001\u0000\u0000\u0000\u056a\u056b\u0003" + + "\u0115\u008a\u0000\u056b\u056c\u0003\u014d\u00a6\u0000\u056c\u0574\u0001" + + "\u0000\u0000\u0000\u056d\u056e\u0003\u0117\u008b\u0000\u056e\u056f\u0003" + + "\u014d\u00a6\u0000\u056f\u0574\u0001\u0000\u0000\u0000\u0570\u0571\u0003" + + "\u0119\u008c\u0000\u0571\u0572\u0003\u014d\u00a6\u0000\u0572\u0574\u0001" + + "\u0000\u0000\u0000\u0573\u0567\u0001\u0000\u0000\u0000\u0573\u056a\u0001" + + "\u0000\u0000\u0000\u0573\u056d\u0001\u0000\u0000\u0000\u0573\u0570\u0001" + + "\u0000\u0000\u0000\u0574\u0146\u0001\u0000\u0000\u0000\u0575\u0577\u0003" + + "\u0135\u009a\u0000\u0576\u0578\u0003\u0137\u009b\u0000\u0577\u0576\u0001" + + "\u0000\u0000\u0000\u0577\u0578\u0001\u0000\u0000\u0000\u0578\u0579\u0001" + + "\u0000\u0000\u0000\u0579\u057a\u0003\u014d\u00a6\u0000\u057a\u0580\u0001" + + "\u0000\u0000\u0000\u057b\u057c\u0003\u013b\u009d\u0000\u057c\u057d\u0003" + + "\u0137\u009b\u0000\u057d\u057e\u0003\u014d\u00a6\u0000\u057e\u0580\u0001" + + "\u0000\u0000\u0000\u057f\u0575\u0001\u0000\u0000\u0000\u057f\u057b\u0001" + + "\u0000\u0000\u0000\u0580\u0148\u0001\u0000\u0000\u0000\u0581\u0582\u0003" + + "\u0007\u0003\u0000\u0582\u0583\u0003\u014d\u00a6\u0000\u0583\u014a\u0001" + + "\u0000\u0000\u0000\u0584\u0585\u0003\u0003\u0001\u0000\u0585\u0586\u0003" + + "\u014d\u00a6\u0000\u0586\u014c\u0001\u0000\u0000\u0000\u0587\u0588\u0003" + + "\u010b\u0085\u0000\u0588\u014e\u0001\u0000\u0000\u0000\u0589\u058b\u0007" + + "\u0011\u0000\u0000\u058a\u0589\u0001\u0000\u0000\u0000\u058b\u058c\u0001" + + "\u0000\u0000\u0000\u058c\u058a\u0001\u0000\u0000\u0000\u058c\u058d\u0001" + + "\u0000\u0000\u0000\u058d\u058e\u0001\u0000\u0000\u0000\u058e\u058f\u0006" + + "\u00a7\u0001\u0000\u058f\u0150\u0001\u0000\u0000\u0000\u0590\u0592\u0005" + + "\r\u0000\u0000\u0591\u0593\u0005\n\u0000\u0000\u0592\u0591\u0001\u0000" + + "\u0000\u0000\u0592\u0593\u0001\u0000\u0000\u0000\u0593\u0596\u0001\u0000" + + "\u0000\u0000\u0594\u0596\u0005\n\u0000\u0000\u0595\u0590\u0001\u0000\u0000" + + "\u0000\u0595\u0594\u0001\u0000\u0000\u0000\u0596\u0597\u0001\u0000\u0000" + + "\u0000\u0597\u0598\u0006\u00a8\u0001\u0000\u0598\u0152\u0001\u0000\u0000" + + "\u0000\u0599\u059a\u0005/\u0000\u0000\u059a\u059b\u0005*\u0000\u0000\u059b" + + "\u059f\u0001\u0000\u0000\u0000\u059c\u059e\t\u0000\u0000\u0000\u059d\u059c" + + "\u0001\u0000\u0000\u0000\u059e\u05a1\u0001\u0000\u0000\u0000\u059f\u05a0" + + "\u0001\u0000\u0000\u0000\u059f\u059d\u0001\u0000\u0000\u0000\u05a0\u05a2" + + "\u0001\u0000\u0000\u0000\u05a1\u059f\u0001\u0000\u0000\u0000\u05a2\u05a3" + + "\u0005*\u0000\u0000\u05a3\u05a4\u0005/\u0000\u0000\u05a4\u05a5\u0001\u0000" + + "\u0000\u0000\u05a5\u05a6\u0006\u00a9\u0001\u0000\u05a6\u0154\u0001\u0000" + + "\u0000\u0000\u05a7\u05a8\u0005/\u0000\u0000\u05a8\u05a9\u0005/\u0000\u0000" + + "\u05a9\u05ad\u0001\u0000\u0000\u0000\u05aa\u05ac\b\u0012\u0000\u0000\u05ab" + + "\u05aa\u0001\u0000\u0000\u0000\u05ac\u05af\u0001\u0000\u0000\u0000\u05ad" + + "\u05ab\u0001\u0000\u0000\u0000\u05ad\u05ae\u0001\u0000\u0000\u0000\u05ae" + + "\u05b0\u0001\u0000\u0000\u0000\u05af\u05ad\u0001\u0000\u0000\u0000\u05b0" + + "\u05b1\u0006\u00aa\u0001\u0000\u05b1\u0156\u0001\u0000\u0000\u0000I\u0000" + + "\u0159\u015d\u0161\u0165\u0167\u016a\u0170\u0176\u0179\u017e\u0180\u0183" + + "\u0189\u018e\u0192\u0196\u019e\u01a4\u01a9\u01ae\u01b3\u01bb\u0408\u0441" + + "\u0447\u0479\u047e\u0480\u0485\u048d\u0492\u0497\u049c\u04a3\u04a7\u04ac" + + "\u04b3\u04b7\u04bc\u04c9\u04cd\u04d1\u04d5\u04d7\u04e1\u04e6\u04eb\u0502" + + "\u0505\u050b\u0518\u0520\u0523\u052a\u052e\u0533\u0536\u053c\u0541\u0549" + + "\u054e\u0554\u055b\u0562\u0573\u0577\u057f\u058c\u0592\u0595\u059f\u05ad" + + "\u0002\u0000\u0001\u0000\u0006\u0000\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.tokens b/src/main/java/CPP14Lexer.tokens similarity index 100% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.tokens rename to src/main/java/CPP14Lexer.tokens diff --git a/src/main/java/CPP14Parser.interp b/src/main/java/CPP14Parser.interp new file mode 100644 index 0000000..b2fa0a5 --- /dev/null +++ b/src/main/java/CPP14Parser.interp @@ -0,0 +1,490 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +'alignas' +'alignof' +'asm' +'auto' +'bool' +'break' +'case' +'catch' +'char' +'char16_t' +'char32_t' +'class' +'const' +'constexpr' +'const_cast' +'continue' +'decltype' +'default' +'delete' +'do' +'double' +'dynamic_cast' +'else' +'enum' +'explicit' +'export' +'extern' +'false' +'final' +'float' +'for' +'friend' +'goto' +'if' +'inline' +'int' +'long' +'mutable' +'namespace' +'new' +'noexcept' +'nullptr' +'operator' +'override' +'private' +'protected' +'public' +'register' +'reinterpret_cast' +'return' +'short' +'signed' +'sizeof' +'static' +'static_assert' +'static_cast' +'struct' +'switch' +'template' +'this' +'thread_local' +'throw' +'true' +'try' +'typedef' +'typeid' +'typename' +'union' +'unsigned' +'using' +'virtual' +'void' +'volatile' +'wchar_t' +'while' +'(' +')' +'[' +']' +'{' +'}' +'+' +'-' +'*' +'/' +'%' +'^' +'&' +'|' +'~' +null +'=' +'<' +'>' +'+=' +'-=' +'*=' +'/=' +'%=' +'^=' +'&=' +'|=' +'<<=' +'>>=' +'==' +'!=' +'<=' +'>=' +null +null +'++' +'--' +',' +'->*' +'->' +'?' +':' +'::' +';' +'.' +'.*' +'...' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Identifier +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +Integersuffix +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Whitespace +Newline +BlockComment +LineComment + +rule names: +translationUnit +primaryExpression +idExpression +unqualifiedId +qualifiedId +nestedNameSpecifier +lambdaExpression +lambdaIntroducer +lambdaCapture +captureDefault +captureList +capture +simpleCapture +initcapture +lambdaDeclarator +postfixExpression +typeIdOfTheTypeId +expressionList +pseudoDestructorName +unaryExpression +unaryOperator +newExpression +newPlacement +newTypeId +newDeclarator +noPointerNewDeclarator +newInitializer +deleteExpression +noExceptExpression +castExpression +pointerMemberExpression +multiplicativeExpression +additiveExpression +shiftExpression +shiftOperator +relationalExpression +equalityExpression +andExpression +exclusiveOrExpression +inclusiveOrExpression +logicalAndExpression +logicalOrExpression +conditionalExpression +assignmentExpression +assignmentOperator +expression +constantExpression +statement +labeledStatement +expressionStatement +compoundStatement +statementSeq +selectionStatement +condition +iterationStatement +forInitStatement +forRangeDeclaration +forRangeInitializer +jumpStatement +declarationStatement +declarationseq +declaration +blockDeclaration +aliasDeclaration +simpleDeclaration +staticAssertDeclaration +emptyDeclaration +attributeDeclaration +declSpecifier +declSpecifierSeq +storageClassSpecifier +functionSpecifier +typedefName +typeSpecifier +trailingTypeSpecifier +typeSpecifierSeq +trailingTypeSpecifierSeq +simpleTypeSpecifier +theTypeName +decltypeSpecifier +elaboratedTypeSpecifier +enumName +enumSpecifier +enumHead +opaqueEnumDeclaration +enumkey +enumbase +enumeratorList +enumeratorDefinition +enumerator +namespaceName +originalNamespaceName +namespaceDefinition +namespaceAlias +namespaceAliasDefinition +qualifiednamespacespecifier +usingDeclaration +usingDirective +asmDefinition +linkageSpecification +attributeSpecifierSeq +attributeSpecifier +alignmentspecifier +attributeList +attribute +attributeNamespace +attributeArgumentClause +balancedTokenSeq +balancedtoken +initDeclaratorList +initDeclarator +declarator +pointerDeclarator +noPointerDeclarator +parametersAndQualifiers +trailingReturnType +pointerOperator +cvqualifierseq +cvQualifier +refqualifier +declaratorid +theTypeId +abstractDeclarator +pointerAbstractDeclarator +noPointerAbstractDeclarator +abstractPackDeclarator +noPointerAbstractPackDeclarator +parameterDeclarationClause +parameterDeclarationList +parameterDeclaration +functionDefinition +functionBody +initializer +braceOrEqualInitializer +initializerClause +initializerList +bracedInitList +className +classSpecifier +classHead +classHeadName +classVirtSpecifier +classKey +memberSpecification +memberdeclaration +memberDeclaratorList +memberDeclarator +virtualSpecifierSeq +virtualSpecifier +pureSpecifier +baseClause +baseSpecifierList +baseSpecifier +classOrDeclType +baseTypeSpecifier +accessSpecifier +conversionFunctionId +conversionTypeId +conversionDeclarator +constructorInitializer +memInitializerList +memInitializer +meminitializerid +operatorFunctionId +literalOperatorId +templateDeclaration +templateparameterList +templateParameter +typeParameter +simpleTemplateId +templateId +templateName +templateArgumentList +templateArgument +typeNameSpecifier +explicitInstantiation +explicitSpecialization +tryBlock +functionTryBlock +handlerSeq +handler +exceptionDeclaration +throwExpression +exceptionSpecification +dynamicExceptionSpecification +typeIdList +noeExceptSpecification +theOperator +literal + + +atn: +[4, 1, 145, 2075, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 1, 0, 3, 0, 380, 8, 0, 1, 0, 1, 0, 1, 1, 4, 1, 385, 8, 1, 11, 1, 12, 1, 386, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 396, 8, 1, 1, 2, 1, 2, 3, 2, 400, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 409, 8, 3, 1, 3, 3, 3, 412, 8, 3, 1, 4, 1, 4, 3, 4, 416, 8, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 424, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 431, 8, 5, 1, 5, 3, 5, 434, 8, 5, 1, 5, 5, 5, 437, 8, 5, 10, 5, 12, 5, 440, 9, 5, 1, 6, 1, 6, 3, 6, 444, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 3, 7, 450, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 458, 8, 8, 3, 8, 460, 8, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 5, 10, 467, 8, 10, 10, 10, 12, 10, 470, 9, 10, 1, 10, 3, 10, 473, 8, 10, 1, 11, 1, 11, 3, 11, 477, 8, 11, 1, 12, 3, 12, 480, 8, 12, 1, 12, 1, 12, 3, 12, 484, 8, 12, 1, 13, 3, 13, 487, 8, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 494, 8, 14, 1, 14, 1, 14, 3, 14, 498, 8, 14, 1, 14, 3, 14, 501, 8, 14, 1, 14, 3, 14, 504, 8, 14, 1, 14, 3, 14, 507, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 513, 8, 15, 1, 15, 1, 15, 3, 15, 517, 8, 15, 1, 15, 1, 15, 3, 15, 521, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 535, 8, 15, 1, 15, 1, 15, 3, 15, 539, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 545, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 552, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 558, 8, 15, 1, 15, 1, 15, 3, 15, 562, 8, 15, 1, 15, 1, 15, 5, 15, 566, 8, 15, 10, 15, 12, 15, 569, 9, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 3, 18, 576, 8, 18, 1, 18, 1, 18, 1, 18, 3, 18, 581, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 594, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 601, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 613, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 623, 8, 19, 1, 20, 1, 20, 1, 21, 3, 21, 628, 8, 21, 1, 21, 1, 21, 3, 21, 632, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 639, 8, 21, 1, 21, 3, 21, 642, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 3, 23, 650, 8, 23, 1, 24, 1, 24, 3, 24, 654, 8, 24, 1, 24, 3, 24, 657, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 664, 8, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 671, 8, 25, 5, 25, 673, 8, 25, 10, 25, 12, 25, 676, 9, 25, 1, 26, 1, 26, 3, 26, 680, 8, 26, 1, 26, 1, 26, 3, 26, 684, 8, 26, 1, 27, 3, 27, 687, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 692, 8, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 707, 8, 29, 1, 30, 1, 30, 1, 30, 5, 30, 712, 8, 30, 10, 30, 12, 30, 715, 9, 30, 1, 31, 1, 31, 1, 31, 5, 31, 720, 8, 31, 10, 31, 12, 31, 723, 9, 31, 1, 32, 1, 32, 1, 32, 5, 32, 728, 8, 32, 10, 32, 12, 32, 731, 9, 32, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 737, 8, 33, 10, 33, 12, 33, 740, 9, 33, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 746, 8, 34, 1, 35, 1, 35, 1, 35, 5, 35, 751, 8, 35, 10, 35, 12, 35, 754, 9, 35, 1, 36, 1, 36, 1, 36, 5, 36, 759, 8, 36, 10, 36, 12, 36, 762, 9, 36, 1, 37, 1, 37, 1, 37, 5, 37, 767, 8, 37, 10, 37, 12, 37, 770, 9, 37, 1, 38, 1, 38, 1, 38, 5, 38, 775, 8, 38, 10, 38, 12, 38, 778, 9, 38, 1, 39, 1, 39, 1, 39, 5, 39, 783, 8, 39, 10, 39, 12, 39, 786, 9, 39, 1, 40, 1, 40, 1, 40, 5, 40, 791, 8, 40, 10, 40, 12, 40, 794, 9, 40, 1, 41, 1, 41, 1, 41, 5, 41, 799, 8, 41, 10, 41, 12, 41, 802, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 810, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 818, 8, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 5, 45, 825, 8, 45, 10, 45, 12, 45, 828, 9, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 834, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 842, 8, 47, 1, 47, 3, 47, 845, 8, 47, 1, 48, 3, 48, 848, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 854, 8, 48, 1, 48, 1, 48, 1, 48, 1, 49, 3, 49, 860, 8, 49, 1, 49, 1, 49, 1, 50, 1, 50, 3, 50, 866, 8, 50, 1, 50, 1, 50, 1, 51, 4, 51, 871, 8, 51, 11, 51, 12, 51, 872, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 882, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 890, 8, 52, 1, 53, 1, 53, 3, 53, 894, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 901, 8, 53, 3, 53, 903, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 923, 8, 54, 1, 54, 1, 54, 3, 54, 927, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 933, 8, 54, 1, 54, 1, 54, 1, 54, 3, 54, 938, 8, 54, 1, 55, 1, 55, 3, 55, 942, 8, 55, 1, 56, 3, 56, 945, 8, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 3, 57, 952, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 959, 8, 58, 1, 58, 1, 58, 3, 58, 963, 8, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 4, 60, 970, 8, 60, 11, 60, 12, 60, 971, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 983, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 993, 8, 62, 1, 63, 1, 63, 1, 63, 3, 63, 998, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 3, 64, 1005, 8, 64, 1, 64, 3, 64, 1008, 8, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1013, 8, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1018, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1039, 8, 68, 1, 69, 4, 69, 1042, 8, 69, 11, 69, 12, 69, 1043, 1, 69, 3, 69, 1047, 8, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 1058, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1064, 8, 74, 1, 75, 4, 75, 1067, 8, 75, 11, 75, 12, 75, 1068, 1, 75, 3, 75, 1072, 8, 75, 1, 76, 4, 76, 1075, 8, 76, 11, 76, 12, 76, 1076, 1, 76, 3, 76, 1080, 8, 76, 1, 77, 3, 77, 1083, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1105, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1111, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1117, 8, 79, 1, 79, 1, 79, 1, 80, 1, 80, 3, 80, 1123, 8, 80, 1, 80, 3, 80, 1126, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1132, 8, 80, 1, 80, 1, 80, 3, 80, 1136, 8, 80, 1, 80, 1, 80, 3, 80, 1140, 8, 80, 1, 80, 3, 80, 1143, 8, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1151, 8, 82, 3, 82, 1153, 8, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1159, 8, 83, 1, 83, 3, 83, 1162, 8, 83, 1, 83, 3, 83, 1165, 8, 83, 1, 83, 3, 83, 1168, 8, 83, 1, 84, 1, 84, 3, 84, 1172, 8, 84, 1, 84, 1, 84, 3, 84, 1176, 8, 84, 1, 84, 1, 84, 1, 85, 1, 85, 3, 85, 1182, 8, 85, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 5, 87, 1190, 8, 87, 10, 87, 12, 87, 1193, 9, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1198, 8, 88, 1, 89, 1, 89, 1, 90, 1, 90, 3, 90, 1204, 8, 90, 1, 91, 1, 91, 1, 92, 3, 92, 1209, 8, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1214, 8, 92, 1, 92, 1, 92, 3, 92, 1218, 8, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 3, 95, 1231, 8, 95, 1, 95, 1, 95, 1, 96, 1, 96, 3, 96, 1237, 8, 96, 1, 96, 1, 96, 3, 96, 1241, 8, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1247, 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1252, 8, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1267, 8, 99, 1, 99, 1, 99, 3, 99, 1271, 8, 99, 1, 100, 4, 100, 1274, 8, 100, 11, 100, 12, 100, 1275, 1, 101, 1, 101, 1, 101, 3, 101, 1281, 8, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1286, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1292, 8, 102, 1, 102, 3, 102, 1295, 8, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 5, 103, 1302, 8, 103, 10, 103, 12, 103, 1305, 9, 103, 1, 103, 3, 103, 1308, 8, 103, 1, 104, 1, 104, 1, 104, 3, 104, 1313, 8, 104, 1, 104, 1, 104, 3, 104, 1317, 8, 104, 1, 105, 1, 105, 1, 106, 1, 106, 3, 106, 1323, 8, 106, 1, 106, 1, 106, 1, 107, 4, 107, 1328, 8, 107, 11, 107, 12, 107, 1329, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 4, 108, 1345, 8, 108, 11, 108, 12, 108, 1346, 3, 108, 1349, 8, 108, 1, 109, 1, 109, 1, 109, 5, 109, 1354, 8, 109, 10, 109, 12, 109, 1357, 9, 109, 1, 110, 1, 110, 3, 110, 1361, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 1368, 8, 111, 1, 112, 1, 112, 3, 112, 1372, 8, 112, 5, 112, 1374, 8, 112, 10, 112, 12, 112, 1377, 9, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 3, 113, 1384, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1390, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1396, 8, 113, 1, 113, 1, 113, 3, 113, 1400, 8, 113, 3, 113, 1402, 8, 113, 5, 113, 1404, 8, 113, 10, 113, 12, 113, 1407, 9, 113, 1, 114, 1, 114, 3, 114, 1411, 8, 114, 1, 114, 1, 114, 3, 114, 1415, 8, 114, 1, 114, 3, 114, 1418, 8, 114, 1, 114, 3, 114, 1421, 8, 114, 1, 114, 3, 114, 1424, 8, 114, 1, 115, 1, 115, 1, 115, 3, 115, 1429, 8, 115, 1, 116, 1, 116, 3, 116, 1433, 8, 116, 1, 116, 3, 116, 1436, 8, 116, 1, 116, 1, 116, 3, 116, 1440, 8, 116, 1, 116, 3, 116, 1443, 8, 116, 3, 116, 1445, 8, 116, 1, 117, 4, 117, 1448, 8, 117, 11, 117, 12, 117, 1449, 1, 118, 1, 118, 1, 119, 1, 119, 1, 120, 3, 120, 1457, 8, 120, 1, 120, 1, 120, 1, 121, 1, 121, 3, 121, 1463, 8, 121, 1, 122, 1, 122, 3, 122, 1467, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1473, 8, 122, 1, 123, 1, 123, 4, 123, 1477, 8, 123, 11, 123, 12, 123, 1478, 1, 123, 3, 123, 1482, 8, 123, 3, 123, 1484, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1490, 8, 124, 1, 124, 1, 124, 3, 124, 1494, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1500, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1507, 8, 124, 1, 124, 1, 124, 3, 124, 1511, 8, 124, 3, 124, 1513, 8, 124, 5, 124, 1515, 8, 124, 10, 124, 12, 124, 1518, 9, 124, 1, 125, 5, 125, 1521, 8, 125, 10, 125, 12, 125, 1524, 9, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 1535, 8, 126, 1, 126, 1, 126, 3, 126, 1539, 8, 126, 3, 126, 1541, 8, 126, 5, 126, 1543, 8, 126, 10, 126, 12, 126, 1546, 9, 126, 1, 127, 1, 127, 3, 127, 1550, 8, 127, 1, 127, 3, 127, 1553, 8, 127, 1, 128, 1, 128, 1, 128, 5, 128, 1558, 8, 128, 10, 128, 12, 128, 1561, 9, 128, 1, 129, 3, 129, 1564, 8, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1569, 8, 129, 3, 129, 1571, 8, 129, 1, 129, 1, 129, 3, 129, 1575, 8, 129, 1, 130, 3, 130, 1578, 8, 130, 1, 130, 3, 130, 1581, 8, 130, 1, 130, 1, 130, 3, 130, 1585, 8, 130, 1, 130, 1, 130, 1, 131, 3, 131, 1590, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1597, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1604, 8, 132, 1, 133, 1, 133, 1, 133, 3, 133, 1609, 8, 133, 1, 134, 1, 134, 3, 134, 1613, 8, 134, 1, 135, 1, 135, 3, 135, 1617, 8, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1622, 8, 135, 5, 135, 1624, 8, 135, 10, 135, 12, 135, 1627, 9, 135, 1, 136, 1, 136, 1, 136, 3, 136, 1632, 8, 136, 3, 136, 1634, 8, 136, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 1640, 8, 137, 1, 138, 1, 138, 1, 138, 3, 138, 1645, 8, 138, 1, 138, 1, 138, 1, 139, 1, 139, 3, 139, 1651, 8, 139, 1, 139, 1, 139, 3, 139, 1655, 8, 139, 3, 139, 1657, 8, 139, 1, 139, 3, 139, 1660, 8, 139, 1, 139, 1, 139, 3, 139, 1664, 8, 139, 1, 139, 1, 139, 3, 139, 1668, 8, 139, 3, 139, 1670, 8, 139, 3, 139, 1672, 8, 139, 1, 140, 3, 140, 1675, 8, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 4, 143, 1687, 8, 143, 11, 143, 12, 143, 1688, 1, 144, 3, 144, 1692, 8, 144, 1, 144, 3, 144, 1695, 8, 144, 1, 144, 3, 144, 1698, 8, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1707, 8, 144, 1, 145, 1, 145, 1, 145, 5, 145, 1712, 8, 145, 10, 145, 12, 145, 1715, 9, 145, 1, 146, 1, 146, 3, 146, 1719, 8, 146, 1, 146, 3, 146, 1722, 8, 146, 1, 146, 3, 146, 1725, 8, 146, 3, 146, 1727, 8, 146, 1, 146, 3, 146, 1730, 8, 146, 1, 146, 3, 146, 1733, 8, 146, 1, 146, 1, 146, 3, 146, 1737, 8, 146, 1, 147, 4, 147, 1740, 8, 147, 11, 147, 12, 147, 1741, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 3, 151, 1755, 8, 151, 1, 151, 1, 151, 1, 151, 3, 151, 1760, 8, 151, 5, 151, 1762, 8, 151, 10, 151, 12, 151, 1765, 9, 151, 1, 152, 3, 152, 1768, 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 1773, 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 1778, 8, 152, 1, 152, 1, 152, 3, 152, 1782, 8, 152, 1, 153, 3, 153, 1785, 8, 153, 1, 153, 1, 153, 3, 153, 1789, 8, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 3, 157, 1800, 8, 157, 1, 158, 1, 158, 3, 158, 1804, 8, 158, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 3, 160, 1811, 8, 160, 1, 160, 1, 160, 1, 160, 3, 160, 1816, 8, 160, 5, 160, 1818, 8, 160, 10, 160, 12, 160, 1821, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 1826, 8, 161, 1, 161, 1, 161, 3, 161, 1830, 8, 161, 1, 162, 1, 162, 3, 162, 1834, 8, 162, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, 1843, 8, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 5, 166, 1854, 8, 166, 10, 166, 12, 166, 1857, 9, 166, 1, 167, 1, 167, 3, 167, 1861, 8, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 1868, 8, 168, 1, 168, 1, 168, 3, 168, 1872, 8, 168, 1, 168, 3, 168, 1875, 8, 168, 1, 168, 3, 168, 1878, 8, 168, 1, 168, 3, 168, 1881, 8, 168, 1, 168, 1, 168, 3, 168, 1885, 8, 168, 1, 169, 1, 169, 1, 169, 3, 169, 1890, 8, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 3, 170, 1897, 8, 170, 1, 170, 1, 170, 3, 170, 1901, 8, 170, 1, 170, 1, 170, 3, 170, 1905, 8, 170, 1, 171, 1, 171, 1, 172, 1, 172, 3, 172, 1911, 8, 172, 1, 172, 1, 172, 1, 172, 3, 172, 1916, 8, 172, 5, 172, 1918, 8, 172, 10, 172, 12, 172, 1921, 9, 172, 1, 173, 1, 173, 1, 173, 3, 173, 1926, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 1932, 8, 174, 1, 174, 3, 174, 1935, 8, 174, 1, 175, 3, 175, 1938, 8, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 3, 178, 1954, 8, 178, 1, 178, 1, 178, 1, 178, 1, 179, 4, 179, 1960, 8, 179, 11, 179, 12, 179, 1961, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 3, 181, 1971, 8, 181, 1, 181, 1, 181, 1, 181, 3, 181, 1976, 8, 181, 1, 181, 3, 181, 1979, 8, 181, 1, 182, 1, 182, 3, 182, 1983, 8, 182, 1, 183, 1, 183, 3, 183, 1987, 8, 183, 1, 184, 1, 184, 1, 184, 3, 184, 1992, 8, 184, 1, 184, 1, 184, 1, 185, 1, 185, 3, 185, 1998, 8, 185, 1, 185, 1, 185, 1, 185, 3, 185, 2003, 8, 185, 5, 185, 2005, 8, 185, 10, 185, 12, 185, 2008, 9, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 2016, 8, 186, 1, 187, 1, 187, 1, 187, 3, 187, 2021, 8, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2026, 8, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2071, 8, 187, 1, 188, 1, 188, 1, 188, 0, 6, 10, 30, 50, 226, 248, 252, 189, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 0, 21, 2, 0, 97, 97, 101, 101, 4, 0, 24, 24, 31, 31, 58, 58, 65, 65, 2, 0, 124, 124, 129, 129, 1, 0, 120, 121, 2, 0, 91, 93, 97, 100, 2, 0, 123, 123, 130, 130, 1, 0, 93, 95, 1, 0, 91, 92, 2, 0, 102, 103, 116, 117, 1, 0, 114, 115, 2, 0, 101, 101, 104, 113, 5, 0, 36, 36, 47, 47, 57, 57, 63, 63, 70, 70, 3, 0, 34, 34, 44, 44, 80, 80, 2, 0, 21, 21, 66, 66, 1, 0, 85, 90, 2, 0, 97, 97, 118, 118, 2, 0, 22, 22, 82, 82, 1, 0, 27, 28, 2, 0, 38, 38, 53, 53, 1, 0, 54, 56, 1, 0, 1, 7, 2305, 0, 379, 1, 0, 0, 0, 2, 395, 1, 0, 0, 0, 4, 399, 1, 0, 0, 0, 6, 411, 1, 0, 0, 0, 8, 413, 1, 0, 0, 0, 10, 419, 1, 0, 0, 0, 12, 441, 1, 0, 0, 0, 14, 447, 1, 0, 0, 0, 16, 459, 1, 0, 0, 0, 18, 461, 1, 0, 0, 0, 20, 463, 1, 0, 0, 0, 22, 476, 1, 0, 0, 0, 24, 483, 1, 0, 0, 0, 26, 486, 1, 0, 0, 0, 28, 491, 1, 0, 0, 0, 30, 538, 1, 0, 0, 0, 32, 570, 1, 0, 0, 0, 34, 572, 1, 0, 0, 0, 36, 593, 1, 0, 0, 0, 38, 622, 1, 0, 0, 0, 40, 624, 1, 0, 0, 0, 42, 627, 1, 0, 0, 0, 44, 643, 1, 0, 0, 0, 46, 647, 1, 0, 0, 0, 48, 656, 1, 0, 0, 0, 50, 658, 1, 0, 0, 0, 52, 683, 1, 0, 0, 0, 54, 686, 1, 0, 0, 0, 56, 695, 1, 0, 0, 0, 58, 706, 1, 0, 0, 0, 60, 708, 1, 0, 0, 0, 62, 716, 1, 0, 0, 0, 64, 724, 1, 0, 0, 0, 66, 732, 1, 0, 0, 0, 68, 745, 1, 0, 0, 0, 70, 747, 1, 0, 0, 0, 72, 755, 1, 0, 0, 0, 74, 763, 1, 0, 0, 0, 76, 771, 1, 0, 0, 0, 78, 779, 1, 0, 0, 0, 80, 787, 1, 0, 0, 0, 82, 795, 1, 0, 0, 0, 84, 803, 1, 0, 0, 0, 86, 817, 1, 0, 0, 0, 88, 819, 1, 0, 0, 0, 90, 821, 1, 0, 0, 0, 92, 829, 1, 0, 0, 0, 94, 844, 1, 0, 0, 0, 96, 847, 1, 0, 0, 0, 98, 859, 1, 0, 0, 0, 100, 863, 1, 0, 0, 0, 102, 870, 1, 0, 0, 0, 104, 889, 1, 0, 0, 0, 106, 902, 1, 0, 0, 0, 108, 937, 1, 0, 0, 0, 110, 941, 1, 0, 0, 0, 112, 944, 1, 0, 0, 0, 114, 951, 1, 0, 0, 0, 116, 962, 1, 0, 0, 0, 118, 966, 1, 0, 0, 0, 120, 969, 1, 0, 0, 0, 122, 982, 1, 0, 0, 0, 124, 992, 1, 0, 0, 0, 126, 994, 1, 0, 0, 0, 128, 1017, 1, 0, 0, 0, 130, 1019, 1, 0, 0, 0, 132, 1027, 1, 0, 0, 0, 134, 1029, 1, 0, 0, 0, 136, 1038, 1, 0, 0, 0, 138, 1041, 1, 0, 0, 0, 140, 1048, 1, 0, 0, 0, 142, 1050, 1, 0, 0, 0, 144, 1052, 1, 0, 0, 0, 146, 1057, 1, 0, 0, 0, 148, 1063, 1, 0, 0, 0, 150, 1066, 1, 0, 0, 0, 152, 1074, 1, 0, 0, 0, 154, 1104, 1, 0, 0, 0, 156, 1110, 1, 0, 0, 0, 158, 1112, 1, 0, 0, 0, 160, 1142, 1, 0, 0, 0, 162, 1144, 1, 0, 0, 0, 164, 1146, 1, 0, 0, 0, 166, 1156, 1, 0, 0, 0, 168, 1169, 1, 0, 0, 0, 170, 1179, 1, 0, 0, 0, 172, 1183, 1, 0, 0, 0, 174, 1186, 1, 0, 0, 0, 176, 1194, 1, 0, 0, 0, 178, 1199, 1, 0, 0, 0, 180, 1203, 1, 0, 0, 0, 182, 1205, 1, 0, 0, 0, 184, 1208, 1, 0, 0, 0, 186, 1221, 1, 0, 0, 0, 188, 1223, 1, 0, 0, 0, 190, 1230, 1, 0, 0, 0, 192, 1234, 1, 0, 0, 0, 194, 1246, 1, 0, 0, 0, 196, 1256, 1, 0, 0, 0, 198, 1262, 1, 0, 0, 0, 200, 1273, 1, 0, 0, 0, 202, 1285, 1, 0, 0, 0, 204, 1287, 1, 0, 0, 0, 206, 1298, 1, 0, 0, 0, 208, 1312, 1, 0, 0, 0, 210, 1318, 1, 0, 0, 0, 212, 1320, 1, 0, 0, 0, 214, 1327, 1, 0, 0, 0, 216, 1348, 1, 0, 0, 0, 218, 1350, 1, 0, 0, 0, 220, 1358, 1, 0, 0, 0, 222, 1367, 1, 0, 0, 0, 224, 1375, 1, 0, 0, 0, 226, 1389, 1, 0, 0, 0, 228, 1408, 1, 0, 0, 0, 230, 1425, 1, 0, 0, 0, 232, 1444, 1, 0, 0, 0, 234, 1447, 1, 0, 0, 0, 236, 1451, 1, 0, 0, 0, 238, 1453, 1, 0, 0, 0, 240, 1456, 1, 0, 0, 0, 242, 1460, 1, 0, 0, 0, 244, 1472, 1, 0, 0, 0, 246, 1483, 1, 0, 0, 0, 248, 1499, 1, 0, 0, 0, 250, 1522, 1, 0, 0, 0, 252, 1527, 1, 0, 0, 0, 254, 1547, 1, 0, 0, 0, 256, 1554, 1, 0, 0, 0, 258, 1563, 1, 0, 0, 0, 260, 1577, 1, 0, 0, 0, 262, 1596, 1, 0, 0, 0, 264, 1603, 1, 0, 0, 0, 266, 1608, 1, 0, 0, 0, 268, 1612, 1, 0, 0, 0, 270, 1614, 1, 0, 0, 0, 272, 1628, 1, 0, 0, 0, 274, 1639, 1, 0, 0, 0, 276, 1641, 1, 0, 0, 0, 278, 1671, 1, 0, 0, 0, 280, 1674, 1, 0, 0, 0, 282, 1678, 1, 0, 0, 0, 284, 1680, 1, 0, 0, 0, 286, 1686, 1, 0, 0, 0, 288, 1706, 1, 0, 0, 0, 290, 1708, 1, 0, 0, 0, 292, 1736, 1, 0, 0, 0, 294, 1739, 1, 0, 0, 0, 296, 1743, 1, 0, 0, 0, 298, 1745, 1, 0, 0, 0, 300, 1749, 1, 0, 0, 0, 302, 1752, 1, 0, 0, 0, 304, 1767, 1, 0, 0, 0, 306, 1788, 1, 0, 0, 0, 308, 1790, 1, 0, 0, 0, 310, 1792, 1, 0, 0, 0, 312, 1794, 1, 0, 0, 0, 314, 1797, 1, 0, 0, 0, 316, 1801, 1, 0, 0, 0, 318, 1805, 1, 0, 0, 0, 320, 1808, 1, 0, 0, 0, 322, 1822, 1, 0, 0, 0, 324, 1833, 1, 0, 0, 0, 326, 1835, 1, 0, 0, 0, 328, 1838, 1, 0, 0, 0, 330, 1844, 1, 0, 0, 0, 332, 1850, 1, 0, 0, 0, 334, 1860, 1, 0, 0, 0, 336, 1871, 1, 0, 0, 0, 338, 1886, 1, 0, 0, 0, 340, 1904, 1, 0, 0, 0, 342, 1906, 1, 0, 0, 0, 344, 1908, 1, 0, 0, 0, 346, 1925, 1, 0, 0, 0, 348, 1927, 1, 0, 0, 0, 350, 1937, 1, 0, 0, 0, 352, 1942, 1, 0, 0, 0, 354, 1947, 1, 0, 0, 0, 356, 1951, 1, 0, 0, 0, 358, 1959, 1, 0, 0, 0, 360, 1963, 1, 0, 0, 0, 362, 1978, 1, 0, 0, 0, 364, 1980, 1, 0, 0, 0, 366, 1986, 1, 0, 0, 0, 368, 1988, 1, 0, 0, 0, 370, 1995, 1, 0, 0, 0, 372, 2015, 1, 0, 0, 0, 374, 2070, 1, 0, 0, 0, 376, 2072, 1, 0, 0, 0, 378, 380, 3, 120, 60, 0, 379, 378, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 381, 1, 0, 0, 0, 381, 382, 5, 0, 0, 1, 382, 1, 1, 0, 0, 0, 383, 385, 3, 376, 188, 0, 384, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 384, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 396, 1, 0, 0, 0, 388, 396, 5, 69, 0, 0, 389, 390, 5, 85, 0, 0, 390, 391, 3, 90, 45, 0, 391, 392, 5, 86, 0, 0, 392, 396, 1, 0, 0, 0, 393, 396, 3, 4, 2, 0, 394, 396, 3, 12, 6, 0, 395, 384, 1, 0, 0, 0, 395, 388, 1, 0, 0, 0, 395, 389, 1, 0, 0, 0, 395, 393, 1, 0, 0, 0, 395, 394, 1, 0, 0, 0, 396, 3, 1, 0, 0, 0, 397, 400, 3, 6, 3, 0, 398, 400, 3, 8, 4, 0, 399, 397, 1, 0, 0, 0, 399, 398, 1, 0, 0, 0, 400, 5, 1, 0, 0, 0, 401, 412, 5, 132, 0, 0, 402, 412, 3, 326, 163, 0, 403, 412, 3, 312, 156, 0, 404, 412, 3, 328, 164, 0, 405, 408, 5, 99, 0, 0, 406, 409, 3, 274, 137, 0, 407, 409, 3, 158, 79, 0, 408, 406, 1, 0, 0, 0, 408, 407, 1, 0, 0, 0, 409, 412, 1, 0, 0, 0, 410, 412, 3, 340, 170, 0, 411, 401, 1, 0, 0, 0, 411, 402, 1, 0, 0, 0, 411, 403, 1, 0, 0, 0, 411, 404, 1, 0, 0, 0, 411, 405, 1, 0, 0, 0, 411, 410, 1, 0, 0, 0, 412, 7, 1, 0, 0, 0, 413, 415, 3, 10, 5, 0, 414, 416, 5, 68, 0, 0, 415, 414, 1, 0, 0, 0, 415, 416, 1, 0, 0, 0, 416, 417, 1, 0, 0, 0, 417, 418, 3, 6, 3, 0, 418, 9, 1, 0, 0, 0, 419, 423, 6, 5, -1, 0, 420, 424, 3, 156, 78, 0, 421, 424, 3, 180, 90, 0, 422, 424, 3, 158, 79, 0, 423, 420, 1, 0, 0, 0, 423, 421, 1, 0, 0, 0, 423, 422, 1, 0, 0, 0, 423, 424, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 426, 5, 127, 0, 0, 426, 438, 1, 0, 0, 0, 427, 433, 10, 1, 0, 0, 428, 434, 5, 132, 0, 0, 429, 431, 5, 68, 0, 0, 430, 429, 1, 0, 0, 0, 430, 431, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 434, 3, 338, 169, 0, 433, 428, 1, 0, 0, 0, 433, 430, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 437, 5, 127, 0, 0, 436, 427, 1, 0, 0, 0, 437, 440, 1, 0, 0, 0, 438, 436, 1, 0, 0, 0, 438, 439, 1, 0, 0, 0, 439, 11, 1, 0, 0, 0, 440, 438, 1, 0, 0, 0, 441, 443, 3, 14, 7, 0, 442, 444, 3, 28, 14, 0, 443, 442, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 445, 1, 0, 0, 0, 445, 446, 3, 100, 50, 0, 446, 13, 1, 0, 0, 0, 447, 449, 5, 87, 0, 0, 448, 450, 3, 16, 8, 0, 449, 448, 1, 0, 0, 0, 449, 450, 1, 0, 0, 0, 450, 451, 1, 0, 0, 0, 451, 452, 5, 88, 0, 0, 452, 15, 1, 0, 0, 0, 453, 460, 3, 20, 10, 0, 454, 457, 3, 18, 9, 0, 455, 456, 5, 122, 0, 0, 456, 458, 3, 20, 10, 0, 457, 455, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 460, 1, 0, 0, 0, 459, 453, 1, 0, 0, 0, 459, 454, 1, 0, 0, 0, 460, 17, 1, 0, 0, 0, 461, 462, 7, 0, 0, 0, 462, 19, 1, 0, 0, 0, 463, 468, 3, 22, 11, 0, 464, 465, 5, 122, 0, 0, 465, 467, 3, 22, 11, 0, 466, 464, 1, 0, 0, 0, 467, 470, 1, 0, 0, 0, 468, 466, 1, 0, 0, 0, 468, 469, 1, 0, 0, 0, 469, 472, 1, 0, 0, 0, 470, 468, 1, 0, 0, 0, 471, 473, 5, 131, 0, 0, 472, 471, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 473, 21, 1, 0, 0, 0, 474, 477, 3, 24, 12, 0, 475, 477, 3, 26, 13, 0, 476, 474, 1, 0, 0, 0, 476, 475, 1, 0, 0, 0, 477, 23, 1, 0, 0, 0, 478, 480, 5, 97, 0, 0, 479, 478, 1, 0, 0, 0, 479, 480, 1, 0, 0, 0, 480, 481, 1, 0, 0, 0, 481, 484, 5, 132, 0, 0, 482, 484, 5, 69, 0, 0, 483, 479, 1, 0, 0, 0, 483, 482, 1, 0, 0, 0, 484, 25, 1, 0, 0, 0, 485, 487, 5, 97, 0, 0, 486, 485, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 488, 1, 0, 0, 0, 488, 489, 5, 132, 0, 0, 489, 490, 3, 264, 132, 0, 490, 27, 1, 0, 0, 0, 491, 493, 5, 85, 0, 0, 492, 494, 3, 254, 127, 0, 493, 492, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 497, 5, 86, 0, 0, 496, 498, 5, 47, 0, 0, 497, 496, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, 499, 501, 3, 366, 183, 0, 500, 499, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501, 503, 1, 0, 0, 0, 502, 504, 3, 200, 100, 0, 503, 502, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 506, 1, 0, 0, 0, 505, 507, 3, 230, 115, 0, 506, 505, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 29, 1, 0, 0, 0, 508, 509, 6, 15, -1, 0, 509, 539, 3, 2, 1, 0, 510, 513, 3, 154, 77, 0, 511, 513, 3, 348, 174, 0, 512, 510, 1, 0, 0, 0, 512, 511, 1, 0, 0, 0, 513, 520, 1, 0, 0, 0, 514, 516, 5, 85, 0, 0, 515, 517, 3, 34, 17, 0, 516, 515, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 521, 5, 86, 0, 0, 519, 521, 3, 272, 136, 0, 520, 514, 1, 0, 0, 0, 520, 519, 1, 0, 0, 0, 521, 539, 1, 0, 0, 0, 522, 523, 7, 1, 0, 0, 523, 524, 5, 102, 0, 0, 524, 525, 3, 242, 121, 0, 525, 526, 5, 103, 0, 0, 526, 527, 5, 85, 0, 0, 527, 528, 3, 90, 45, 0, 528, 529, 5, 86, 0, 0, 529, 539, 1, 0, 0, 0, 530, 531, 3, 32, 16, 0, 531, 534, 5, 85, 0, 0, 532, 535, 3, 90, 45, 0, 533, 535, 3, 242, 121, 0, 534, 532, 1, 0, 0, 0, 534, 533, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 537, 5, 86, 0, 0, 537, 539, 1, 0, 0, 0, 538, 508, 1, 0, 0, 0, 538, 512, 1, 0, 0, 0, 538, 522, 1, 0, 0, 0, 538, 530, 1, 0, 0, 0, 539, 567, 1, 0, 0, 0, 540, 541, 10, 7, 0, 0, 541, 544, 5, 87, 0, 0, 542, 545, 3, 90, 45, 0, 543, 545, 3, 272, 136, 0, 544, 542, 1, 0, 0, 0, 544, 543, 1, 0, 0, 0, 545, 546, 1, 0, 0, 0, 546, 547, 5, 88, 0, 0, 547, 566, 1, 0, 0, 0, 548, 549, 10, 6, 0, 0, 549, 551, 5, 85, 0, 0, 550, 552, 3, 34, 17, 0, 551, 550, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 566, 5, 86, 0, 0, 554, 555, 10, 4, 0, 0, 555, 561, 7, 2, 0, 0, 556, 558, 5, 68, 0, 0, 557, 556, 1, 0, 0, 0, 557, 558, 1, 0, 0, 0, 558, 559, 1, 0, 0, 0, 559, 562, 3, 4, 2, 0, 560, 562, 3, 36, 18, 0, 561, 557, 1, 0, 0, 0, 561, 560, 1, 0, 0, 0, 562, 566, 1, 0, 0, 0, 563, 564, 10, 3, 0, 0, 564, 566, 7, 3, 0, 0, 565, 540, 1, 0, 0, 0, 565, 548, 1, 0, 0, 0, 565, 554, 1, 0, 0, 0, 565, 563, 1, 0, 0, 0, 566, 569, 1, 0, 0, 0, 567, 565, 1, 0, 0, 0, 567, 568, 1, 0, 0, 0, 568, 31, 1, 0, 0, 0, 569, 567, 1, 0, 0, 0, 570, 571, 5, 75, 0, 0, 571, 33, 1, 0, 0, 0, 572, 573, 3, 270, 135, 0, 573, 35, 1, 0, 0, 0, 574, 576, 3, 10, 5, 0, 575, 574, 1, 0, 0, 0, 575, 576, 1, 0, 0, 0, 576, 580, 1, 0, 0, 0, 577, 578, 3, 156, 78, 0, 578, 579, 5, 127, 0, 0, 579, 581, 1, 0, 0, 0, 580, 577, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 582, 1, 0, 0, 0, 582, 583, 5, 99, 0, 0, 583, 594, 3, 156, 78, 0, 584, 585, 3, 10, 5, 0, 585, 586, 5, 68, 0, 0, 586, 587, 3, 338, 169, 0, 587, 588, 5, 127, 0, 0, 588, 589, 5, 99, 0, 0, 589, 590, 3, 156, 78, 0, 590, 594, 1, 0, 0, 0, 591, 592, 5, 99, 0, 0, 592, 594, 3, 158, 79, 0, 593, 575, 1, 0, 0, 0, 593, 584, 1, 0, 0, 0, 593, 591, 1, 0, 0, 0, 594, 37, 1, 0, 0, 0, 595, 623, 3, 30, 15, 0, 596, 601, 5, 120, 0, 0, 597, 601, 5, 121, 0, 0, 598, 601, 3, 40, 20, 0, 599, 601, 5, 62, 0, 0, 600, 596, 1, 0, 0, 0, 600, 597, 1, 0, 0, 0, 600, 598, 1, 0, 0, 0, 600, 599, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 623, 3, 38, 19, 0, 603, 612, 5, 62, 0, 0, 604, 605, 5, 85, 0, 0, 605, 606, 3, 242, 121, 0, 606, 607, 5, 86, 0, 0, 607, 613, 1, 0, 0, 0, 608, 609, 5, 131, 0, 0, 609, 610, 5, 85, 0, 0, 610, 611, 5, 132, 0, 0, 611, 613, 5, 86, 0, 0, 612, 604, 1, 0, 0, 0, 612, 608, 1, 0, 0, 0, 613, 623, 1, 0, 0, 0, 614, 615, 5, 11, 0, 0, 615, 616, 5, 85, 0, 0, 616, 617, 3, 242, 121, 0, 617, 618, 5, 86, 0, 0, 618, 623, 1, 0, 0, 0, 619, 623, 3, 56, 28, 0, 620, 623, 3, 42, 21, 0, 621, 623, 3, 54, 27, 0, 622, 595, 1, 0, 0, 0, 622, 600, 1, 0, 0, 0, 622, 603, 1, 0, 0, 0, 622, 614, 1, 0, 0, 0, 622, 619, 1, 0, 0, 0, 622, 620, 1, 0, 0, 0, 622, 621, 1, 0, 0, 0, 623, 39, 1, 0, 0, 0, 624, 625, 7, 4, 0, 0, 625, 41, 1, 0, 0, 0, 626, 628, 5, 127, 0, 0, 627, 626, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 629, 1, 0, 0, 0, 629, 631, 5, 49, 0, 0, 630, 632, 3, 44, 22, 0, 631, 630, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 638, 1, 0, 0, 0, 633, 639, 3, 46, 23, 0, 634, 635, 5, 85, 0, 0, 635, 636, 3, 242, 121, 0, 636, 637, 5, 86, 0, 0, 637, 639, 1, 0, 0, 0, 638, 633, 1, 0, 0, 0, 638, 634, 1, 0, 0, 0, 639, 641, 1, 0, 0, 0, 640, 642, 3, 52, 26, 0, 641, 640, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 43, 1, 0, 0, 0, 643, 644, 5, 85, 0, 0, 644, 645, 3, 34, 17, 0, 645, 646, 5, 86, 0, 0, 646, 45, 1, 0, 0, 0, 647, 649, 3, 150, 75, 0, 648, 650, 3, 48, 24, 0, 649, 648, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 47, 1, 0, 0, 0, 651, 653, 3, 232, 116, 0, 652, 654, 3, 48, 24, 0, 653, 652, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 50, 25, 0, 656, 651, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 49, 1, 0, 0, 0, 658, 659, 6, 25, -1, 0, 659, 660, 5, 87, 0, 0, 660, 661, 3, 90, 45, 0, 661, 663, 5, 88, 0, 0, 662, 664, 3, 200, 100, 0, 663, 662, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 674, 1, 0, 0, 0, 665, 666, 10, 1, 0, 0, 666, 667, 5, 87, 0, 0, 667, 668, 3, 92, 46, 0, 668, 670, 5, 88, 0, 0, 669, 671, 3, 200, 100, 0, 670, 669, 1, 0, 0, 0, 670, 671, 1, 0, 0, 0, 671, 673, 1, 0, 0, 0, 672, 665, 1, 0, 0, 0, 673, 676, 1, 0, 0, 0, 674, 672, 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 51, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 677, 679, 5, 85, 0, 0, 678, 680, 3, 34, 17, 0, 679, 678, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 681, 1, 0, 0, 0, 681, 684, 5, 86, 0, 0, 682, 684, 3, 272, 136, 0, 683, 677, 1, 0, 0, 0, 683, 682, 1, 0, 0, 0, 684, 53, 1, 0, 0, 0, 685, 687, 5, 127, 0, 0, 686, 685, 1, 0, 0, 0, 686, 687, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 691, 5, 28, 0, 0, 689, 690, 5, 87, 0, 0, 690, 692, 5, 88, 0, 0, 691, 689, 1, 0, 0, 0, 691, 692, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 694, 3, 58, 29, 0, 694, 55, 1, 0, 0, 0, 695, 696, 5, 50, 0, 0, 696, 697, 5, 85, 0, 0, 697, 698, 3, 90, 45, 0, 698, 699, 5, 86, 0, 0, 699, 57, 1, 0, 0, 0, 700, 707, 3, 38, 19, 0, 701, 702, 5, 85, 0, 0, 702, 703, 3, 242, 121, 0, 703, 704, 5, 86, 0, 0, 704, 705, 3, 58, 29, 0, 705, 707, 1, 0, 0, 0, 706, 700, 1, 0, 0, 0, 706, 701, 1, 0, 0, 0, 707, 59, 1, 0, 0, 0, 708, 713, 3, 58, 29, 0, 709, 710, 7, 5, 0, 0, 710, 712, 3, 58, 29, 0, 711, 709, 1, 0, 0, 0, 712, 715, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 713, 714, 1, 0, 0, 0, 714, 61, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 716, 721, 3, 60, 30, 0, 717, 718, 7, 6, 0, 0, 718, 720, 3, 60, 30, 0, 719, 717, 1, 0, 0, 0, 720, 723, 1, 0, 0, 0, 721, 719, 1, 0, 0, 0, 721, 722, 1, 0, 0, 0, 722, 63, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 724, 729, 3, 62, 31, 0, 725, 726, 7, 7, 0, 0, 726, 728, 3, 62, 31, 0, 727, 725, 1, 0, 0, 0, 728, 731, 1, 0, 0, 0, 729, 727, 1, 0, 0, 0, 729, 730, 1, 0, 0, 0, 730, 65, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 732, 738, 3, 64, 32, 0, 733, 734, 3, 68, 34, 0, 734, 735, 3, 64, 32, 0, 735, 737, 1, 0, 0, 0, 736, 733, 1, 0, 0, 0, 737, 740, 1, 0, 0, 0, 738, 736, 1, 0, 0, 0, 738, 739, 1, 0, 0, 0, 739, 67, 1, 0, 0, 0, 740, 738, 1, 0, 0, 0, 741, 742, 5, 103, 0, 0, 742, 746, 5, 103, 0, 0, 743, 744, 5, 102, 0, 0, 744, 746, 5, 102, 0, 0, 745, 741, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 746, 69, 1, 0, 0, 0, 747, 752, 3, 66, 33, 0, 748, 749, 7, 8, 0, 0, 749, 751, 3, 66, 33, 0, 750, 748, 1, 0, 0, 0, 751, 754, 1, 0, 0, 0, 752, 750, 1, 0, 0, 0, 752, 753, 1, 0, 0, 0, 753, 71, 1, 0, 0, 0, 754, 752, 1, 0, 0, 0, 755, 760, 3, 70, 35, 0, 756, 757, 7, 9, 0, 0, 757, 759, 3, 70, 35, 0, 758, 756, 1, 0, 0, 0, 759, 762, 1, 0, 0, 0, 760, 758, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 73, 1, 0, 0, 0, 762, 760, 1, 0, 0, 0, 763, 768, 3, 72, 36, 0, 764, 765, 5, 97, 0, 0, 765, 767, 3, 72, 36, 0, 766, 764, 1, 0, 0, 0, 767, 770, 1, 0, 0, 0, 768, 766, 1, 0, 0, 0, 768, 769, 1, 0, 0, 0, 769, 75, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 771, 776, 3, 74, 37, 0, 772, 773, 5, 96, 0, 0, 773, 775, 3, 74, 37, 0, 774, 772, 1, 0, 0, 0, 775, 778, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 77, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 784, 3, 76, 38, 0, 780, 781, 5, 98, 0, 0, 781, 783, 3, 76, 38, 0, 782, 780, 1, 0, 0, 0, 783, 786, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, 785, 1, 0, 0, 0, 785, 79, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 792, 3, 78, 39, 0, 788, 789, 5, 118, 0, 0, 789, 791, 3, 78, 39, 0, 790, 788, 1, 0, 0, 0, 791, 794, 1, 0, 0, 0, 792, 790, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 81, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 795, 800, 3, 80, 40, 0, 796, 797, 5, 119, 0, 0, 797, 799, 3, 80, 40, 0, 798, 796, 1, 0, 0, 0, 799, 802, 1, 0, 0, 0, 800, 798, 1, 0, 0, 0, 800, 801, 1, 0, 0, 0, 801, 83, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 803, 809, 3, 82, 41, 0, 804, 805, 5, 125, 0, 0, 805, 806, 3, 90, 45, 0, 806, 807, 5, 126, 0, 0, 807, 808, 3, 86, 43, 0, 808, 810, 1, 0, 0, 0, 809, 804, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 85, 1, 0, 0, 0, 811, 818, 3, 84, 42, 0, 812, 813, 3, 82, 41, 0, 813, 814, 3, 88, 44, 0, 814, 815, 3, 268, 134, 0, 815, 818, 1, 0, 0, 0, 816, 818, 3, 364, 182, 0, 817, 811, 1, 0, 0, 0, 817, 812, 1, 0, 0, 0, 817, 816, 1, 0, 0, 0, 818, 87, 1, 0, 0, 0, 819, 820, 7, 10, 0, 0, 820, 89, 1, 0, 0, 0, 821, 826, 3, 86, 43, 0, 822, 823, 5, 122, 0, 0, 823, 825, 3, 86, 43, 0, 824, 822, 1, 0, 0, 0, 825, 828, 1, 0, 0, 0, 826, 824, 1, 0, 0, 0, 826, 827, 1, 0, 0, 0, 827, 91, 1, 0, 0, 0, 828, 826, 1, 0, 0, 0, 829, 830, 3, 84, 42, 0, 830, 93, 1, 0, 0, 0, 831, 845, 3, 96, 48, 0, 832, 834, 3, 200, 100, 0, 833, 832, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 841, 1, 0, 0, 0, 835, 842, 3, 98, 49, 0, 836, 842, 3, 100, 50, 0, 837, 842, 3, 104, 52, 0, 838, 842, 3, 108, 54, 0, 839, 842, 3, 116, 58, 0, 840, 842, 3, 354, 177, 0, 841, 835, 1, 0, 0, 0, 841, 836, 1, 0, 0, 0, 841, 837, 1, 0, 0, 0, 841, 838, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 841, 840, 1, 0, 0, 0, 842, 845, 1, 0, 0, 0, 843, 845, 3, 118, 59, 0, 844, 831, 1, 0, 0, 0, 844, 833, 1, 0, 0, 0, 844, 843, 1, 0, 0, 0, 845, 95, 1, 0, 0, 0, 846, 848, 3, 200, 100, 0, 847, 846, 1, 0, 0, 0, 847, 848, 1, 0, 0, 0, 848, 853, 1, 0, 0, 0, 849, 854, 5, 132, 0, 0, 850, 851, 5, 16, 0, 0, 851, 854, 3, 92, 46, 0, 852, 854, 5, 27, 0, 0, 853, 849, 1, 0, 0, 0, 853, 850, 1, 0, 0, 0, 853, 852, 1, 0, 0, 0, 854, 855, 1, 0, 0, 0, 855, 856, 5, 126, 0, 0, 856, 857, 3, 94, 47, 0, 857, 97, 1, 0, 0, 0, 858, 860, 3, 90, 45, 0, 859, 858, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 861, 1, 0, 0, 0, 861, 862, 5, 128, 0, 0, 862, 99, 1, 0, 0, 0, 863, 865, 5, 89, 0, 0, 864, 866, 3, 102, 51, 0, 865, 864, 1, 0, 0, 0, 865, 866, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 868, 5, 90, 0, 0, 868, 101, 1, 0, 0, 0, 869, 871, 3, 94, 47, 0, 870, 869, 1, 0, 0, 0, 871, 872, 1, 0, 0, 0, 872, 870, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 103, 1, 0, 0, 0, 874, 875, 5, 43, 0, 0, 875, 876, 5, 85, 0, 0, 876, 877, 3, 106, 53, 0, 877, 878, 5, 86, 0, 0, 878, 881, 3, 94, 47, 0, 879, 880, 5, 32, 0, 0, 880, 882, 3, 94, 47, 0, 881, 879, 1, 0, 0, 0, 881, 882, 1, 0, 0, 0, 882, 890, 1, 0, 0, 0, 883, 884, 5, 67, 0, 0, 884, 885, 5, 85, 0, 0, 885, 886, 3, 106, 53, 0, 886, 887, 5, 86, 0, 0, 887, 888, 3, 94, 47, 0, 888, 890, 1, 0, 0, 0, 889, 874, 1, 0, 0, 0, 889, 883, 1, 0, 0, 0, 890, 105, 1, 0, 0, 0, 891, 903, 3, 90, 45, 0, 892, 894, 3, 200, 100, 0, 893, 892, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 895, 1, 0, 0, 0, 895, 896, 3, 138, 69, 0, 896, 900, 3, 222, 111, 0, 897, 898, 5, 101, 0, 0, 898, 901, 3, 268, 134, 0, 899, 901, 3, 272, 136, 0, 900, 897, 1, 0, 0, 0, 900, 899, 1, 0, 0, 0, 901, 903, 1, 0, 0, 0, 902, 891, 1, 0, 0, 0, 902, 893, 1, 0, 0, 0, 903, 107, 1, 0, 0, 0, 904, 905, 5, 84, 0, 0, 905, 906, 5, 85, 0, 0, 906, 907, 3, 106, 53, 0, 907, 908, 5, 86, 0, 0, 908, 909, 3, 94, 47, 0, 909, 938, 1, 0, 0, 0, 910, 911, 5, 29, 0, 0, 911, 912, 3, 94, 47, 0, 912, 913, 5, 84, 0, 0, 913, 914, 5, 85, 0, 0, 914, 915, 3, 90, 45, 0, 915, 916, 5, 86, 0, 0, 916, 917, 5, 128, 0, 0, 917, 938, 1, 0, 0, 0, 918, 919, 5, 40, 0, 0, 919, 932, 5, 85, 0, 0, 920, 922, 3, 110, 55, 0, 921, 923, 3, 106, 53, 0, 922, 921, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 5, 128, 0, 0, 925, 927, 3, 90, 45, 0, 926, 925, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 933, 1, 0, 0, 0, 928, 929, 3, 112, 56, 0, 929, 930, 5, 126, 0, 0, 930, 931, 3, 114, 57, 0, 931, 933, 1, 0, 0, 0, 932, 920, 1, 0, 0, 0, 932, 928, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 935, 5, 86, 0, 0, 935, 936, 3, 94, 47, 0, 936, 938, 1, 0, 0, 0, 937, 904, 1, 0, 0, 0, 937, 910, 1, 0, 0, 0, 937, 918, 1, 0, 0, 0, 938, 109, 1, 0, 0, 0, 939, 942, 3, 98, 49, 0, 940, 942, 3, 128, 64, 0, 941, 939, 1, 0, 0, 0, 941, 940, 1, 0, 0, 0, 942, 111, 1, 0, 0, 0, 943, 945, 3, 200, 100, 0, 944, 943, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 947, 3, 138, 69, 0, 947, 948, 3, 222, 111, 0, 948, 113, 1, 0, 0, 0, 949, 952, 3, 90, 45, 0, 950, 952, 3, 272, 136, 0, 951, 949, 1, 0, 0, 0, 951, 950, 1, 0, 0, 0, 952, 115, 1, 0, 0, 0, 953, 963, 5, 15, 0, 0, 954, 963, 5, 25, 0, 0, 955, 958, 5, 59, 0, 0, 956, 959, 3, 90, 45, 0, 957, 959, 3, 272, 136, 0, 958, 956, 1, 0, 0, 0, 958, 957, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 963, 1, 0, 0, 0, 960, 961, 5, 42, 0, 0, 961, 963, 5, 132, 0, 0, 962, 953, 1, 0, 0, 0, 962, 954, 1, 0, 0, 0, 962, 955, 1, 0, 0, 0, 962, 960, 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 965, 5, 128, 0, 0, 965, 117, 1, 0, 0, 0, 966, 967, 3, 124, 62, 0, 967, 119, 1, 0, 0, 0, 968, 970, 3, 122, 61, 0, 969, 968, 1, 0, 0, 0, 970, 971, 1, 0, 0, 0, 971, 969, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 121, 1, 0, 0, 0, 973, 983, 3, 124, 62, 0, 974, 983, 3, 260, 130, 0, 975, 983, 3, 330, 165, 0, 976, 983, 3, 350, 175, 0, 977, 983, 3, 352, 176, 0, 978, 983, 3, 198, 99, 0, 979, 983, 3, 184, 92, 0, 980, 983, 3, 132, 66, 0, 981, 983, 3, 134, 67, 0, 982, 973, 1, 0, 0, 0, 982, 974, 1, 0, 0, 0, 982, 975, 1, 0, 0, 0, 982, 976, 1, 0, 0, 0, 982, 977, 1, 0, 0, 0, 982, 978, 1, 0, 0, 0, 982, 979, 1, 0, 0, 0, 982, 980, 1, 0, 0, 0, 982, 981, 1, 0, 0, 0, 983, 123, 1, 0, 0, 0, 984, 993, 3, 128, 64, 0, 985, 993, 3, 196, 98, 0, 986, 993, 3, 188, 94, 0, 987, 993, 3, 192, 96, 0, 988, 993, 3, 194, 97, 0, 989, 993, 3, 130, 65, 0, 990, 993, 3, 126, 63, 0, 991, 993, 3, 168, 84, 0, 992, 984, 1, 0, 0, 0, 992, 985, 1, 0, 0, 0, 992, 986, 1, 0, 0, 0, 992, 987, 1, 0, 0, 0, 992, 988, 1, 0, 0, 0, 992, 989, 1, 0, 0, 0, 992, 990, 1, 0, 0, 0, 992, 991, 1, 0, 0, 0, 993, 125, 1, 0, 0, 0, 994, 995, 5, 79, 0, 0, 995, 997, 5, 132, 0, 0, 996, 998, 3, 200, 100, 0, 997, 996, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 999, 1, 0, 0, 0, 999, 1000, 5, 101, 0, 0, 1000, 1001, 3, 242, 121, 0, 1001, 1002, 5, 128, 0, 0, 1002, 127, 1, 0, 0, 0, 1003, 1005, 3, 138, 69, 0, 1004, 1003, 1, 0, 0, 0, 1004, 1005, 1, 0, 0, 0, 1005, 1007, 1, 0, 0, 0, 1006, 1008, 3, 218, 109, 0, 1007, 1006, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1018, 5, 128, 0, 0, 1010, 1012, 3, 200, 100, 0, 1011, 1013, 3, 138, 69, 0, 1012, 1011, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1014, 1, 0, 0, 0, 1014, 1015, 3, 218, 109, 0, 1015, 1016, 5, 128, 0, 0, 1016, 1018, 1, 0, 0, 0, 1017, 1004, 1, 0, 0, 0, 1017, 1010, 1, 0, 0, 0, 1018, 129, 1, 0, 0, 0, 1019, 1020, 5, 64, 0, 0, 1020, 1021, 5, 85, 0, 0, 1021, 1022, 3, 92, 46, 0, 1022, 1023, 5, 122, 0, 0, 1023, 1024, 5, 4, 0, 0, 1024, 1025, 5, 86, 0, 0, 1025, 1026, 5, 128, 0, 0, 1026, 131, 1, 0, 0, 0, 1027, 1028, 5, 128, 0, 0, 1028, 133, 1, 0, 0, 0, 1029, 1030, 3, 200, 100, 0, 1030, 1031, 5, 128, 0, 0, 1031, 135, 1, 0, 0, 0, 1032, 1039, 3, 140, 70, 0, 1033, 1039, 3, 146, 73, 0, 1034, 1039, 3, 142, 71, 0, 1035, 1039, 5, 41, 0, 0, 1036, 1039, 5, 74, 0, 0, 1037, 1039, 5, 23, 0, 0, 1038, 1032, 1, 0, 0, 0, 1038, 1033, 1, 0, 0, 0, 1038, 1034, 1, 0, 0, 0, 1038, 1035, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1038, 1037, 1, 0, 0, 0, 1039, 137, 1, 0, 0, 0, 1040, 1042, 3, 136, 68, 0, 1041, 1040, 1, 0, 0, 0, 1042, 1043, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1046, 1, 0, 0, 0, 1045, 1047, 3, 200, 100, 0, 1046, 1045, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 139, 1, 0, 0, 0, 1048, 1049, 7, 11, 0, 0, 1049, 141, 1, 0, 0, 0, 1050, 1051, 7, 12, 0, 0, 1051, 143, 1, 0, 0, 0, 1052, 1053, 5, 132, 0, 0, 1053, 145, 1, 0, 0, 0, 1054, 1058, 3, 148, 74, 0, 1055, 1058, 3, 276, 138, 0, 1056, 1058, 3, 164, 82, 0, 1057, 1054, 1, 0, 0, 0, 1057, 1055, 1, 0, 0, 0, 1057, 1056, 1, 0, 0, 0, 1058, 147, 1, 0, 0, 0, 1059, 1064, 3, 154, 77, 0, 1060, 1064, 3, 160, 80, 0, 1061, 1064, 3, 348, 174, 0, 1062, 1064, 3, 236, 118, 0, 1063, 1059, 1, 0, 0, 0, 1063, 1060, 1, 0, 0, 0, 1063, 1061, 1, 0, 0, 0, 1063, 1062, 1, 0, 0, 0, 1064, 149, 1, 0, 0, 0, 1065, 1067, 3, 146, 73, 0, 1066, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1066, 1, 0, 0, 0, 1068, 1069, 1, 0, 0, 0, 1069, 1071, 1, 0, 0, 0, 1070, 1072, 3, 200, 100, 0, 1071, 1070, 1, 0, 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 151, 1, 0, 0, 0, 1073, 1075, 3, 148, 74, 0, 1074, 1073, 1, 0, 0, 0, 1075, 1076, 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1079, 1, 0, 0, 0, 1078, 1080, 3, 200, 100, 0, 1079, 1078, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 153, 1, 0, 0, 0, 1081, 1083, 3, 10, 5, 0, 1082, 1081, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1105, 3, 156, 78, 0, 1085, 1086, 3, 10, 5, 0, 1086, 1087, 5, 68, 0, 0, 1087, 1088, 3, 338, 169, 0, 1088, 1105, 1, 0, 0, 0, 1089, 1105, 5, 18, 0, 0, 1090, 1105, 5, 19, 0, 0, 1091, 1105, 5, 20, 0, 0, 1092, 1105, 5, 83, 0, 0, 1093, 1105, 5, 14, 0, 0, 1094, 1105, 5, 60, 0, 0, 1095, 1105, 5, 45, 0, 0, 1096, 1105, 5, 46, 0, 0, 1097, 1105, 5, 61, 0, 0, 1098, 1105, 5, 78, 0, 0, 1099, 1105, 5, 39, 0, 0, 1100, 1105, 5, 30, 0, 0, 1101, 1105, 5, 81, 0, 0, 1102, 1105, 5, 13, 0, 0, 1103, 1105, 3, 158, 79, 0, 1104, 1082, 1, 0, 0, 0, 1104, 1085, 1, 0, 0, 0, 1104, 1089, 1, 0, 0, 0, 1104, 1090, 1, 0, 0, 0, 1104, 1091, 1, 0, 0, 0, 1104, 1092, 1, 0, 0, 0, 1104, 1093, 1, 0, 0, 0, 1104, 1094, 1, 0, 0, 0, 1104, 1095, 1, 0, 0, 0, 1104, 1096, 1, 0, 0, 0, 1104, 1097, 1, 0, 0, 0, 1104, 1098, 1, 0, 0, 0, 1104, 1099, 1, 0, 0, 0, 1104, 1100, 1, 0, 0, 0, 1104, 1101, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1104, 1103, 1, 0, 0, 0, 1105, 155, 1, 0, 0, 0, 1106, 1111, 3, 274, 137, 0, 1107, 1111, 3, 162, 81, 0, 1108, 1111, 3, 144, 72, 0, 1109, 1111, 3, 338, 169, 0, 1110, 1106, 1, 0, 0, 0, 1110, 1107, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1109, 1, 0, 0, 0, 1111, 157, 1, 0, 0, 0, 1112, 1113, 5, 26, 0, 0, 1113, 1116, 5, 85, 0, 0, 1114, 1117, 3, 90, 45, 0, 1115, 1117, 5, 13, 0, 0, 1116, 1114, 1, 0, 0, 0, 1116, 1115, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1119, 5, 86, 0, 0, 1119, 159, 1, 0, 0, 0, 1120, 1135, 3, 284, 142, 0, 1121, 1123, 3, 200, 100, 0, 1122, 1121, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1125, 1, 0, 0, 0, 1124, 1126, 3, 10, 5, 0, 1125, 1124, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1136, 5, 132, 0, 0, 1128, 1136, 3, 338, 169, 0, 1129, 1131, 3, 10, 5, 0, 1130, 1132, 5, 68, 0, 0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, 1134, 3, 338, 169, 0, 1134, 1136, 1, 0, 0, 0, 1135, 1122, 1, 0, 0, 0, 1135, 1128, 1, 0, 0, 0, 1135, 1129, 1, 0, 0, 0, 1136, 1143, 1, 0, 0, 0, 1137, 1139, 5, 33, 0, 0, 1138, 1140, 3, 10, 5, 0, 1139, 1138, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1143, 5, 132, 0, 0, 1142, 1120, 1, 0, 0, 0, 1142, 1137, 1, 0, 0, 0, 1143, 161, 1, 0, 0, 0, 1144, 1145, 5, 132, 0, 0, 1145, 163, 1, 0, 0, 0, 1146, 1147, 3, 166, 83, 0, 1147, 1152, 5, 89, 0, 0, 1148, 1150, 3, 174, 87, 0, 1149, 1151, 5, 122, 0, 0, 1150, 1149, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1153, 1, 0, 0, 0, 1152, 1148, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1155, 5, 90, 0, 0, 1155, 165, 1, 0, 0, 0, 1156, 1158, 3, 170, 85, 0, 1157, 1159, 3, 200, 100, 0, 1158, 1157, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1164, 1, 0, 0, 0, 1160, 1162, 3, 10, 5, 0, 1161, 1160, 1, 0, 0, 0, 1161, 1162, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1165, 5, 132, 0, 0, 1164, 1161, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1167, 1, 0, 0, 0, 1166, 1168, 3, 172, 86, 0, 1167, 1166, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 167, 1, 0, 0, 0, 1169, 1171, 3, 170, 85, 0, 1170, 1172, 3, 200, 100, 0, 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1173, 1, 0, 0, 0, 1173, 1175, 5, 132, 0, 0, 1174, 1176, 3, 172, 86, 0, 1175, 1174, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1177, 1, 0, 0, 0, 1177, 1178, 5, 128, 0, 0, 1178, 169, 1, 0, 0, 0, 1179, 1181, 5, 33, 0, 0, 1180, 1182, 7, 13, 0, 0, 1181, 1180, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 171, 1, 0, 0, 0, 1183, 1184, 5, 126, 0, 0, 1184, 1185, 3, 150, 75, 0, 1185, 173, 1, 0, 0, 0, 1186, 1191, 3, 176, 88, 0, 1187, 1188, 5, 122, 0, 0, 1188, 1190, 3, 176, 88, 0, 1189, 1187, 1, 0, 0, 0, 1190, 1193, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 175, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1194, 1197, 3, 178, 89, 0, 1195, 1196, 5, 101, 0, 0, 1196, 1198, 3, 92, 46, 0, 1197, 1195, 1, 0, 0, 0, 1197, 1198, 1, 0, 0, 0, 1198, 177, 1, 0, 0, 0, 1199, 1200, 5, 132, 0, 0, 1200, 179, 1, 0, 0, 0, 1201, 1204, 3, 182, 91, 0, 1202, 1204, 3, 186, 93, 0, 1203, 1201, 1, 0, 0, 0, 1203, 1202, 1, 0, 0, 0, 1204, 181, 1, 0, 0, 0, 1205, 1206, 5, 132, 0, 0, 1206, 183, 1, 0, 0, 0, 1207, 1209, 5, 44, 0, 0, 1208, 1207, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 1213, 5, 48, 0, 0, 1211, 1214, 5, 132, 0, 0, 1212, 1214, 3, 182, 91, 0, 1213, 1211, 1, 0, 0, 0, 1213, 1212, 1, 0, 0, 0, 1213, 1214, 1, 0, 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 1217, 5, 89, 0, 0, 1216, 1218, 3, 120, 60, 0, 1217, 1216, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1220, 5, 90, 0, 0, 1220, 185, 1, 0, 0, 0, 1221, 1222, 5, 132, 0, 0, 1222, 187, 1, 0, 0, 0, 1223, 1224, 5, 48, 0, 0, 1224, 1225, 5, 132, 0, 0, 1225, 1226, 5, 101, 0, 0, 1226, 1227, 3, 190, 95, 0, 1227, 1228, 5, 128, 0, 0, 1228, 189, 1, 0, 0, 0, 1229, 1231, 3, 10, 5, 0, 1230, 1229, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 1233, 3, 180, 90, 0, 1233, 191, 1, 0, 0, 0, 1234, 1240, 5, 79, 0, 0, 1235, 1237, 5, 76, 0, 0, 1236, 1235, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 1238, 1, 0, 0, 0, 1238, 1241, 3, 10, 5, 0, 1239, 1241, 5, 127, 0, 0, 1240, 1236, 1, 0, 0, 0, 1240, 1239, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, 0, 1242, 1243, 3, 6, 3, 0, 1243, 1244, 5, 128, 0, 0, 1244, 193, 1, 0, 0, 0, 1245, 1247, 3, 200, 100, 0, 1246, 1245, 1, 0, 0, 0, 1246, 1247, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1249, 5, 79, 0, 0, 1249, 1251, 5, 48, 0, 0, 1250, 1252, 3, 10, 5, 0, 1251, 1250, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1254, 3, 180, 90, 0, 1254, 1255, 5, 128, 0, 0, 1255, 195, 1, 0, 0, 0, 1256, 1257, 5, 12, 0, 0, 1257, 1258, 5, 85, 0, 0, 1258, 1259, 5, 4, 0, 0, 1259, 1260, 5, 86, 0, 0, 1260, 1261, 5, 128, 0, 0, 1261, 197, 1, 0, 0, 0, 1262, 1263, 5, 36, 0, 0, 1263, 1270, 5, 4, 0, 0, 1264, 1266, 5, 89, 0, 0, 1265, 1267, 3, 120, 60, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1271, 5, 90, 0, 0, 1269, 1271, 3, 122, 61, 0, 1270, 1264, 1, 0, 0, 0, 1270, 1269, 1, 0, 0, 0, 1271, 199, 1, 0, 0, 0, 1272, 1274, 3, 202, 101, 0, 1273, 1272, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1273, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 201, 1, 0, 0, 0, 1277, 1278, 5, 87, 0, 0, 1278, 1280, 5, 87, 0, 0, 1279, 1281, 3, 206, 103, 0, 1280, 1279, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 5, 88, 0, 0, 1283, 1286, 5, 88, 0, 0, 1284, 1286, 3, 204, 102, 0, 1285, 1277, 1, 0, 0, 0, 1285, 1284, 1, 0, 0, 0, 1286, 203, 1, 0, 0, 0, 1287, 1288, 5, 10, 0, 0, 1288, 1291, 5, 85, 0, 0, 1289, 1292, 3, 242, 121, 0, 1290, 1292, 3, 92, 46, 0, 1291, 1289, 1, 0, 0, 0, 1291, 1290, 1, 0, 0, 0, 1292, 1294, 1, 0, 0, 0, 1293, 1295, 5, 131, 0, 0, 1294, 1293, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1297, 5, 86, 0, 0, 1297, 205, 1, 0, 0, 0, 1298, 1303, 3, 208, 104, 0, 1299, 1300, 5, 122, 0, 0, 1300, 1302, 3, 208, 104, 0, 1301, 1299, 1, 0, 0, 0, 1302, 1305, 1, 0, 0, 0, 1303, 1301, 1, 0, 0, 0, 1303, 1304, 1, 0, 0, 0, 1304, 1307, 1, 0, 0, 0, 1305, 1303, 1, 0, 0, 0, 1306, 1308, 5, 131, 0, 0, 1307, 1306, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 207, 1, 0, 0, 0, 1309, 1310, 3, 210, 105, 0, 1310, 1311, 5, 127, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1309, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1316, 5, 132, 0, 0, 1315, 1317, 3, 212, 106, 0, 1316, 1315, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 209, 1, 0, 0, 0, 1318, 1319, 5, 132, 0, 0, 1319, 211, 1, 0, 0, 0, 1320, 1322, 5, 85, 0, 0, 1321, 1323, 3, 214, 107, 0, 1322, 1321, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, 1324, 1325, 5, 86, 0, 0, 1325, 213, 1, 0, 0, 0, 1326, 1328, 3, 216, 108, 0, 1327, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1327, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 215, 1, 0, 0, 0, 1331, 1332, 5, 85, 0, 0, 1332, 1333, 3, 214, 107, 0, 1333, 1334, 5, 86, 0, 0, 1334, 1349, 1, 0, 0, 0, 1335, 1336, 5, 87, 0, 0, 1336, 1337, 3, 214, 107, 0, 1337, 1338, 5, 88, 0, 0, 1338, 1349, 1, 0, 0, 0, 1339, 1340, 5, 89, 0, 0, 1340, 1341, 3, 214, 107, 0, 1341, 1342, 5, 90, 0, 0, 1342, 1349, 1, 0, 0, 0, 1343, 1345, 8, 14, 0, 0, 1344, 1343, 1, 0, 0, 0, 1345, 1346, 1, 0, 0, 0, 1346, 1344, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1349, 1, 0, 0, 0, 1348, 1331, 1, 0, 0, 0, 1348, 1335, 1, 0, 0, 0, 1348, 1339, 1, 0, 0, 0, 1348, 1344, 1, 0, 0, 0, 1349, 217, 1, 0, 0, 0, 1350, 1355, 3, 220, 110, 0, 1351, 1352, 5, 122, 0, 0, 1352, 1354, 3, 220, 110, 0, 1353, 1351, 1, 0, 0, 0, 1354, 1357, 1, 0, 0, 0, 1355, 1353, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 219, 1, 0, 0, 0, 1357, 1355, 1, 0, 0, 0, 1358, 1360, 3, 222, 111, 0, 1359, 1361, 3, 264, 132, 0, 1360, 1359, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 221, 1, 0, 0, 0, 1362, 1368, 3, 224, 112, 0, 1363, 1364, 3, 226, 113, 0, 1364, 1365, 3, 228, 114, 0, 1365, 1366, 3, 230, 115, 0, 1366, 1368, 1, 0, 0, 0, 1367, 1362, 1, 0, 0, 0, 1367, 1363, 1, 0, 0, 0, 1368, 223, 1, 0, 0, 0, 1369, 1371, 3, 232, 116, 0, 1370, 1372, 5, 22, 0, 0, 1371, 1370, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, 0, 0, 0, 1373, 1369, 1, 0, 0, 0, 1374, 1377, 1, 0, 0, 0, 1375, 1373, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1378, 1, 0, 0, 0, 1377, 1375, 1, 0, 0, 0, 1378, 1379, 3, 226, 113, 0, 1379, 225, 1, 0, 0, 0, 1380, 1381, 6, 113, -1, 0, 1381, 1383, 3, 240, 120, 0, 1382, 1384, 3, 200, 100, 0, 1383, 1382, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1390, 1, 0, 0, 0, 1385, 1386, 5, 85, 0, 0, 1386, 1387, 3, 224, 112, 0, 1387, 1388, 5, 86, 0, 0, 1388, 1390, 1, 0, 0, 0, 1389, 1380, 1, 0, 0, 0, 1389, 1385, 1, 0, 0, 0, 1390, 1405, 1, 0, 0, 0, 1391, 1401, 10, 2, 0, 0, 1392, 1402, 3, 228, 114, 0, 1393, 1395, 5, 87, 0, 0, 1394, 1396, 3, 92, 46, 0, 1395, 1394, 1, 0, 0, 0, 1395, 1396, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, 1399, 5, 88, 0, 0, 1398, 1400, 3, 200, 100, 0, 1399, 1398, 1, 0, 0, 0, 1399, 1400, 1, 0, 0, 0, 1400, 1402, 1, 0, 0, 0, 1401, 1392, 1, 0, 0, 0, 1401, 1393, 1, 0, 0, 0, 1402, 1404, 1, 0, 0, 0, 1403, 1391, 1, 0, 0, 0, 1404, 1407, 1, 0, 0, 0, 1405, 1403, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 227, 1, 0, 0, 0, 1407, 1405, 1, 0, 0, 0, 1408, 1410, 5, 85, 0, 0, 1409, 1411, 3, 254, 127, 0, 1410, 1409, 1, 0, 0, 0, 1410, 1411, 1, 0, 0, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1414, 5, 86, 0, 0, 1413, 1415, 3, 234, 117, 0, 1414, 1413, 1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1417, 1, 0, 0, 0, 1416, 1418, 3, 238, 119, 0, 1417, 1416, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1420, 1, 0, 0, 0, 1419, 1421, 3, 366, 183, 0, 1420, 1419, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1423, 1, 0, 0, 0, 1422, 1424, 3, 200, 100, 0, 1423, 1422, 1, 0, 0, 0, 1423, 1424, 1, 0, 0, 0, 1424, 229, 1, 0, 0, 0, 1425, 1426, 5, 124, 0, 0, 1426, 1428, 3, 152, 76, 0, 1427, 1429, 3, 244, 122, 0, 1428, 1427, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 231, 1, 0, 0, 0, 1430, 1432, 7, 15, 0, 0, 1431, 1433, 3, 200, 100, 0, 1432, 1431, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1445, 1, 0, 0, 0, 1434, 1436, 3, 10, 5, 0, 1435, 1434, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1437, 1, 0, 0, 0, 1437, 1439, 5, 93, 0, 0, 1438, 1440, 3, 200, 100, 0, 1439, 1438, 1, 0, 0, 0, 1439, 1440, 1, 0, 0, 0, 1440, 1442, 1, 0, 0, 0, 1441, 1443, 3, 234, 117, 0, 1442, 1441, 1, 0, 0, 0, 1442, 1443, 1, 0, 0, 0, 1443, 1445, 1, 0, 0, 0, 1444, 1430, 1, 0, 0, 0, 1444, 1435, 1, 0, 0, 0, 1445, 233, 1, 0, 0, 0, 1446, 1448, 3, 236, 118, 0, 1447, 1446, 1, 0, 0, 0, 1448, 1449, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 235, 1, 0, 0, 0, 1451, 1452, 7, 16, 0, 0, 1452, 237, 1, 0, 0, 0, 1453, 1454, 7, 15, 0, 0, 1454, 239, 1, 0, 0, 0, 1455, 1457, 5, 131, 0, 0, 1456, 1455, 1, 0, 0, 0, 1456, 1457, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 3, 4, 2, 0, 1459, 241, 1, 0, 0, 0, 1460, 1462, 3, 150, 75, 0, 1461, 1463, 3, 244, 122, 0, 1462, 1461, 1, 0, 0, 0, 1462, 1463, 1, 0, 0, 0, 1463, 243, 1, 0, 0, 0, 1464, 1473, 3, 246, 123, 0, 1465, 1467, 3, 248, 124, 0, 1466, 1465, 1, 0, 0, 0, 1466, 1467, 1, 0, 0, 0, 1467, 1468, 1, 0, 0, 0, 1468, 1469, 3, 228, 114, 0, 1469, 1470, 3, 230, 115, 0, 1470, 1473, 1, 0, 0, 0, 1471, 1473, 3, 250, 125, 0, 1472, 1464, 1, 0, 0, 0, 1472, 1466, 1, 0, 0, 0, 1472, 1471, 1, 0, 0, 0, 1473, 245, 1, 0, 0, 0, 1474, 1484, 3, 248, 124, 0, 1475, 1477, 3, 232, 116, 0, 1476, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1481, 1, 0, 0, 0, 1480, 1482, 3, 248, 124, 0, 1481, 1480, 1, 0, 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 1484, 1, 0, 0, 0, 1483, 1474, 1, 0, 0, 0, 1483, 1476, 1, 0, 0, 0, 1484, 247, 1, 0, 0, 0, 1485, 1486, 6, 124, -1, 0, 1486, 1500, 3, 228, 114, 0, 1487, 1489, 5, 87, 0, 0, 1488, 1490, 3, 92, 46, 0, 1489, 1488, 1, 0, 0, 0, 1489, 1490, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1493, 5, 88, 0, 0, 1492, 1494, 3, 200, 100, 0, 1493, 1492, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1500, 1, 0, 0, 0, 1495, 1496, 5, 85, 0, 0, 1496, 1497, 3, 246, 123, 0, 1497, 1498, 5, 86, 0, 0, 1498, 1500, 1, 0, 0, 0, 1499, 1485, 1, 0, 0, 0, 1499, 1487, 1, 0, 0, 0, 1499, 1495, 1, 0, 0, 0, 1500, 1516, 1, 0, 0, 0, 1501, 1512, 10, 4, 0, 0, 1502, 1513, 3, 228, 114, 0, 1503, 1504, 3, 248, 124, 0, 1504, 1506, 5, 87, 0, 0, 1505, 1507, 3, 92, 46, 0, 1506, 1505, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 5, 88, 0, 0, 1509, 1511, 3, 200, 100, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1513, 1, 0, 0, 0, 1512, 1502, 1, 0, 0, 0, 1512, 1503, 1, 0, 0, 0, 1513, 1515, 1, 0, 0, 0, 1514, 1501, 1, 0, 0, 0, 1515, 1518, 1, 0, 0, 0, 1516, 1514, 1, 0, 0, 0, 1516, 1517, 1, 0, 0, 0, 1517, 249, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1519, 1521, 3, 232, 116, 0, 1520, 1519, 1, 0, 0, 0, 1521, 1524, 1, 0, 0, 0, 1522, 1520, 1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1522, 1, 0, 0, 0, 1525, 1526, 3, 252, 126, 0, 1526, 251, 1, 0, 0, 0, 1527, 1528, 6, 126, -1, 0, 1528, 1529, 5, 131, 0, 0, 1529, 1544, 1, 0, 0, 0, 1530, 1540, 10, 2, 0, 0, 1531, 1541, 3, 228, 114, 0, 1532, 1534, 5, 87, 0, 0, 1533, 1535, 3, 92, 46, 0, 1534, 1533, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1538, 5, 88, 0, 0, 1537, 1539, 3, 200, 100, 0, 1538, 1537, 1, 0, 0, 0, 1538, 1539, 1, 0, 0, 0, 1539, 1541, 1, 0, 0, 0, 1540, 1531, 1, 0, 0, 0, 1540, 1532, 1, 0, 0, 0, 1541, 1543, 1, 0, 0, 0, 1542, 1530, 1, 0, 0, 0, 1543, 1546, 1, 0, 0, 0, 1544, 1542, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 253, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, 0, 1547, 1552, 3, 256, 128, 0, 1548, 1550, 5, 122, 0, 0, 1549, 1548, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 1553, 5, 131, 0, 0, 1552, 1549, 1, 0, 0, 0, 1552, 1553, 1, 0, 0, 0, 1553, 255, 1, 0, 0, 0, 1554, 1559, 3, 258, 129, 0, 1555, 1556, 5, 122, 0, 0, 1556, 1558, 3, 258, 129, 0, 1557, 1555, 1, 0, 0, 0, 1558, 1561, 1, 0, 0, 0, 1559, 1557, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 257, 1, 0, 0, 0, 1561, 1559, 1, 0, 0, 0, 1562, 1564, 3, 200, 100, 0, 1563, 1562, 1, 0, 0, 0, 1563, 1564, 1, 0, 0, 0, 1564, 1565, 1, 0, 0, 0, 1565, 1570, 3, 138, 69, 0, 1566, 1571, 3, 222, 111, 0, 1567, 1569, 3, 244, 122, 0, 1568, 1567, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1571, 1, 0, 0, 0, 1570, 1566, 1, 0, 0, 0, 1570, 1568, 1, 0, 0, 0, 1571, 1574, 1, 0, 0, 0, 1572, 1573, 5, 101, 0, 0, 1573, 1575, 3, 268, 134, 0, 1574, 1572, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 259, 1, 0, 0, 0, 1576, 1578, 3, 200, 100, 0, 1577, 1576, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1580, 1, 0, 0, 0, 1579, 1581, 3, 138, 69, 0, 1580, 1579, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1582, 1, 0, 0, 0, 1582, 1584, 3, 222, 111, 0, 1583, 1585, 3, 294, 147, 0, 1584, 1583, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 1, 0, 0, 0, 1586, 1587, 3, 262, 131, 0, 1587, 261, 1, 0, 0, 0, 1588, 1590, 3, 318, 159, 0, 1589, 1588, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 1597, 3, 100, 50, 0, 1592, 1597, 3, 356, 178, 0, 1593, 1594, 5, 101, 0, 0, 1594, 1595, 7, 17, 0, 0, 1595, 1597, 5, 128, 0, 0, 1596, 1589, 1, 0, 0, 0, 1596, 1592, 1, 0, 0, 0, 1596, 1593, 1, 0, 0, 0, 1597, 263, 1, 0, 0, 0, 1598, 1604, 3, 266, 133, 0, 1599, 1600, 5, 85, 0, 0, 1600, 1601, 3, 34, 17, 0, 1601, 1602, 5, 86, 0, 0, 1602, 1604, 1, 0, 0, 0, 1603, 1598, 1, 0, 0, 0, 1603, 1599, 1, 0, 0, 0, 1604, 265, 1, 0, 0, 0, 1605, 1606, 5, 101, 0, 0, 1606, 1609, 3, 268, 134, 0, 1607, 1609, 3, 272, 136, 0, 1608, 1605, 1, 0, 0, 0, 1608, 1607, 1, 0, 0, 0, 1609, 267, 1, 0, 0, 0, 1610, 1613, 3, 86, 43, 0, 1611, 1613, 3, 272, 136, 0, 1612, 1610, 1, 0, 0, 0, 1612, 1611, 1, 0, 0, 0, 1613, 269, 1, 0, 0, 0, 1614, 1616, 3, 268, 134, 0, 1615, 1617, 5, 131, 0, 0, 1616, 1615, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 1625, 1, 0, 0, 0, 1618, 1619, 5, 122, 0, 0, 1619, 1621, 3, 268, 134, 0, 1620, 1622, 5, 131, 0, 0, 1621, 1620, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1624, 1, 0, 0, 0, 1623, 1618, 1, 0, 0, 0, 1624, 1627, 1, 0, 0, 0, 1625, 1623, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 271, 1, 0, 0, 0, 1627, 1625, 1, 0, 0, 0, 1628, 1633, 5, 89, 0, 0, 1629, 1631, 3, 270, 135, 0, 1630, 1632, 5, 122, 0, 0, 1631, 1630, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, 0, 1632, 1634, 1, 0, 0, 0, 1633, 1629, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1635, 1, 0, 0, 0, 1635, 1636, 5, 90, 0, 0, 1636, 273, 1, 0, 0, 0, 1637, 1640, 5, 132, 0, 0, 1638, 1640, 3, 338, 169, 0, 1639, 1637, 1, 0, 0, 0, 1639, 1638, 1, 0, 0, 0, 1640, 275, 1, 0, 0, 0, 1641, 1642, 3, 278, 139, 0, 1642, 1644, 5, 89, 0, 0, 1643, 1645, 3, 286, 143, 0, 1644, 1643, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 1647, 5, 90, 0, 0, 1647, 277, 1, 0, 0, 0, 1648, 1650, 3, 284, 142, 0, 1649, 1651, 3, 200, 100, 0, 1650, 1649, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1656, 1, 0, 0, 0, 1652, 1654, 3, 280, 140, 0, 1653, 1655, 3, 282, 141, 0, 1654, 1653, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1652, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, 1657, 1659, 1, 0, 0, 0, 1658, 1660, 3, 300, 150, 0, 1659, 1658, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1672, 1, 0, 0, 0, 1661, 1663, 5, 77, 0, 0, 1662, 1664, 3, 200, 100, 0, 1663, 1662, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1669, 1, 0, 0, 0, 1665, 1667, 3, 280, 140, 0, 1666, 1668, 3, 282, 141, 0, 1667, 1666, 1, 0, 0, 0, 1667, 1668, 1, 0, 0, 0, 1668, 1670, 1, 0, 0, 0, 1669, 1665, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1672, 1, 0, 0, 0, 1671, 1648, 1, 0, 0, 0, 1671, 1661, 1, 0, 0, 0, 1672, 279, 1, 0, 0, 0, 1673, 1675, 3, 10, 5, 0, 1674, 1673, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 3, 274, 137, 0, 1677, 281, 1, 0, 0, 0, 1678, 1679, 5, 38, 0, 0, 1679, 283, 1, 0, 0, 0, 1680, 1681, 7, 13, 0, 0, 1681, 285, 1, 0, 0, 0, 1682, 1687, 3, 288, 144, 0, 1683, 1684, 3, 310, 155, 0, 1684, 1685, 5, 126, 0, 0, 1685, 1687, 1, 0, 0, 0, 1686, 1682, 1, 0, 0, 0, 1686, 1683, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 1686, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 287, 1, 0, 0, 0, 1690, 1692, 3, 200, 100, 0, 1691, 1690, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1694, 1, 0, 0, 0, 1693, 1695, 3, 138, 69, 0, 1694, 1693, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1695, 1697, 1, 0, 0, 0, 1696, 1698, 3, 290, 145, 0, 1697, 1696, 1, 0, 0, 0, 1697, 1698, 1, 0, 0, 0, 1698, 1699, 1, 0, 0, 0, 1699, 1707, 5, 128, 0, 0, 1700, 1707, 3, 260, 130, 0, 1701, 1707, 3, 192, 96, 0, 1702, 1707, 3, 130, 65, 0, 1703, 1707, 3, 330, 165, 0, 1704, 1707, 3, 126, 63, 0, 1705, 1707, 3, 132, 66, 0, 1706, 1691, 1, 0, 0, 0, 1706, 1700, 1, 0, 0, 0, 1706, 1701, 1, 0, 0, 0, 1706, 1702, 1, 0, 0, 0, 1706, 1703, 1, 0, 0, 0, 1706, 1704, 1, 0, 0, 0, 1706, 1705, 1, 0, 0, 0, 1707, 289, 1, 0, 0, 0, 1708, 1713, 3, 292, 146, 0, 1709, 1710, 5, 122, 0, 0, 1710, 1712, 3, 292, 146, 0, 1711, 1709, 1, 0, 0, 0, 1712, 1715, 1, 0, 0, 0, 1713, 1711, 1, 0, 0, 0, 1713, 1714, 1, 0, 0, 0, 1714, 291, 1, 0, 0, 0, 1715, 1713, 1, 0, 0, 0, 1716, 1726, 3, 222, 111, 0, 1717, 1719, 3, 294, 147, 0, 1718, 1717, 1, 0, 0, 0, 1718, 1719, 1, 0, 0, 0, 1719, 1721, 1, 0, 0, 0, 1720, 1722, 3, 298, 149, 0, 1721, 1720, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1727, 1, 0, 0, 0, 1723, 1725, 3, 266, 133, 0, 1724, 1723, 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, 1727, 1, 0, 0, 0, 1726, 1718, 1, 0, 0, 0, 1726, 1724, 1, 0, 0, 0, 1727, 1737, 1, 0, 0, 0, 1728, 1730, 5, 132, 0, 0, 1729, 1728, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, 0, 1731, 1733, 3, 200, 100, 0, 1732, 1731, 1, 0, 0, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 1735, 5, 126, 0, 0, 1735, 1737, 3, 92, 46, 0, 1736, 1716, 1, 0, 0, 0, 1736, 1729, 1, 0, 0, 0, 1737, 293, 1, 0, 0, 0, 1738, 1740, 3, 296, 148, 0, 1739, 1738, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1739, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 295, 1, 0, 0, 0, 1743, 1744, 7, 18, 0, 0, 1744, 297, 1, 0, 0, 0, 1745, 1746, 5, 101, 0, 0, 1746, 1747, 5, 134, 0, 0, 1747, 1748, 6, 149, -1, 0, 1748, 299, 1, 0, 0, 0, 1749, 1750, 5, 126, 0, 0, 1750, 1751, 3, 302, 151, 0, 1751, 301, 1, 0, 0, 0, 1752, 1754, 3, 304, 152, 0, 1753, 1755, 5, 131, 0, 0, 1754, 1753, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1755, 1763, 1, 0, 0, 0, 1756, 1757, 5, 122, 0, 0, 1757, 1759, 3, 304, 152, 0, 1758, 1760, 5, 131, 0, 0, 1759, 1758, 1, 0, 0, 0, 1759, 1760, 1, 0, 0, 0, 1760, 1762, 1, 0, 0, 0, 1761, 1756, 1, 0, 0, 0, 1762, 1765, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, 0, 1764, 303, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1766, 1768, 3, 200, 100, 0, 1767, 1766, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1781, 1, 0, 0, 0, 1769, 1782, 3, 308, 154, 0, 1770, 1772, 5, 80, 0, 0, 1771, 1773, 3, 310, 155, 0, 1772, 1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1782, 3, 308, 154, 0, 1775, 1777, 3, 310, 155, 0, 1776, 1778, 5, 80, 0, 0, 1777, 1776, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1780, 3, 308, 154, 0, 1780, 1782, 1, 0, 0, 0, 1781, 1769, 1, 0, 0, 0, 1781, 1770, 1, 0, 0, 0, 1781, 1775, 1, 0, 0, 0, 1782, 305, 1, 0, 0, 0, 1783, 1785, 3, 10, 5, 0, 1784, 1783, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1789, 3, 274, 137, 0, 1787, 1789, 3, 158, 79, 0, 1788, 1784, 1, 0, 0, 0, 1788, 1787, 1, 0, 0, 0, 1789, 307, 1, 0, 0, 0, 1790, 1791, 3, 306, 153, 0, 1791, 309, 1, 0, 0, 0, 1792, 1793, 7, 19, 0, 0, 1793, 311, 1, 0, 0, 0, 1794, 1795, 5, 52, 0, 0, 1795, 1796, 3, 314, 157, 0, 1796, 313, 1, 0, 0, 0, 1797, 1799, 3, 150, 75, 0, 1798, 1800, 3, 316, 158, 0, 1799, 1798, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 315, 1, 0, 0, 0, 1801, 1803, 3, 232, 116, 0, 1802, 1804, 3, 316, 158, 0, 1803, 1802, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 317, 1, 0, 0, 0, 1805, 1806, 5, 126, 0, 0, 1806, 1807, 3, 320, 160, 0, 1807, 319, 1, 0, 0, 0, 1808, 1810, 3, 322, 161, 0, 1809, 1811, 5, 131, 0, 0, 1810, 1809, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, 1819, 1, 0, 0, 0, 1812, 1813, 5, 122, 0, 0, 1813, 1815, 3, 322, 161, 0, 1814, 1816, 5, 131, 0, 0, 1815, 1814, 1, 0, 0, 0, 1815, 1816, 1, 0, 0, 0, 1816, 1818, 1, 0, 0, 0, 1817, 1812, 1, 0, 0, 0, 1818, 1821, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 321, 1, 0, 0, 0, 1821, 1819, 1, 0, 0, 0, 1822, 1829, 3, 324, 162, 0, 1823, 1825, 5, 85, 0, 0, 1824, 1826, 3, 34, 17, 0, 1825, 1824, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1830, 5, 86, 0, 0, 1828, 1830, 3, 272, 136, 0, 1829, 1823, 1, 0, 0, 0, 1829, 1828, 1, 0, 0, 0, 1830, 323, 1, 0, 0, 0, 1831, 1834, 3, 306, 153, 0, 1832, 1834, 5, 132, 0, 0, 1833, 1831, 1, 0, 0, 0, 1833, 1832, 1, 0, 0, 0, 1834, 325, 1, 0, 0, 0, 1835, 1836, 5, 52, 0, 0, 1836, 1837, 3, 374, 187, 0, 1837, 327, 1, 0, 0, 0, 1838, 1842, 5, 52, 0, 0, 1839, 1840, 5, 4, 0, 0, 1840, 1843, 5, 132, 0, 0, 1841, 1843, 5, 140, 0, 0, 1842, 1839, 1, 0, 0, 0, 1842, 1841, 1, 0, 0, 0, 1843, 329, 1, 0, 0, 0, 1844, 1845, 5, 68, 0, 0, 1845, 1846, 5, 102, 0, 0, 1846, 1847, 3, 332, 166, 0, 1847, 1848, 5, 103, 0, 0, 1848, 1849, 3, 122, 61, 0, 1849, 331, 1, 0, 0, 0, 1850, 1855, 3, 334, 167, 0, 1851, 1852, 5, 122, 0, 0, 1852, 1854, 3, 334, 167, 0, 1853, 1851, 1, 0, 0, 0, 1854, 1857, 1, 0, 0, 0, 1855, 1853, 1, 0, 0, 0, 1855, 1856, 1, 0, 0, 0, 1856, 333, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1858, 1861, 3, 336, 168, 0, 1859, 1861, 3, 258, 129, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1859, 1, 0, 0, 0, 1861, 335, 1, 0, 0, 0, 1862, 1863, 5, 68, 0, 0, 1863, 1864, 5, 102, 0, 0, 1864, 1865, 3, 332, 166, 0, 1865, 1866, 5, 103, 0, 0, 1866, 1868, 1, 0, 0, 0, 1867, 1862, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1869, 1, 0, 0, 0, 1869, 1872, 5, 21, 0, 0, 1870, 1872, 5, 76, 0, 0, 1871, 1867, 1, 0, 0, 0, 1871, 1870, 1, 0, 0, 0, 1872, 1884, 1, 0, 0, 0, 1873, 1875, 5, 131, 0, 0, 1874, 1873, 1, 0, 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 1877, 1, 0, 0, 0, 1876, 1878, 5, 132, 0, 0, 1877, 1876, 1, 0, 0, 0, 1877, 1878, 1, 0, 0, 0, 1878, 1885, 1, 0, 0, 0, 1879, 1881, 5, 132, 0, 0, 1880, 1879, 1, 0, 0, 0, 1880, 1881, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1883, 5, 101, 0, 0, 1883, 1885, 3, 242, 121, 0, 1884, 1874, 1, 0, 0, 0, 1884, 1880, 1, 0, 0, 0, 1885, 337, 1, 0, 0, 0, 1886, 1887, 3, 342, 171, 0, 1887, 1889, 5, 102, 0, 0, 1888, 1890, 3, 344, 172, 0, 1889, 1888, 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1891, 1, 0, 0, 0, 1891, 1892, 5, 103, 0, 0, 1892, 339, 1, 0, 0, 0, 1893, 1905, 3, 338, 169, 0, 1894, 1897, 3, 326, 163, 0, 1895, 1897, 3, 328, 164, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1895, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1900, 5, 102, 0, 0, 1899, 1901, 3, 344, 172, 0, 1900, 1899, 1, 0, 0, 0, 1900, 1901, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1903, 5, 103, 0, 0, 1903, 1905, 1, 0, 0, 0, 1904, 1893, 1, 0, 0, 0, 1904, 1896, 1, 0, 0, 0, 1905, 341, 1, 0, 0, 0, 1906, 1907, 5, 132, 0, 0, 1907, 343, 1, 0, 0, 0, 1908, 1910, 3, 346, 173, 0, 1909, 1911, 5, 131, 0, 0, 1910, 1909, 1, 0, 0, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1919, 1, 0, 0, 0, 1912, 1913, 5, 122, 0, 0, 1913, 1915, 3, 346, 173, 0, 1914, 1916, 5, 131, 0, 0, 1915, 1914, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1918, 1, 0, 0, 0, 1917, 1912, 1, 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1917, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 345, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1922, 1926, 3, 242, 121, 0, 1923, 1926, 3, 92, 46, 0, 1924, 1926, 3, 4, 2, 0, 1925, 1922, 1, 0, 0, 0, 1925, 1923, 1, 0, 0, 0, 1925, 1924, 1, 0, 0, 0, 1926, 347, 1, 0, 0, 0, 1927, 1928, 5, 76, 0, 0, 1928, 1934, 3, 10, 5, 0, 1929, 1935, 5, 132, 0, 0, 1930, 1932, 5, 68, 0, 0, 1931, 1930, 1, 0, 0, 0, 1931, 1932, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1935, 3, 338, 169, 0, 1934, 1929, 1, 0, 0, 0, 1934, 1931, 1, 0, 0, 0, 1935, 349, 1, 0, 0, 0, 1936, 1938, 5, 36, 0, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 5, 68, 0, 0, 1940, 1941, 3, 122, 61, 0, 1941, 351, 1, 0, 0, 0, 1942, 1943, 5, 68, 0, 0, 1943, 1944, 5, 102, 0, 0, 1944, 1945, 5, 103, 0, 0, 1945, 1946, 3, 122, 61, 0, 1946, 353, 1, 0, 0, 0, 1947, 1948, 5, 73, 0, 0, 1948, 1949, 3, 100, 50, 0, 1949, 1950, 3, 358, 179, 0, 1950, 355, 1, 0, 0, 0, 1951, 1953, 5, 73, 0, 0, 1952, 1954, 3, 318, 159, 0, 1953, 1952, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955, 1956, 3, 100, 50, 0, 1956, 1957, 3, 358, 179, 0, 1957, 357, 1, 0, 0, 0, 1958, 1960, 3, 360, 180, 0, 1959, 1958, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1962, 1, 0, 0, 0, 1962, 359, 1, 0, 0, 0, 1963, 1964, 5, 17, 0, 0, 1964, 1965, 5, 85, 0, 0, 1965, 1966, 3, 362, 181, 0, 1966, 1967, 5, 86, 0, 0, 1967, 1968, 3, 100, 50, 0, 1968, 361, 1, 0, 0, 0, 1969, 1971, 3, 200, 100, 0, 1970, 1969, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972, 1975, 3, 150, 75, 0, 1973, 1976, 3, 222, 111, 0, 1974, 1976, 3, 244, 122, 0, 1975, 1973, 1, 0, 0, 0, 1975, 1974, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1979, 1, 0, 0, 0, 1977, 1979, 5, 131, 0, 0, 1978, 1970, 1, 0, 0, 0, 1978, 1977, 1, 0, 0, 0, 1979, 363, 1, 0, 0, 0, 1980, 1982, 5, 71, 0, 0, 1981, 1983, 3, 86, 43, 0, 1982, 1981, 1, 0, 0, 0, 1982, 1983, 1, 0, 0, 0, 1983, 365, 1, 0, 0, 0, 1984, 1987, 3, 368, 184, 0, 1985, 1987, 3, 372, 186, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1985, 1, 0, 0, 0, 1987, 367, 1, 0, 0, 0, 1988, 1989, 5, 71, 0, 0, 1989, 1991, 5, 85, 0, 0, 1990, 1992, 3, 370, 185, 0, 1991, 1990, 1, 0, 0, 0, 1991, 1992, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, 1994, 5, 86, 0, 0, 1994, 369, 1, 0, 0, 0, 1995, 1997, 3, 242, 121, 0, 1996, 1998, 5, 131, 0, 0, 1997, 1996, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 2006, 1, 0, 0, 0, 1999, 2000, 5, 122, 0, 0, 2000, 2002, 3, 242, 121, 0, 2001, 2003, 5, 131, 0, 0, 2002, 2001, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2005, 1, 0, 0, 0, 2004, 1999, 1, 0, 0, 0, 2005, 2008, 1, 0, 0, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2007, 1, 0, 0, 0, 2007, 371, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 2009, 2010, 5, 50, 0, 0, 2010, 2011, 5, 85, 0, 0, 2011, 2012, 3, 92, 46, 0, 2012, 2013, 5, 86, 0, 0, 2013, 2016, 1, 0, 0, 0, 2014, 2016, 5, 50, 0, 0, 2015, 2009, 1, 0, 0, 0, 2015, 2014, 1, 0, 0, 0, 2016, 373, 1, 0, 0, 0, 2017, 2020, 5, 49, 0, 0, 2018, 2019, 5, 87, 0, 0, 2019, 2021, 5, 88, 0, 0, 2020, 2018, 1, 0, 0, 0, 2020, 2021, 1, 0, 0, 0, 2021, 2071, 1, 0, 0, 0, 2022, 2025, 5, 28, 0, 0, 2023, 2024, 5, 87, 0, 0, 2024, 2026, 5, 88, 0, 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2071, 1, 0, 0, 0, 2027, 2071, 5, 91, 0, 0, 2028, 2071, 5, 92, 0, 0, 2029, 2071, 5, 93, 0, 0, 2030, 2071, 5, 94, 0, 0, 2031, 2071, 5, 95, 0, 0, 2032, 2071, 5, 96, 0, 0, 2033, 2071, 5, 97, 0, 0, 2034, 2071, 5, 98, 0, 0, 2035, 2071, 5, 99, 0, 0, 2036, 2071, 5, 100, 0, 0, 2037, 2071, 5, 101, 0, 0, 2038, 2071, 5, 103, 0, 0, 2039, 2071, 5, 102, 0, 0, 2040, 2071, 5, 117, 0, 0, 2041, 2071, 5, 104, 0, 0, 2042, 2071, 5, 105, 0, 0, 2043, 2071, 5, 106, 0, 0, 2044, 2071, 5, 101, 0, 0, 2045, 2071, 5, 108, 0, 0, 2046, 2071, 5, 109, 0, 0, 2047, 2071, 5, 110, 0, 0, 2048, 2071, 5, 111, 0, 0, 2049, 2050, 5, 102, 0, 0, 2050, 2071, 5, 102, 0, 0, 2051, 2052, 5, 103, 0, 0, 2052, 2071, 5, 103, 0, 0, 2053, 2071, 5, 113, 0, 0, 2054, 2071, 5, 112, 0, 0, 2055, 2071, 5, 114, 0, 0, 2056, 2071, 5, 115, 0, 0, 2057, 2071, 5, 116, 0, 0, 2058, 2071, 5, 117, 0, 0, 2059, 2071, 5, 118, 0, 0, 2060, 2071, 5, 119, 0, 0, 2061, 2071, 5, 120, 0, 0, 2062, 2071, 5, 121, 0, 0, 2063, 2071, 5, 122, 0, 0, 2064, 2071, 5, 123, 0, 0, 2065, 2071, 5, 124, 0, 0, 2066, 2067, 5, 85, 0, 0, 2067, 2071, 5, 86, 0, 0, 2068, 2069, 5, 87, 0, 0, 2069, 2071, 5, 88, 0, 0, 2070, 2017, 1, 0, 0, 0, 2070, 2022, 1, 0, 0, 0, 2070, 2027, 1, 0, 0, 0, 2070, 2028, 1, 0, 0, 0, 2070, 2029, 1, 0, 0, 0, 2070, 2030, 1, 0, 0, 0, 2070, 2031, 1, 0, 0, 0, 2070, 2032, 1, 0, 0, 0, 2070, 2033, 1, 0, 0, 0, 2070, 2034, 1, 0, 0, 0, 2070, 2035, 1, 0, 0, 0, 2070, 2036, 1, 0, 0, 0, 2070, 2037, 1, 0, 0, 0, 2070, 2038, 1, 0, 0, 0, 2070, 2039, 1, 0, 0, 0, 2070, 2040, 1, 0, 0, 0, 2070, 2041, 1, 0, 0, 0, 2070, 2042, 1, 0, 0, 0, 2070, 2043, 1, 0, 0, 0, 2070, 2044, 1, 0, 0, 0, 2070, 2045, 1, 0, 0, 0, 2070, 2046, 1, 0, 0, 0, 2070, 2047, 1, 0, 0, 0, 2070, 2048, 1, 0, 0, 0, 2070, 2049, 1, 0, 0, 0, 2070, 2051, 1, 0, 0, 0, 2070, 2053, 1, 0, 0, 0, 2070, 2054, 1, 0, 0, 0, 2070, 2055, 1, 0, 0, 0, 2070, 2056, 1, 0, 0, 0, 2070, 2057, 1, 0, 0, 0, 2070, 2058, 1, 0, 0, 0, 2070, 2059, 1, 0, 0, 0, 2070, 2060, 1, 0, 0, 0, 2070, 2061, 1, 0, 0, 0, 2070, 2062, 1, 0, 0, 0, 2070, 2063, 1, 0, 0, 0, 2070, 2064, 1, 0, 0, 0, 2070, 2065, 1, 0, 0, 0, 2070, 2066, 1, 0, 0, 0, 2070, 2068, 1, 0, 0, 0, 2071, 375, 1, 0, 0, 0, 2072, 2073, 7, 20, 0, 0, 2073, 377, 1, 0, 0, 0, 297, 379, 386, 395, 399, 408, 411, 415, 423, 430, 433, 438, 443, 449, 457, 459, 468, 472, 476, 479, 483, 486, 493, 497, 500, 503, 506, 512, 516, 520, 534, 538, 544, 551, 557, 561, 565, 567, 575, 580, 593, 600, 612, 622, 627, 631, 638, 641, 649, 653, 656, 663, 670, 674, 679, 683, 686, 691, 706, 713, 721, 729, 738, 745, 752, 760, 768, 776, 784, 792, 800, 809, 817, 826, 833, 841, 844, 847, 853, 859, 865, 872, 881, 889, 893, 900, 902, 922, 926, 932, 937, 941, 944, 951, 958, 962, 971, 982, 992, 997, 1004, 1007, 1012, 1017, 1038, 1043, 1046, 1057, 1063, 1068, 1071, 1076, 1079, 1082, 1104, 1110, 1116, 1122, 1125, 1131, 1135, 1139, 1142, 1150, 1152, 1158, 1161, 1164, 1167, 1171, 1175, 1181, 1191, 1197, 1203, 1208, 1213, 1217, 1230, 1236, 1240, 1246, 1251, 1266, 1270, 1275, 1280, 1285, 1291, 1294, 1303, 1307, 1312, 1316, 1322, 1329, 1346, 1348, 1355, 1360, 1367, 1371, 1375, 1383, 1389, 1395, 1399, 1401, 1405, 1410, 1414, 1417, 1420, 1423, 1428, 1432, 1435, 1439, 1442, 1444, 1449, 1456, 1462, 1466, 1472, 1478, 1481, 1483, 1489, 1493, 1499, 1506, 1510, 1512, 1516, 1522, 1534, 1538, 1540, 1544, 1549, 1552, 1559, 1563, 1568, 1570, 1574, 1577, 1580, 1584, 1589, 1596, 1603, 1608, 1612, 1616, 1621, 1625, 1631, 1633, 1639, 1644, 1650, 1654, 1656, 1659, 1663, 1667, 1669, 1671, 1674, 1686, 1688, 1691, 1694, 1697, 1706, 1713, 1718, 1721, 1724, 1726, 1729, 1732, 1736, 1741, 1754, 1759, 1763, 1767, 1772, 1777, 1781, 1784, 1788, 1799, 1803, 1810, 1815, 1819, 1825, 1829, 1833, 1842, 1855, 1860, 1867, 1871, 1874, 1877, 1880, 1884, 1889, 1896, 1900, 1904, 1910, 1915, 1919, 1925, 1931, 1934, 1937, 1953, 1961, 1970, 1975, 1978, 1982, 1986, 1991, 1997, 2002, 2006, 2015, 2020, 2025, 2070] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.java b/src/main/java/CPP14Parser.java similarity index 81% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.java rename to src/main/java/CPP14Parser.java index 3797ed0..b84a87c 100644 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.java +++ b/src/main/java/CPP14Parser.java @@ -1,18 +1,31 @@ -package jp.ac.osaka_u.sdl.nil.parser.cpp; - -// Generated from CPP14Parser.g4 by ANTLR 4.9.1 - -import org.antlr.v4.runtime.atn.*; +// Generated from CPP14Parser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.FailedPredicateException; +import org.antlr.v4.runtime.InputMismatchException; +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.tree.*; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.TerminalNode; import java.util.List; -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) public class CPP14Parser extends Parser { static { - RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; @@ -279,6 +292,7 @@ public CPP14Parser(TokenStream input) { _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); } + @SuppressWarnings("CheckReturnValue") public static class TranslationUnitContext extends ParserRuleContext { public TerminalNode EOF() { return getToken(CPP14Parser.EOF, 0); @@ -318,7 +332,7 @@ public final TranslationUnitContext translationUnit() throws RecognitionExceptio setState(379); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543754443169808157L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 459384754220313597L) != 0)) { { setState(378); declarationseq(); @@ -338,6 +352,7 @@ public final TranslationUnitContext translationUnit() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PrimaryExpressionContext extends ParserRuleContext { public List literal() { return getRuleContexts(LiteralContext.class); @@ -478,6 +493,7 @@ public final PrimaryExpressionContext primaryExpression() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IdExpressionContext extends ParserRuleContext { public UnqualifiedIdContext unqualifiedId() { return getRuleContext(UnqualifiedIdContext.class, 0); @@ -539,6 +555,7 @@ public final IdExpressionContext idExpression() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class UnqualifiedIdContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -668,6 +685,7 @@ public final UnqualifiedIdContext unqualifiedId() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class QualifiedIdContext extends ParserRuleContext { public NestedNameSpecifierContext nestedNameSpecifier() { return getRuleContext(NestedNameSpecifierContext.class, 0); @@ -733,6 +751,7 @@ public final QualifiedIdContext qualifiedId() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NestedNameSpecifierContext extends ParserRuleContext { public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); @@ -884,6 +903,7 @@ private NestedNameSpecifierContext nestedNameSpecifier(int _p) throws Recognitio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LambdaExpressionContext extends ParserRuleContext { public LambdaIntroducerContext lambdaIntroducer() { return getRuleContext(LambdaIntroducerContext.class, 0); @@ -949,6 +969,7 @@ public final LambdaExpressionContext lambdaExpression() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LambdaIntroducerContext extends ParserRuleContext { public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); @@ -994,7 +1015,7 @@ public final LambdaIntroducerContext lambdaIntroducer() throws RecognitionExcept setState(449); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (This - 69)) | (1L << (And - 69)) | (1L << (Assign - 69)) | (1L << (Identifier - 69)))) != 0)) { + if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & -9223372032291373055L) != 0)) { { setState(448); lambdaCapture(); @@ -1014,6 +1035,7 @@ public final LambdaIntroducerContext lambdaIntroducer() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LambdaCaptureContext extends ParserRuleContext { public CaptureListContext captureList() { return getRuleContext(CaptureListContext.class, 0); @@ -1092,6 +1114,7 @@ public final LambdaCaptureContext lambdaCapture() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CaptureDefaultContext extends ParserRuleContext { public TerminalNode And() { return getToken(CPP14Parser.And, 0); @@ -1148,6 +1171,7 @@ public final CaptureDefaultContext captureDefault() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CaptureListContext extends ParserRuleContext { public List capture() { return getRuleContexts(CaptureContext.class); @@ -1235,6 +1259,7 @@ public final CaptureListContext captureList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CaptureContext extends ParserRuleContext { public SimpleCaptureContext simpleCapture() { return getRuleContext(SimpleCaptureContext.class, 0); @@ -1296,6 +1321,7 @@ public final CaptureContext capture() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SimpleCaptureContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -1375,6 +1401,7 @@ public final SimpleCaptureContext simpleCapture() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitcaptureContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -1440,6 +1467,7 @@ public final InitcaptureContext initcapture() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LambdaDeclaratorContext extends ParserRuleContext { public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); @@ -1501,7 +1529,7 @@ public final LambdaDeclaratorContext lambdaDeclarator() throws RecognitionExcept setState(493); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Struct - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftBracket - 74)) | (1L << (Doublecolon - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1237504995584196377L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 297237575406461917L) != 0)) { { setState(492); parameterDeclarationClause(); @@ -1561,6 +1589,7 @@ public final LambdaDeclaratorContext lambdaDeclarator() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PostfixExpressionContext extends ParserRuleContext { public PrimaryExpressionContext primaryExpression() { return getRuleContext(PrimaryExpressionContext.class, 0); @@ -1752,7 +1781,7 @@ private PostfixExpressionContext postfixExpression(int _p) throws RecognitionExc setState(516); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474400910417L) != 0) || _la == Identifier) { { setState(515); expressionList(); @@ -1776,7 +1805,7 @@ private PostfixExpressionContext postfixExpression(int _p) throws RecognitionExc case 3: { setState(522); _la = _input.LA(1); - if (!(((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (Const_cast - 24)) | (1L << (Dynamic_cast - 24)) | (1L << (Reinterpret_cast - 24)) | (1L << (Static_cast - 24)))) != 0))) { + if (!(((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & 2216203124865L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -1920,7 +1949,7 @@ private PostfixExpressionContext postfixExpression(int _p) throws RecognitionExc setState(551); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474400910417L) != 0) || _la == Identifier) { { setState(550); expressionList(); @@ -2007,6 +2036,7 @@ private PostfixExpressionContext postfixExpression(int _p) throws RecognitionExc return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeIdOfTheTypeIdContext extends ParserRuleContext { public TerminalNode Typeid_() { return getToken(CPP14Parser.Typeid_, 0); @@ -2051,6 +2081,7 @@ public final TypeIdOfTheTypeIdContext typeIdOfTheTypeId() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionListContext extends ParserRuleContext { public InitializerListContext initializerList() { return getRuleContext(InitializerListContext.class, 0); @@ -2095,6 +2126,7 @@ public final ExpressionListContext expressionList() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PseudoDestructorNameContext extends ParserRuleContext { public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); @@ -2225,6 +2257,7 @@ public final PseudoDestructorNameContext pseudoDestructorName() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class UnaryExpressionContext extends ParserRuleContext { public PostfixExpressionContext postfixExpression() { return getRuleContext(PostfixExpressionContext.class, 0); @@ -2437,6 +2470,7 @@ public final UnaryExpressionContext unaryExpression() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class UnaryOperatorContext extends ParserRuleContext { public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); @@ -2495,7 +2529,7 @@ public final UnaryOperatorContext unaryOperator() throws RecognitionException { { setState(624); _la = _input.LA(1); - if (!(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (Plus - 91)) | (1L << (Minus - 91)) | (1L << (Star - 91)) | (1L << (And - 91)) | (1L << (Or - 91)) | (1L << (Tilde - 91)) | (1L << (Not - 91)))) != 0))) { + if (!(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & 967L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -2513,6 +2547,7 @@ public final UnaryOperatorContext unaryOperator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NewExpressionContext extends ParserRuleContext { public TerminalNode New() { return getToken(CPP14Parser.New, 0); @@ -2660,6 +2695,7 @@ public final NewExpressionContext newExpression() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NewPlacementContext extends ParserRuleContext { public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); @@ -2716,6 +2752,7 @@ public final NewPlacementContext newPlacement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NewTypeIdContext extends ParserRuleContext { public TypeSpecifierSeqContext typeSpecifierSeq() { return getRuleContext(TypeSpecifierSeqContext.class, 0); @@ -2773,6 +2810,7 @@ public final NewTypeIdContext newTypeId() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NewDeclaratorContext extends ParserRuleContext { public PointerOperatorContext pointerOperator() { return getRuleContext(PointerOperatorContext.class, 0); @@ -2854,6 +2892,7 @@ public final NewDeclaratorContext newDeclarator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoPointerNewDeclaratorContext extends ParserRuleContext { public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); @@ -2980,6 +3019,7 @@ private NoPointerNewDeclaratorContext noPointerNewDeclarator(int _p) throws Reco return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NewInitializerContext extends ParserRuleContext { public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); @@ -3033,7 +3073,7 @@ public final NewInitializerContext newInitializer() throws RecognitionException setState(679); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474400910417L) != 0) || _la == Identifier) { { setState(678); expressionList(); @@ -3064,6 +3104,7 @@ public final NewInitializerContext newInitializer() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeleteExpressionContext extends ParserRuleContext { public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); @@ -3148,6 +3189,7 @@ public final DeleteExpressionContext deleteExpression() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoExceptExpressionContext extends ParserRuleContext { public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); @@ -3210,6 +3252,7 @@ public final NoExceptExpressionContext noExceptExpression() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CastExpressionContext extends ParserRuleContext { public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class, 0); @@ -3289,6 +3332,7 @@ public final CastExpressionContext castExpression() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PointerMemberExpressionContext extends ParserRuleContext { public List castExpression() { return getRuleContexts(CastExpressionContext.class); @@ -3379,6 +3423,7 @@ public final PointerMemberExpressionContext pointerMemberExpression() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MultiplicativeExpressionContext extends ParserRuleContext { public List pointerMemberExpression() { return getRuleContexts(PointerMemberExpressionContext.class); @@ -3446,12 +3491,12 @@ public final MultiplicativeExpressionContext multiplicativeExpression() throws R setState(721); _errHandler.sync(this); _la = _input.LA(1); - while (((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (Div - 93)) | (1L << (Mod - 93)))) != 0)) { + while (((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 7L) != 0)) { { { setState(717); _la = _input.LA(1); - if (!(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (Div - 93)) | (1L << (Mod - 93)))) != 0))) { + if (!(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 7L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -3477,6 +3522,7 @@ public final MultiplicativeExpressionContext multiplicativeExpression() throws R return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AdditiveExpressionContext extends ParserRuleContext { public List multiplicativeExpression() { return getRuleContexts(MultiplicativeExpressionContext.class); @@ -3565,6 +3611,7 @@ public final AdditiveExpressionContext additiveExpression() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ShiftExpressionContext extends ParserRuleContext { public List additiveExpression() { return getRuleContexts(AdditiveExpressionContext.class); @@ -3640,6 +3687,7 @@ public final ShiftExpressionContext shiftExpression() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ShiftOperatorContext extends ParserRuleContext { public List Greater() { return getTokens(CPP14Parser.Greater); @@ -3715,6 +3763,7 @@ public final ShiftOperatorContext shiftOperator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class RelationalExpressionContext extends ParserRuleContext { public List shiftExpression() { return getRuleContexts(ShiftExpressionContext.class); @@ -3797,7 +3846,7 @@ public final RelationalExpressionContext relationalExpression() throws Recogniti { setState(748); _la = _input.LA(1); - if (!(((((_la - 102)) & ~0x3f) == 0 && ((1L << (_la - 102)) & ((1L << (Less - 102)) | (1L << (Greater - 102)) | (1L << (LessEqual - 102)) | (1L << (GreaterEqual - 102)))) != 0))) { + if (!(((((_la - 102)) & ~0x3f) == 0 && ((1L << (_la - 102)) & 49155L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -3824,6 +3873,7 @@ public final RelationalExpressionContext relationalExpression() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EqualityExpressionContext extends ParserRuleContext { public List relationalExpression() { return getRuleContexts(RelationalExpressionContext.class); @@ -3912,6 +3962,7 @@ public final EqualityExpressionContext equalityExpression() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AndExpressionContext extends ParserRuleContext { public List equalityExpression() { return getRuleContexts(EqualityExpressionContext.class); @@ -3985,6 +4036,7 @@ public final AndExpressionContext andExpression() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExclusiveOrExpressionContext extends ParserRuleContext { public List andExpression() { return getRuleContexts(AndExpressionContext.class); @@ -4060,6 +4112,7 @@ public final ExclusiveOrExpressionContext exclusiveOrExpression() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InclusiveOrExpressionContext extends ParserRuleContext { public List exclusiveOrExpression() { return getRuleContexts(ExclusiveOrExpressionContext.class); @@ -4135,6 +4188,7 @@ public final InclusiveOrExpressionContext inclusiveOrExpression() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LogicalAndExpressionContext extends ParserRuleContext { public List inclusiveOrExpression() { return getRuleContexts(InclusiveOrExpressionContext.class); @@ -4210,6 +4264,7 @@ public final LogicalAndExpressionContext logicalAndExpression() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LogicalOrExpressionContext extends ParserRuleContext { public List logicalAndExpression() { return getRuleContexts(LogicalAndExpressionContext.class); @@ -4284,6 +4339,7 @@ public final LogicalOrExpressionContext logicalOrExpression() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConditionalExpressionContext extends ParserRuleContext { public LogicalOrExpressionContext logicalOrExpression() { return getRuleContext(LogicalOrExpressionContext.class, 0); @@ -4363,6 +4419,7 @@ public final ConditionalExpressionContext conditionalExpression() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AssignmentExpressionContext extends ParserRuleContext { public ConditionalExpressionContext conditionalExpression() { return getRuleContext(ConditionalExpressionContext.class, 0); @@ -4449,6 +4506,7 @@ public final AssignmentExpressionContext assignmentExpression() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AssignmentOperatorContext extends ParserRuleContext { public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); @@ -4523,7 +4581,7 @@ public final AssignmentOperatorContext assignmentOperator() throws RecognitionEx { setState(819); _la = _input.LA(1); - if (!(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (Assign - 101)) | (1L << (PlusAssign - 101)) | (1L << (MinusAssign - 101)) | (1L << (StarAssign - 101)) | (1L << (DivAssign - 101)) | (1L << (ModAssign - 101)) | (1L << (XorAssign - 101)) | (1L << (AndAssign - 101)) | (1L << (OrAssign - 101)) | (1L << (LeftShiftAssign - 101)) | (1L << (RightShiftAssign - 101)))) != 0))) { + if (!(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 8185L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -4541,6 +4599,7 @@ public final AssignmentOperatorContext assignmentOperator() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionContext extends ParserRuleContext { public List assignmentExpression() { return getRuleContexts(AssignmentExpressionContext.class); @@ -4614,6 +4673,7 @@ public final ExpressionContext expression() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConstantExpressionContext extends ParserRuleContext { public ConditionalExpressionContext conditionalExpression() { return getRuleContext(ConditionalExpressionContext.class, 0); @@ -4658,6 +4718,7 @@ public final ConstantExpressionContext constantExpression() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StatementContext extends ParserRuleContext { public LabeledStatementContext labeledStatement() { return getRuleContext(LabeledStatementContext.class, 0); @@ -4852,6 +4913,7 @@ public final StatementContext statement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LabeledStatementContext extends ParserRuleContext { public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); @@ -4956,6 +5018,7 @@ public final LabeledStatementContext labeledStatement() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionStatementContext extends ParserRuleContext { public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); @@ -4996,7 +5059,7 @@ public final ExpressionStatementContext expressionStatement() throws Recognition setState(859); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133201L) != 0) || _la == Identifier) { { setState(858); expression(); @@ -5016,6 +5079,7 @@ public final ExpressionStatementContext expressionStatement() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CompoundStatementContext extends ParserRuleContext { public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); @@ -5061,7 +5125,7 @@ public final CompoundStatementContext compoundStatement() throws RecognitionExce setState(865); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (AndAnd - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -137360239606498050L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -8989184726396829969L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 25L) != 0)) { { setState(864); statementSeq(); @@ -5081,6 +5145,7 @@ public final CompoundStatementContext compoundStatement() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StatementSeqContext extends ParserRuleContext { public List statement() { return getRuleContexts(StatementContext.class); @@ -5130,7 +5195,7 @@ public final StatementSeqContext statementSeq() throws RecognitionException { setState(872); _errHandler.sync(this); _la = _input.LA(1); - } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (AndAnd - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)))) != 0)); + } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -137360239606498050L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -8989184726396829969L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 25L) != 0)); } } catch (RecognitionException re) { _localctx.exception = re; @@ -5142,6 +5207,7 @@ public final StatementSeqContext statementSeq() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SelectionStatementContext extends ParserRuleContext { public TerminalNode If() { return getToken(CPP14Parser.If, 0); @@ -5256,6 +5322,7 @@ public final SelectionStatementContext selectionStatement() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConditionContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class, 0); @@ -5368,6 +5435,7 @@ public final ConditionContext condition() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IterationStatementContext extends ParserRuleContext { public TerminalNode While() { return getToken(CPP14Parser.While, 0); @@ -5499,7 +5567,7 @@ public final IterationStatementContext iterationStatement() throws RecognitionEx setState(922); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Thread_local - 65)) | (1L << (Throw - 65)) | (1L << (Typedef - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Virtual - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -714116761242538754L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384301683L) != 0) || _la == Identifier) { { setState(921); condition(); @@ -5511,7 +5579,7 @@ public final IterationStatementContext iterationStatement() throws RecognitionEx setState(926); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133201L) != 0) || _la == Identifier) { { setState(925); expression(); @@ -5549,6 +5617,7 @@ public final IterationStatementContext iterationStatement() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ForInitStatementContext extends ParserRuleContext { public ExpressionStatementContext expressionStatement() { return getRuleContext(ExpressionStatementContext.class, 0); @@ -5610,6 +5679,7 @@ public final ForInitStatementContext forInitStatement() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ForRangeDeclarationContext extends ParserRuleContext { public DeclSpecifierSeqContext declSpecifierSeq() { return getRuleContext(DeclSpecifierSeqContext.class, 0); @@ -5676,6 +5746,7 @@ public final ForRangeDeclarationContext forRangeDeclaration() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ForRangeInitializerContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class, 0); @@ -5788,6 +5859,7 @@ public final ForRangeInitializerContext forRangeInitializer() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class JumpStatementContext extends ParserRuleContext { public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); @@ -5954,6 +6026,7 @@ public final JumpStatementContext jumpStatement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclarationStatementContext extends ParserRuleContext { public BlockDeclarationContext blockDeclaration() { return getRuleContext(BlockDeclarationContext.class, 0); @@ -6000,6 +6073,7 @@ public final DeclarationStatementContext declarationStatement() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclarationseqContext extends ParserRuleContext { public List declaration() { return getRuleContexts(DeclarationContext.class); @@ -6049,7 +6123,7 @@ public final DeclarationseqContext declarationseq() throws RecognitionException setState(971); _errHandler.sync(this); _la = _input.LA(1); - } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)); + } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543754443169808157L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 459384754220313597L) != 0)); } } catch (RecognitionException re) { _localctx.exception = re; @@ -6061,6 +6135,7 @@ public final DeclarationseqContext declarationseq() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclarationContext extends ParserRuleContext { public BlockDeclarationContext blockDeclaration() { return getRuleContext(BlockDeclarationContext.class, 0); @@ -6199,6 +6274,7 @@ public final DeclarationContext declaration() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BlockDeclarationContext extends ParserRuleContext { public SimpleDeclarationContext simpleDeclaration() { return getRuleContext(SimpleDeclarationContext.class, 0); @@ -6326,6 +6402,7 @@ public final BlockDeclarationContext blockDeclaration() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AliasDeclarationContext extends ParserRuleContext { public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); @@ -6409,6 +6486,7 @@ public final AliasDeclarationContext aliasDeclaration() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SimpleDeclarationContext extends ParserRuleContext { public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); @@ -6511,7 +6589,7 @@ public final SimpleDeclarationContext simpleDeclaration() throws RecognitionExce setState(1007); _errHandler.sync(this); _la = _input.LA(1); - if (_la == Decltype || _la == Operator || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (Star - 85)) | (1L << (And - 85)) | (1L << (Tilde - 85)) | (1L << (AndAnd - 85)) | (1L << (Doublecolon - 85)) | (1L << (Ellipsis - 85)) | (1L << (Identifier - 85)))) != 0)) { + if (_la == Decltype || _la == Operator || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & 215512868999425L) != 0)) { { setState(1006); initDeclaratorList(); @@ -6556,6 +6634,7 @@ public final SimpleDeclarationContext simpleDeclaration() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StaticAssertDeclarationContext extends ParserRuleContext { public TerminalNode Static_assert() { return getToken(CPP14Parser.Static_assert, 0); @@ -6638,6 +6717,7 @@ public final StaticAssertDeclarationContext staticAssertDeclaration() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EmptyDeclarationContext extends ParserRuleContext { public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); @@ -6682,6 +6762,7 @@ public final EmptyDeclarationContext emptyDeclaration() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeDeclarationContext extends ParserRuleContext { public AttributeSpecifierSeqContext attributeSpecifierSeq() { return getRuleContext(AttributeSpecifierSeqContext.class, 0); @@ -6734,6 +6815,7 @@ public final AttributeDeclarationContext attributeDeclaration() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclSpecifierContext extends ParserRuleContext { public StorageClassSpecifierContext storageClassSpecifier() { return getRuleContext(StorageClassSpecifierContext.class, 0); @@ -6870,6 +6952,7 @@ public final DeclSpecifierContext declSpecifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclSpecifierSeqContext extends ParserRuleContext { public List declSpecifier() { return getRuleContexts(DeclSpecifierContext.class); @@ -6949,6 +7032,7 @@ public final DeclSpecifierSeqContext declSpecifierSeq() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StorageClassSpecifierContext extends ParserRuleContext { public TerminalNode Register() { return getToken(CPP14Parser.Register, 0); @@ -7001,7 +7085,7 @@ public final StorageClassSpecifierContext storageClassSpecifier() throws Recogni { setState(1048); _la = _input.LA(1); - if (!(((((_la - 36)) & ~0x3f) == 0 && ((1L << (_la - 36)) & ((1L << (Extern - 36)) | (1L << (Mutable - 36)) | (1L << (Register - 36)) | (1L << (Static - 36)) | (1L << (Thread_local - 36)))) != 0))) { + if (!(((((_la - 36)) & ~0x3f) == 0 && ((1L << (_la - 36)) & 17316186113L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -7019,6 +7103,7 @@ public final StorageClassSpecifierContext storageClassSpecifier() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionSpecifierContext extends ParserRuleContext { public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); @@ -7061,7 +7146,7 @@ public final FunctionSpecifierContext functionSpecifier() throws RecognitionExce { setState(1050); _la = _input.LA(1); - if (!(((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & ((1L << (Explicit - 34)) | (1L << (Inline - 34)) | (1L << (Virtual - 34)))) != 0))) { + if (!(((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 70368744178689L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -7079,6 +7164,7 @@ public final FunctionSpecifierContext functionSpecifier() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypedefNameContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -7123,6 +7209,7 @@ public final TypedefNameContext typedefName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSpecifierContext extends ParserRuleContext { public TrailingTypeSpecifierContext trailingTypeSpecifier() { return getRuleContext(TrailingTypeSpecifierContext.class, 0); @@ -7195,6 +7282,7 @@ public final TypeSpecifierContext typeSpecifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TrailingTypeSpecifierContext extends ParserRuleContext { public SimpleTypeSpecifierContext simpleTypeSpecifier() { return getRuleContext(SimpleTypeSpecifierContext.class, 0); @@ -7301,6 +7389,7 @@ public final TrailingTypeSpecifierContext trailingTypeSpecifier() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSpecifierSeqContext extends ParserRuleContext { public List typeSpecifier() { return getRuleContexts(TypeSpecifierContext.class); @@ -7380,6 +7469,7 @@ public final TypeSpecifierSeqContext typeSpecifierSeq() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TrailingTypeSpecifierSeqContext extends ParserRuleContext { public List trailingTypeSpecifier() { return getRuleContexts(TrailingTypeSpecifierContext.class); @@ -7461,6 +7551,7 @@ public final TrailingTypeSpecifierSeqContext trailingTypeSpecifierSeq() throws R return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SimpleTypeSpecifierContext extends ParserRuleContext { public TheTypeNameContext theTypeName() { return getRuleContext(TheTypeNameContext.class, 0); @@ -7709,6 +7800,7 @@ public final SimpleTypeSpecifierContext simpleTypeSpecifier() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TheTypeNameContext extends ParserRuleContext { public ClassNameContext className() { return getRuleContext(ClassNameContext.class, 0); @@ -7792,6 +7884,7 @@ public final TheTypeNameContext theTypeName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DecltypeSpecifierContext extends ParserRuleContext { public TerminalNode Decltype() { return getToken(CPP14Parser.Decltype, 0); @@ -7870,6 +7963,7 @@ public final DecltypeSpecifierContext decltypeSpecifier() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ElaboratedTypeSpecifierContext extends ParserRuleContext { public ClassKeyContext classKey() { return getRuleContext(ClassKeyContext.class, 0); @@ -8018,6 +8112,7 @@ public final ElaboratedTypeSpecifierContext elaboratedTypeSpecifier() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumNameContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -8062,6 +8157,7 @@ public final EnumNameContext enumName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumSpecifierContext extends ParserRuleContext { public EnumHeadContext enumHead() { return getRuleContext(EnumHeadContext.class, 0); @@ -8147,6 +8243,7 @@ public final EnumSpecifierContext enumSpecifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumHeadContext extends ParserRuleContext { public EnumkeyContext enumkey() { return getRuleContext(EnumkeyContext.class, 0); @@ -8247,6 +8344,7 @@ public final EnumHeadContext enumHead() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OpaqueEnumDeclarationContext extends ParserRuleContext { public EnumkeyContext enumkey() { return getRuleContext(EnumkeyContext.class, 0); @@ -8334,6 +8432,7 @@ public final OpaqueEnumDeclarationContext opaqueEnumDeclaration() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumkeyContext extends ParserRuleContext { public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); @@ -8404,6 +8503,7 @@ public final EnumkeyContext enumkey() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumbaseContext extends ParserRuleContext { public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); @@ -8454,6 +8554,7 @@ public final EnumbaseContext enumbase() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumeratorListContext extends ParserRuleContext { public List enumeratorDefinition() { return getRuleContexts(EnumeratorDefinitionContext.class); @@ -8529,6 +8630,7 @@ public final EnumeratorListContext enumeratorList() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumeratorDefinitionContext extends ParserRuleContext { public EnumeratorContext enumerator() { return getRuleContext(EnumeratorContext.class, 0); @@ -8596,6 +8698,7 @@ public final EnumeratorDefinitionContext enumeratorDefinition() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EnumeratorContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -8640,6 +8743,7 @@ public final EnumeratorContext enumerator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NamespaceNameContext extends ParserRuleContext { public OriginalNamespaceNameContext originalNamespaceName() { return getRuleContext(OriginalNamespaceNameContext.class, 0); @@ -8701,6 +8805,7 @@ public final NamespaceNameContext namespaceName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OriginalNamespaceNameContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -8747,6 +8852,7 @@ public final OriginalNamespaceNameContext originalNamespaceName() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NamespaceDefinitionContext extends ParserRuleContext { public DeclarationseqContext namespaceBody; @@ -8837,7 +8943,7 @@ public final NamespaceDefinitionContext namespaceDefinition() throws Recognition setState(1217); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543754443169808157L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 459384754220313597L) != 0)) { { setState(1216); ((NamespaceDefinitionContext) _localctx).namespaceBody = declarationseq(); @@ -8857,6 +8963,7 @@ public final NamespaceDefinitionContext namespaceDefinition() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NamespaceAliasContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -8901,6 +9008,7 @@ public final NamespaceAliasContext namespaceAlias() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NamespaceAliasDefinitionContext extends ParserRuleContext { public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); @@ -8971,6 +9079,7 @@ public final NamespaceAliasDefinitionContext namespaceAliasDefinition() throws R return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class QualifiednamespacespecifierContext extends ParserRuleContext { public NamespaceNameContext namespaceName() { return getRuleContext(NamespaceNameContext.class, 0); @@ -9030,6 +9139,7 @@ public final QualifiednamespacespecifierContext qualifiednamespacespecifier() th return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class UsingDeclarationContext extends ParserRuleContext { public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); @@ -9125,6 +9235,7 @@ public final UsingDeclarationContext usingDeclaration() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class UsingDirectiveContext extends ParserRuleContext { public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); @@ -9215,6 +9326,7 @@ public final UsingDirectiveContext usingDirective() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AsmDefinitionContext extends ParserRuleContext { public TerminalNode Asm() { return getToken(CPP14Parser.Asm, 0); @@ -9283,6 +9395,7 @@ public final AsmDefinitionContext asmDefinition() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LinkageSpecificationContext extends ParserRuleContext { public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); @@ -9350,7 +9463,7 @@ public final LinkageSpecificationContext linkageSpecification() throws Recogniti setState(1266); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543754443169808157L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 459384754220313597L) != 0)) { { setState(1265); declarationseq(); @@ -9429,6 +9542,7 @@ public final LinkageSpecificationContext linkageSpecification() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeSpecifierSeqContext extends ParserRuleContext { public List attributeSpecifier() { return getRuleContexts(AttributeSpecifierContext.class); @@ -9497,6 +9611,7 @@ public final AttributeSpecifierSeqContext attributeSpecifierSeq() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeSpecifierContext extends ParserRuleContext { public List LeftBracket() { return getTokens(CPP14Parser.LeftBracket); @@ -9593,6 +9708,7 @@ public final AttributeSpecifierContext attributeSpecifier() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AlignmentspecifierContext extends ParserRuleContext { public TerminalNode Alignas() { return getToken(CPP14Parser.Alignas, 0); @@ -9686,6 +9802,7 @@ public final AlignmentspecifierContext alignmentspecifier() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeListContext extends ParserRuleContext { public List attribute() { return getRuleContexts(AttributeContext.class); @@ -9773,6 +9890,7 @@ public final AttributeListContext attributeList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -9851,6 +9969,7 @@ public final AttributeContext attribute() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeNamespaceContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -9895,6 +10014,7 @@ public final AttributeNamespaceContext attributeNamespace() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AttributeArgumentClauseContext extends ParserRuleContext { public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); @@ -9942,7 +10062,7 @@ public final AttributeArgumentClauseContext attributeArgumentClause() throws Rec setState(1322); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << MultiLineMacro) | (1L << Directive) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Catch) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Else) | (1L << Enum) | (1L << Explicit) | (1L << Export) | (1L << Extern) | (1L << False_) | (1L << Final) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Override) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (Template - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (True_ - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (Caret - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (Assign - 64)) | (1L << (Less - 64)) | (1L << (Greater - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (LessEqual - 64)) | (1L << (GreaterEqual - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Comma - 64)) | (1L << (ArrowStar - 64)) | (1L << (Arrow - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Dot - 128)) | (1L << (DotStar - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (Integersuffix - 128)) | (1L << (UserDefinedIntegerLiteral - 128)) | (1L << (UserDefinedFloatingLiteral - 128)) | (1L << (UserDefinedStringLiteral - 128)) | (1L << (UserDefinedCharacterLiteral - 128)) | (1L << (Whitespace - 128)) | (1L << (Newline - 128)) | (1L << (BlockComment - 128)) | (1L << (LineComment - 128)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -88080385L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 262143L) != 0)) { { setState(1321); balancedTokenSeq(); @@ -9962,6 +10082,7 @@ public final AttributeArgumentClauseContext attributeArgumentClause() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BalancedTokenSeqContext extends ParserRuleContext { public List balancedtoken() { return getRuleContexts(BalancedtokenContext.class); @@ -10011,7 +10132,7 @@ public final BalancedTokenSeqContext balancedTokenSeq() throws RecognitionExcept setState(1329); _errHandler.sync(this); _la = _input.LA(1); - } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << MultiLineMacro) | (1L << Directive) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Catch) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Else) | (1L << Enum) | (1L << Explicit) | (1L << Export) | (1L << Extern) | (1L << False_) | (1L << Final) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Override) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (Template - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (True_ - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (Caret - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (Assign - 64)) | (1L << (Less - 64)) | (1L << (Greater - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (LessEqual - 64)) | (1L << (GreaterEqual - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Comma - 64)) | (1L << (ArrowStar - 64)) | (1L << (Arrow - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Dot - 128)) | (1L << (DotStar - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (Integersuffix - 128)) | (1L << (UserDefinedIntegerLiteral - 128)) | (1L << (UserDefinedFloatingLiteral - 128)) | (1L << (UserDefinedStringLiteral - 128)) | (1L << (UserDefinedCharacterLiteral - 128)) | (1L << (Whitespace - 128)) | (1L << (Newline - 128)) | (1L << (BlockComment - 128)) | (1L << (LineComment - 128)))) != 0)); + } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -88080385L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 262143L) != 0)); } } catch (RecognitionException re) { _localctx.exception = re; @@ -10023,6 +10144,7 @@ public final BalancedTokenSeqContext balancedTokenSeq() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BalancedtokenContext extends ParserRuleContext { public List LeftParen() { return getTokens(CPP14Parser.LeftParen); @@ -10288,7 +10410,7 @@ public final BalancedtokenContext balancedtoken() throws RecognitionException { { setState(1343); _la = _input.LA(1); - if (_la <= 0 || (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (RightParen - 85)) | (1L << (LeftBracket - 85)) | (1L << (RightBracket - 85)) | (1L << (LeftBrace - 85)) | (1L << (RightBrace - 85)))) != 0))) { + if (_la <= 0 || (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & 63L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -10320,6 +10442,7 @@ public final BalancedtokenContext balancedtoken() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitDeclaratorListContext extends ParserRuleContext { public List initDeclarator() { return getRuleContexts(InitDeclaratorContext.class); @@ -10393,6 +10516,7 @@ public final InitDeclaratorListContext initDeclaratorList() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitDeclaratorContext extends ParserRuleContext { public DeclaratorContext declarator() { return getRuleContext(DeclaratorContext.class, 0); @@ -10434,7 +10558,7 @@ public final InitDeclaratorContext initDeclarator() throws RecognitionException setState(1360); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (LeftBrace - 85)) | (1L << (Assign - 85)))) != 0)) { + if (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & 65553L) != 0)) { { setState(1359); initializer(); @@ -10452,6 +10576,7 @@ public final InitDeclaratorContext initDeclarator() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclaratorContext extends ParserRuleContext { public PointerDeclaratorContext pointerDeclarator() { return getRuleContext(PointerDeclaratorContext.class, 0); @@ -10525,6 +10650,7 @@ public final DeclaratorContext declarator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PointerDeclaratorContext extends ParserRuleContext { public NoPointerDeclaratorContext noPointerDeclarator() { return getRuleContext(NoPointerDeclaratorContext.class, 0); @@ -10613,6 +10739,7 @@ public final PointerDeclaratorContext pointerDeclarator() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoPointerDeclaratorContext extends ParserRuleContext { public DeclaratoridContext declaratorid() { return getRuleContext(DeclaratoridContext.class, 0); @@ -10753,7 +10880,7 @@ private NoPointerDeclaratorContext noPointerDeclarator(int _p) throws Recognitio setState(1395); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133137L) != 0) || _la == Identifier) { { setState(1394); constantExpression(); @@ -10794,6 +10921,7 @@ private NoPointerDeclaratorContext noPointerDeclarator(int _p) throws Recognitio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParametersAndQualifiersContext extends ParserRuleContext { public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); @@ -10857,7 +10985,7 @@ public final ParametersAndQualifiersContext parametersAndQualifiers() throws Rec setState(1410); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Struct - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftBracket - 74)) | (1L << (Doublecolon - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1237504995584196377L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 297237575406461917L) != 0)) { { setState(1409); parameterDeclarationClause(); @@ -10913,6 +11041,7 @@ public final ParametersAndQualifiersContext parametersAndQualifiers() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TrailingReturnTypeContext extends ParserRuleContext { public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); @@ -10976,6 +11105,7 @@ public final TrailingReturnTypeContext trailingReturnType() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PointerOperatorContext extends ParserRuleContext { public TerminalNode And() { return getToken(CPP14Parser.And, 0); @@ -11104,6 +11234,7 @@ public final PointerOperatorContext pointerOperator() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CvqualifierseqContext extends ParserRuleContext { public List cvQualifier() { return getRuleContexts(CvQualifierContext.class); @@ -11170,6 +11301,7 @@ public final CvqualifierseqContext cvqualifierseq() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CvQualifierContext extends ParserRuleContext { public TerminalNode Const() { return getToken(CPP14Parser.Const, 0); @@ -11226,6 +11358,7 @@ public final CvQualifierContext cvQualifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class RefqualifierContext extends ParserRuleContext { public TerminalNode And() { return getToken(CPP14Parser.And, 0); @@ -11282,6 +11415,7 @@ public final RefqualifierContext refqualifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclaratoridContext extends ParserRuleContext { public IdExpressionContext idExpression() { return getRuleContext(IdExpressionContext.class, 0); @@ -11341,6 +11475,7 @@ public final DeclaratoridContext declaratorid() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TheTypeIdContext extends ParserRuleContext { public TypeSpecifierSeqContext typeSpecifierSeq() { return getRuleContext(TypeSpecifierSeqContext.class, 0); @@ -11398,6 +11533,7 @@ public final TheTypeIdContext theTypeId() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AbstractDeclaratorContext extends ParserRuleContext { public PointerAbstractDeclaratorContext pointerAbstractDeclarator() { return getRuleContext(PointerAbstractDeclaratorContext.class, 0); @@ -11489,6 +11625,7 @@ public final AbstractDeclaratorContext abstractDeclarator() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PointerAbstractDeclaratorContext extends ParserRuleContext { public NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator() { return getRuleContext(NoPointerAbstractDeclaratorContext.class, 0); @@ -11561,7 +11698,7 @@ public final PointerAbstractDeclaratorContext pointerAbstractDeclarator() throws setState(1478); _errHandler.sync(this); _la = _input.LA(1); - } while (_la == Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (And - 93)) | (1L << (AndAnd - 93)) | (1L << (Doublecolon - 93)) | (1L << (Identifier - 93)))) != 0)); + } while (_la == Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 566969237521L) != 0)); setState(1481); _errHandler.sync(this); switch (getInterpreter().adaptivePredict(_input, 185, _ctx)) { @@ -11586,6 +11723,7 @@ public final PointerAbstractDeclaratorContext pointerAbstractDeclarator() throws return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoPointerAbstractDeclaratorContext extends ParserRuleContext { public ParametersAndQualifiersContext parametersAndQualifiers() { return getRuleContext(ParametersAndQualifiersContext.class, 0); @@ -11679,7 +11817,7 @@ private NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int _p) t setState(1489); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133137L) != 0) || _la == Identifier) { { setState(1488); constantExpression(); @@ -11739,7 +11877,7 @@ private NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int _p) t setState(1506); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133137L) != 0) || _la == Identifier) { { setState(1505); constantExpression(); @@ -11778,6 +11916,7 @@ private NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int _p) t return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AbstractPackDeclaratorContext extends ParserRuleContext { public NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator() { return getRuleContext(NoPointerAbstractPackDeclaratorContext.class, 0); @@ -11823,7 +11962,7 @@ public final AbstractPackDeclaratorContext abstractPackDeclarator() throws Recog setState(1522); _errHandler.sync(this); _la = _input.LA(1); - while (_la == Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (And - 93)) | (1L << (AndAnd - 93)) | (1L << (Doublecolon - 93)) | (1L << (Identifier - 93)))) != 0)) { + while (_la == Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 566969237521L) != 0)) { { { setState(1519); @@ -11847,6 +11986,7 @@ public final AbstractPackDeclaratorContext abstractPackDeclarator() throws Recog return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoPointerAbstractPackDeclaratorContext extends ParserRuleContext { public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); @@ -11946,7 +12086,7 @@ private NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator(i setState(1534); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133137L) != 0) || _la == Identifier) { { setState(1533); constantExpression(); @@ -11987,6 +12127,7 @@ private NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator(i return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParameterDeclarationClauseContext extends ParserRuleContext { public ParameterDeclarationListContext parameterDeclarationList() { return getRuleContext(ParameterDeclarationListContext.class, 0); @@ -12062,6 +12203,7 @@ public final ParameterDeclarationClauseContext parameterDeclarationClause() thro return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParameterDeclarationListContext extends ParserRuleContext { public List parameterDeclaration() { return getRuleContexts(ParameterDeclarationContext.class); @@ -12139,6 +12281,7 @@ public final ParameterDeclarationListContext parameterDeclarationList() throws R return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParameterDeclarationContext extends ParserRuleContext { public DeclSpecifierSeqContext declSpecifierSeq() { return getRuleContext(DeclSpecifierSeqContext.class, 0); @@ -12251,6 +12394,7 @@ public final ParameterDeclarationContext parameterDeclaration() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionDefinitionContext extends ParserRuleContext { public DeclaratorContext declarator() { return getRuleContext(DeclaratorContext.class, 0); @@ -12343,6 +12487,7 @@ public final FunctionDefinitionContext functionDefinition() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionBodyContext extends ParserRuleContext { public CompoundStatementContext compoundStatement() { return getRuleContext(CompoundStatementContext.class, 0); @@ -12456,6 +12601,7 @@ public final FunctionBodyContext functionBody() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitializerContext extends ParserRuleContext { public BraceOrEqualInitializerContext braceOrEqualInitializer() { return getRuleContext(BraceOrEqualInitializerContext.class, 0); @@ -12532,6 +12678,7 @@ public final InitializerContext initializer() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BraceOrEqualInitializerContext extends ParserRuleContext { public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); @@ -12603,6 +12750,7 @@ public final BraceOrEqualInitializerContext braceOrEqualInitializer() throws Rec return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitializerClauseContext extends ParserRuleContext { public AssignmentExpressionContext assignmentExpression() { return getRuleContext(AssignmentExpressionContext.class, 0); @@ -12714,6 +12862,7 @@ public final InitializerClauseContext initializerClause() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InitializerListContext extends ParserRuleContext { public List initializerClause() { return getRuleContexts(InitializerClauseContext.class); @@ -12818,6 +12967,7 @@ public final InitializerListContext initializerList() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BracedInitListContext extends ParserRuleContext { public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); @@ -12867,7 +13017,7 @@ public final BracedInitListContext bracedInitList() throws RecognitionException setState(1633); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474400910417L) != 0) || _la == Identifier) { { setState(1629); initializerList(); @@ -12897,6 +13047,7 @@ public final BracedInitListContext bracedInitList() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassNameContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -12958,6 +13109,7 @@ public final ClassNameContext className() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassSpecifierContext extends ParserRuleContext { public ClassHeadContext classHead() { return getRuleContext(ClassHeadContext.class, 0); @@ -13009,7 +13161,7 @@ public final ClassSpecifierContext classSpecifier() throws RecognitionException setState(1644); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Operator - 10)) | (1L << (Private - 10)) | (1L << (Protected - 10)) | (1L << (Public - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Colon - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543877313594212121L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 463888353847684093L) != 0)) { { setState(1643); memberSpecification(); @@ -13029,6 +13181,7 @@ public final ClassSpecifierContext classSpecifier() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassHeadContext extends ParserRuleContext { public ClassKeyContext classKey() { return getRuleContext(ClassKeyContext.class, 0); @@ -13180,6 +13333,7 @@ public final ClassHeadContext classHead() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassHeadNameContext extends ParserRuleContext { public ClassNameContext className() { return getRuleContext(ClassNameContext.class, 0); @@ -13237,6 +13391,7 @@ public final ClassHeadNameContext classHeadName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassVirtSpecifierContext extends ParserRuleContext { public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); @@ -13281,6 +13436,7 @@ public final ClassVirtSpecifierContext classVirtSpecifier() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassKeyContext extends ParserRuleContext { public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); @@ -13337,6 +13493,7 @@ public final ClassKeyContext classKey() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemberSpecificationContext extends ParserRuleContext { public List memberdeclaration() { return getRuleContexts(MemberdeclarationContext.class); @@ -13467,7 +13624,7 @@ public final MemberSpecificationContext memberSpecification() throws Recognition setState(1688); _errHandler.sync(this); _la = _input.LA(1); - } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Operator - 10)) | (1L << (Private - 10)) | (1L << (Protected - 10)) | (1L << (Public - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Colon - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)); + } while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 1543877313594212121L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 463888353847684093L) != 0)); } } catch (RecognitionException re) { _localctx.exception = re; @@ -13479,6 +13636,7 @@ public final MemberSpecificationContext memberSpecification() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemberdeclarationContext extends ParserRuleContext { public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); @@ -13572,7 +13730,7 @@ public final MemberdeclarationContext memberdeclaration() throws RecognitionExce setState(1697); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Decltype) | (1L << Operator))) != 0) || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (LeftBracket - 85)) | (1L << (Star - 85)) | (1L << (And - 85)) | (1L << (Tilde - 85)) | (1L << (AndAnd - 85)) | (1L << (Colon - 85)) | (1L << (Doublecolon - 85)) | (1L << (Ellipsis - 85)) | (1L << (Identifier - 85)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503599694480384L) != 0) || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & 217711892254981L) != 0)) { { setState(1696); memberDeclaratorList(); @@ -13636,6 +13794,7 @@ public final MemberdeclarationContext memberdeclaration() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemberDeclaratorListContext extends ParserRuleContext { public List memberDeclarator() { return getRuleContexts(MemberDeclaratorContext.class); @@ -13711,6 +13870,7 @@ public final MemberDeclaratorListContext memberDeclaratorList() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemberDeclaratorContext extends ParserRuleContext { public DeclaratorContext declarator() { return getRuleContext(DeclaratorContext.class, 0); @@ -13859,6 +14019,7 @@ public final MemberDeclaratorContext memberDeclarator() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class VirtualSpecifierSeqContext extends ParserRuleContext { public List virtualSpecifier() { return getRuleContexts(VirtualSpecifierContext.class); @@ -13921,6 +14082,7 @@ public final VirtualSpecifierSeqContext virtualSpecifierSeq() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class VirtualSpecifierContext extends ParserRuleContext { public TerminalNode Override() { return getToken(CPP14Parser.Override, 0); @@ -13977,6 +14139,7 @@ public final VirtualSpecifierContext virtualSpecifier() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PureSpecifierContext extends ParserRuleContext { public Token val; @@ -14032,6 +14195,7 @@ public final PureSpecifierContext pureSpecifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BaseClauseContext extends ParserRuleContext { public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); @@ -14082,6 +14246,7 @@ public final BaseClauseContext baseClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BaseSpecifierListContext extends ParserRuleContext { public List baseSpecifier() { return getRuleContexts(BaseSpecifierContext.class); @@ -14183,6 +14348,7 @@ public final BaseSpecifierListContext baseSpecifierList() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BaseSpecifierContext extends ParserRuleContext { public BaseTypeSpecifierContext baseTypeSpecifier() { return getRuleContext(BaseTypeSpecifierContext.class, 0); @@ -14253,7 +14419,7 @@ public final BaseSpecifierContext baseSpecifier() throws RecognitionException { setState(1772); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 126100789566373888L) != 0)) { { setState(1771); accessSpecifier(); @@ -14297,6 +14463,7 @@ public final BaseSpecifierContext baseSpecifier() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClassOrDeclTypeContext extends ParserRuleContext { public ClassNameContext className() { return getRuleContext(ClassNameContext.class, 0); @@ -14371,6 +14538,7 @@ public final ClassOrDeclTypeContext classOrDeclType() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BaseTypeSpecifierContext extends ParserRuleContext { public ClassOrDeclTypeContext classOrDeclType() { return getRuleContext(ClassOrDeclTypeContext.class, 0); @@ -14415,6 +14583,7 @@ public final BaseTypeSpecifierContext baseTypeSpecifier() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AccessSpecifierContext extends ParserRuleContext { public TerminalNode Private() { return getToken(CPP14Parser.Private, 0); @@ -14457,7 +14626,7 @@ public final AccessSpecifierContext accessSpecifier() throws RecognitionExceptio { setState(1792); _la = _input.LA(1); - if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0))) { + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 126100789566373888L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -14475,6 +14644,7 @@ public final AccessSpecifierContext accessSpecifier() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConversionFunctionIdContext extends ParserRuleContext { public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); @@ -14527,6 +14697,7 @@ public final ConversionFunctionIdContext conversionFunctionId() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConversionTypeIdContext extends ParserRuleContext { public TypeSpecifierSeqContext typeSpecifierSeq() { return getRuleContext(TypeSpecifierSeqContext.class, 0); @@ -14584,6 +14755,7 @@ public final ConversionTypeIdContext conversionTypeId() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConversionDeclaratorContext extends ParserRuleContext { public PointerOperatorContext pointerOperator() { return getRuleContext(PointerOperatorContext.class, 0); @@ -14643,6 +14815,7 @@ public final ConversionDeclaratorContext conversionDeclarator() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConstructorInitializerContext extends ParserRuleContext { public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); @@ -14695,6 +14868,7 @@ public final ConstructorInitializerContext constructorInitializer() throws Recog return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemInitializerListContext extends ParserRuleContext { public List memInitializer() { return getRuleContexts(MemInitializerContext.class); @@ -14796,6 +14970,7 @@ public final MemInitializerListContext memInitializerList() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MemInitializerContext extends ParserRuleContext { public MeminitializeridContext meminitializerid() { return getRuleContext(MeminitializeridContext.class, 0); @@ -14855,7 +15030,7 @@ public final MemInitializerContext memInitializer() throws RecognitionException setState(1825); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474400910417L) != 0) || _la == Identifier) { { setState(1824); expressionList(); @@ -14885,6 +15060,7 @@ public final MemInitializerContext memInitializer() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MeminitializeridContext extends ParserRuleContext { public ClassOrDeclTypeContext classOrDeclType() { return getRuleContext(ClassOrDeclTypeContext.class, 0); @@ -14946,6 +15122,7 @@ public final MeminitializeridContext meminitializerid() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OperatorFunctionIdContext extends ParserRuleContext { public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); @@ -14996,6 +15173,7 @@ public final OperatorFunctionIdContext operatorFunctionId() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LiteralOperatorIdContext extends ParserRuleContext { public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); @@ -15070,6 +15248,7 @@ public final LiteralOperatorIdContext literalOperatorId() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateDeclarationContext extends ParserRuleContext { public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); @@ -15139,6 +15318,7 @@ public final TemplateDeclarationContext templateDeclaration() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateparameterListContext extends ParserRuleContext { public List templateParameter() { return getRuleContexts(TemplateParameterContext.class); @@ -15214,6 +15394,7 @@ public final TemplateparameterListContext templateparameterList() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateParameterContext extends ParserRuleContext { public TypeParameterContext typeParameter() { return getRuleContext(TypeParameterContext.class, 0); @@ -15275,6 +15456,7 @@ public final TemplateParameterContext templateParameter() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeParameterContext extends ParserRuleContext { public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); @@ -15435,6 +15617,7 @@ public final TypeParameterContext typeParameter() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SimpleTemplateIdContext extends ParserRuleContext { public TemplateNameContext templateName() { return getRuleContext(TemplateNameContext.class, 0); @@ -15486,7 +15669,7 @@ public final SimpleTemplateIdContext simpleTemplateId() throws RecognitionExcept setState(1889); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979472930990334L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384268307L) != 0) || _la == Identifier) { { setState(1888); templateArgumentList(); @@ -15506,6 +15689,7 @@ public final SimpleTemplateIdContext simpleTemplateId() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateIdContext extends ParserRuleContext { public SimpleTemplateIdContext simpleTemplateId() { return getRuleContext(SimpleTemplateIdContext.class, 0); @@ -15588,7 +15772,7 @@ public final TemplateIdContext templateId() throws RecognitionException { setState(1900); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979472930990334L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384268307L) != 0) || _la == Identifier) { { setState(1899); templateArgumentList(); @@ -15612,6 +15796,7 @@ public final TemplateIdContext templateId() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateNameContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); @@ -15656,6 +15841,7 @@ public final TemplateNameContext templateName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateArgumentListContext extends ParserRuleContext { public List templateArgument() { return getRuleContexts(TemplateArgumentContext.class); @@ -15759,6 +15945,7 @@ public final TemplateArgumentListContext templateArgumentList() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TemplateArgumentContext extends ParserRuleContext { public TheTypeIdContext theTypeId() { return getRuleContext(TheTypeIdContext.class, 0); @@ -15831,6 +16018,7 @@ public final TemplateArgumentContext templateArgument() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeNameSpecifierContext extends ParserRuleContext { public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); @@ -15918,6 +16106,7 @@ public final TypeNameSpecifierContext typeNameSpecifier() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExplicitInstantiationContext extends ParserRuleContext { public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); @@ -15985,6 +16174,7 @@ public final ExplicitInstantiationContext explicitInstantiation() throws Recogni return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExplicitSpecializationContext extends ParserRuleContext { public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); @@ -16049,6 +16239,7 @@ public final ExplicitSpecializationContext explicitSpecialization() throws Recog return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TryBlockContext extends ParserRuleContext { public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); @@ -16105,6 +16296,7 @@ public final TryBlockContext tryBlock() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionTryBlockContext extends ParserRuleContext { public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); @@ -16176,6 +16368,7 @@ public final FunctionTryBlockContext functionTryBlock() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class HandlerSeqContext extends ParserRuleContext { public List handler() { return getRuleContexts(HandlerContext.class); @@ -16237,6 +16430,7 @@ public final HandlerSeqContext handlerSeq() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class HandlerContext extends ParserRuleContext { public TerminalNode Catch() { return getToken(CPP14Parser.Catch, 0); @@ -16305,6 +16499,7 @@ public final HandlerContext handler() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExceptionDeclarationContext extends ParserRuleContext { public TypeSpecifierSeqContext typeSpecifierSeq() { return getRuleContext(TypeSpecifierSeqContext.class, 0); @@ -16432,6 +16627,7 @@ public final ExceptionDeclarationContext exceptionDeclaration() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ThrowExpressionContext extends ParserRuleContext { public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); @@ -16473,7 +16669,7 @@ public final ThrowExpressionContext throwExpression() throws RecognitionExceptio setState(1982); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la == Identifier) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8364979464334764286L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4719772474384133201L) != 0) || _la == Identifier) { { setState(1981); assignmentExpression(); @@ -16491,6 +16687,7 @@ public final ThrowExpressionContext throwExpression() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExceptionSpecificationContext extends ParserRuleContext { public DynamicExceptionSpecificationContext dynamicExceptionSpecification() { return getRuleContext(DynamicExceptionSpecificationContext.class, 0); @@ -16556,6 +16753,7 @@ public final ExceptionSpecificationContext exceptionSpecification() throws Recog return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DynamicExceptionSpecificationContext extends ParserRuleContext { public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); @@ -16609,7 +16807,7 @@ public final DynamicExceptionSpecificationContext dynamicExceptionSpecification( setState(1991); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (Auto - 13)) | (1L << (Bool - 13)) | (1L << (Char - 13)) | (1L << (Char16 - 13)) | (1L << (Char32 - 13)) | (1L << (Class - 13)) | (1L << (Const - 13)) | (1L << (Decltype - 13)) | (1L << (Double - 13)) | (1L << (Enum - 13)) | (1L << (Float - 13)) | (1L << (Int - 13)) | (1L << (Long - 13)) | (1L << (Short - 13)) | (1L << (Signed - 13)) | (1L << (Struct - 13)) | (1L << (Typename_ - 13)))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Union - 77)) | (1L << (Unsigned - 77)) | (1L << (Void - 77)) | (1L << (Volatile - 77)) | (1L << (Wchar - 77)) | (1L << (Doublecolon - 77)) | (1L << (Identifier - 77)))) != 0)) { + if (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & -9213942612181769245L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 37154696925806707L) != 0)) { { setState(1990); typeIdList(); @@ -16629,6 +16827,7 @@ public final DynamicExceptionSpecificationContext dynamicExceptionSpecification( return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeIdListContext extends ParserRuleContext { public List theTypeId() { return getRuleContexts(TheTypeIdContext.class); @@ -16730,6 +16929,7 @@ public final TypeIdListContext typeIdList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NoeExceptSpecificationContext extends ParserRuleContext { public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); @@ -16807,6 +17007,7 @@ public final NoeExceptSpecificationContext noeExceptSpecification() throws Recog return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TheOperatorContext extends ParserRuleContext { public TerminalNode New() { return getToken(CPP14Parser.New, 0); @@ -17327,6 +17528,7 @@ public final TheOperatorContext theOperator() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LiteralContext extends ParserRuleContext { public TerminalNode IntegerLiteral() { return getToken(CPP14Parser.IntegerLiteral, 0); @@ -17385,7 +17587,7 @@ public final LiteralContext literal() throws RecognitionException { { setState(2072); _la = _input.LA(1); - if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral))) != 0))) { + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 254L) != 0))) { _errHandler.recoverInline(this); } else { if (_input.LA(1) == Token.EOF) matchedEOF = true; @@ -17476,889 +17678,1424 @@ private boolean noPointerAbstractPackDeclarator_sempred(NoPointerAbstractPackDec } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0093\u081d\4\2\t" + - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13" + - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31" + - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!" + - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4" + - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t" + - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=" + - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I" + - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT" + - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4" + - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t" + - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4" + - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080" + - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085" + - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089" + - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e" + - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092" + - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097" + - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b" + - "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0" + - "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4" + - "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9" + - "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad" + - "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2" + - "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6" + - "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb" + - "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\3\2\5\2\u017e" + - "\n\2\3\2\3\2\3\3\6\3\u0183\n\3\r\3\16\3\u0184\3\3\3\3\3\3\3\3\3\3\3\3" + - "\3\3\5\3\u018e\n\3\3\4\3\4\5\4\u0192\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5" + - "\5\u019b\n\5\3\5\5\5\u019e\n\5\3\6\3\6\5\6\u01a2\n\6\3\6\3\6\3\7\3\7\3" + - "\7\3\7\5\7\u01aa\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u01b1\n\7\3\7\5\7\u01b4\n" + - "\7\3\7\7\7\u01b7\n\7\f\7\16\7\u01ba\13\7\3\b\3\b\5\b\u01be\n\b\3\b\3\b" + - "\3\t\3\t\5\t\u01c4\n\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u01cc\n\n\5\n\u01ce" + - "\n\n\3\13\3\13\3\f\3\f\3\f\7\f\u01d5\n\f\f\f\16\f\u01d8\13\f\3\f\5\f\u01db" + - "\n\f\3\r\3\r\5\r\u01df\n\r\3\16\5\16\u01e2\n\16\3\16\3\16\5\16\u01e6\n" + - "\16\3\17\5\17\u01e9\n\17\3\17\3\17\3\17\3\20\3\20\5\20\u01f0\n\20\3\20" + - "\3\20\5\20\u01f4\n\20\3\20\5\20\u01f7\n\20\3\20\5\20\u01fa\n\20\3\20\5" + - "\20\u01fd\n\20\3\21\3\21\3\21\3\21\5\21\u0203\n\21\3\21\3\21\5\21\u0207" + - "\n\21\3\21\3\21\5\21\u020b\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21" + - "\3\21\3\21\3\21\3\21\5\21\u0219\n\21\3\21\3\21\5\21\u021d\n\21\3\21\3" + - "\21\3\21\3\21\5\21\u0223\n\21\3\21\3\21\3\21\3\21\3\21\5\21\u022a\n\21" + - "\3\21\3\21\3\21\3\21\5\21\u0230\n\21\3\21\3\21\5\21\u0234\n\21\3\21\3" + - "\21\7\21\u0238\n\21\f\21\16\21\u023b\13\21\3\22\3\22\3\23\3\23\3\24\5" + - "\24\u0242\n\24\3\24\3\24\3\24\5\24\u0247\n\24\3\24\3\24\3\24\3\24\3\24" + - "\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u0254\n\24\3\25\3\25\3\25\3\25\3\25" + - "\5\25\u025b\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25" + - "\u0267\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u0271\n\25\3" + - "\26\3\26\3\27\5\27\u0276\n\27\3\27\3\27\5\27\u027a\n\27\3\27\3\27\3\27" + - "\3\27\3\27\5\27\u0281\n\27\3\27\5\27\u0284\n\27\3\30\3\30\3\30\3\30\3" + - "\31\3\31\5\31\u028c\n\31\3\32\3\32\5\32\u0290\n\32\3\32\5\32\u0293\n\32" + - "\3\33\3\33\3\33\3\33\3\33\5\33\u029a\n\33\3\33\3\33\3\33\3\33\3\33\5\33" + - "\u02a1\n\33\7\33\u02a3\n\33\f\33\16\33\u02a6\13\33\3\34\3\34\5\34\u02aa" + - "\n\34\3\34\3\34\5\34\u02ae\n\34\3\35\5\35\u02b1\n\35\3\35\3\35\3\35\5" + - "\35\u02b6\n\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37" + - "\3\37\3\37\5\37\u02c5\n\37\3 \3 \3 \7 \u02ca\n \f \16 \u02cd\13 \3!\3" + - "!\3!\7!\u02d2\n!\f!\16!\u02d5\13!\3\"\3\"\3\"\7\"\u02da\n\"\f\"\16\"\u02dd" + - "\13\"\3#\3#\3#\3#\7#\u02e3\n#\f#\16#\u02e6\13#\3$\3$\3$\3$\5$\u02ec\n" + - "$\3%\3%\3%\7%\u02f1\n%\f%\16%\u02f4\13%\3&\3&\3&\7&\u02f9\n&\f&\16&\u02fc" + - "\13&\3\'\3\'\3\'\7\'\u0301\n\'\f\'\16\'\u0304\13\'\3(\3(\3(\7(\u0309\n" + - "(\f(\16(\u030c\13(\3)\3)\3)\7)\u0311\n)\f)\16)\u0314\13)\3*\3*\3*\7*\u0319" + - "\n*\f*\16*\u031c\13*\3+\3+\3+\7+\u0321\n+\f+\16+\u0324\13+\3,\3,\3,\3" + - ",\3,\3,\5,\u032c\n,\3-\3-\3-\3-\3-\3-\5-\u0334\n-\3.\3.\3/\3/\3/\7/\u033b" + - "\n/\f/\16/\u033e\13/\3\60\3\60\3\61\3\61\5\61\u0344\n\61\3\61\3\61\3\61" + - "\3\61\3\61\3\61\5\61\u034c\n\61\3\61\5\61\u034f\n\61\3\62\5\62\u0352\n" + - "\62\3\62\3\62\3\62\3\62\5\62\u0358\n\62\3\62\3\62\3\62\3\63\5\63\u035e" + - "\n\63\3\63\3\63\3\64\3\64\5\64\u0364\n\64\3\64\3\64\3\65\6\65\u0369\n" + - "\65\r\65\16\65\u036a\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u0374\n\66" + - "\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u037c\n\66\3\67\3\67\5\67\u0380\n" + - "\67\3\67\3\67\3\67\3\67\3\67\5\67\u0387\n\67\5\67\u0389\n\67\38\38\38" + - "\38\38\38\38\38\38\38\38\38\38\38\38\38\38\38\58\u039d\n8\38\38\58\u03a1" + - "\n8\38\38\38\38\58\u03a7\n8\38\38\38\58\u03ac\n8\39\39\59\u03b0\n9\3:" + - "\5:\u03b3\n:\3:\3:\3:\3;\3;\5;\u03ba\n;\3<\3<\3<\3<\3<\5<\u03c1\n<\3<" + - "\3<\5<\u03c5\n<\3<\3<\3=\3=\3>\6>\u03cc\n>\r>\16>\u03cd\3?\3?\3?\3?\3" + - "?\3?\3?\3?\3?\5?\u03d9\n?\3@\3@\3@\3@\3@\3@\3@\3@\5@\u03e3\n@\3A\3A\3" + - "A\5A\u03e8\nA\3A\3A\3A\3A\3B\5B\u03ef\nB\3B\5B\u03f2\nB\3B\3B\3B\5B\u03f7" + - "\nB\3B\3B\3B\5B\u03fc\nB\3C\3C\3C\3C\3C\3C\3C\3C\3D\3D\3E\3E\3E\3F\3F" + - "\3F\3F\3F\3F\5F\u0411\nF\3G\6G\u0414\nG\rG\16G\u0415\3G\5G\u0419\nG\3" + - "H\3H\3I\3I\3J\3J\3K\3K\3K\5K\u0424\nK\3L\3L\3L\3L\5L\u042a\nL\3M\6M\u042d" + - "\nM\rM\16M\u042e\3M\5M\u0432\nM\3N\6N\u0435\nN\rN\16N\u0436\3N\5N\u043a" + - "\nN\3O\5O\u043d\nO\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O" + - "\3O\3O\3O\5O\u0453\nO\3P\3P\3P\3P\5P\u0459\nP\3Q\3Q\3Q\3Q\5Q\u045f\nQ" + - "\3Q\3Q\3R\3R\5R\u0465\nR\3R\5R\u0468\nR\3R\3R\3R\3R\5R\u046e\nR\3R\3R" + - "\5R\u0472\nR\3R\3R\5R\u0476\nR\3R\5R\u0479\nR\3S\3S\3T\3T\3T\3T\5T\u0481" + - "\nT\5T\u0483\nT\3T\3T\3U\3U\5U\u0489\nU\3U\5U\u048c\nU\3U\5U\u048f\nU" + - "\3U\5U\u0492\nU\3V\3V\5V\u0496\nV\3V\3V\5V\u049a\nV\3V\3V\3W\3W\5W\u04a0" + - "\nW\3X\3X\3X\3Y\3Y\3Y\7Y\u04a8\nY\fY\16Y\u04ab\13Y\3Z\3Z\3Z\5Z\u04b0\n" + - "Z\3[\3[\3\\\3\\\5\\\u04b6\n\\\3]\3]\3^\5^\u04bb\n^\3^\3^\3^\5^\u04c0\n" + - "^\3^\3^\5^\u04c4\n^\3^\3^\3_\3_\3`\3`\3`\3`\3`\3`\3a\5a\u04d1\na\3a\3" + - "a\3b\3b\5b\u04d7\nb\3b\3b\5b\u04db\nb\3b\3b\3b\3c\5c\u04e1\nc\3c\3c\3" + - "c\5c\u04e6\nc\3c\3c\3c\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\5e\u04f5\ne\3e\3" + - "e\5e\u04f9\ne\3f\6f\u04fc\nf\rf\16f\u04fd\3g\3g\3g\5g\u0503\ng\3g\3g\3" + - "g\5g\u0508\ng\3h\3h\3h\3h\5h\u050e\nh\3h\5h\u0511\nh\3h\3h\3i\3i\3i\7" + - "i\u0518\ni\fi\16i\u051b\13i\3i\5i\u051e\ni\3j\3j\3j\5j\u0523\nj\3j\3j" + - "\5j\u0527\nj\3k\3k\3l\3l\5l\u052d\nl\3l\3l\3m\6m\u0532\nm\rm\16m\u0533" + - "\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\6n\u0543\nn\rn\16n\u0544\5n\u0547" + - "\nn\3o\3o\3o\7o\u054c\no\fo\16o\u054f\13o\3p\3p\5p\u0553\np\3q\3q\3q\3" + - "q\3q\5q\u055a\nq\3r\3r\5r\u055e\nr\7r\u0560\nr\fr\16r\u0563\13r\3r\3r" + - "\3s\3s\3s\5s\u056a\ns\3s\3s\3s\3s\5s\u0570\ns\3s\3s\3s\3s\5s\u0576\ns" + - "\3s\3s\5s\u057a\ns\5s\u057c\ns\7s\u057e\ns\fs\16s\u0581\13s\3t\3t\5t\u0585" + - "\nt\3t\3t\5t\u0589\nt\3t\5t\u058c\nt\3t\5t\u058f\nt\3t\5t\u0592\nt\3u" + - "\3u\3u\5u\u0597\nu\3v\3v\5v\u059b\nv\3v\5v\u059e\nv\3v\3v\5v\u05a2\nv" + - "\3v\5v\u05a5\nv\5v\u05a7\nv\3w\6w\u05aa\nw\rw\16w\u05ab\3x\3x\3y\3y\3" + - "z\5z\u05b3\nz\3z\3z\3{\3{\5{\u05b9\n{\3|\3|\5|\u05bd\n|\3|\3|\3|\3|\5" + - "|\u05c3\n|\3}\3}\6}\u05c7\n}\r}\16}\u05c8\3}\5}\u05cc\n}\5}\u05ce\n}\3" + - "~\3~\3~\3~\5~\u05d4\n~\3~\3~\5~\u05d8\n~\3~\3~\3~\3~\5~\u05de\n~\3~\3" + - "~\3~\3~\3~\5~\u05e5\n~\3~\3~\5~\u05e9\n~\5~\u05eb\n~\7~\u05ed\n~\f~\16" + - "~\u05f0\13~\3\177\7\177\u05f3\n\177\f\177\16\177\u05f6\13\177\3\177\3" + - "\177\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u0601" + - "\n\u0080\3\u0080\3\u0080\5\u0080\u0605\n\u0080\5\u0080\u0607\n\u0080\7" + - "\u0080\u0609\n\u0080\f\u0080\16\u0080\u060c\13\u0080\3\u0081\3\u0081\5" + - "\u0081\u0610\n\u0081\3\u0081\5\u0081\u0613\n\u0081\3\u0082\3\u0082\3\u0082" + - "\7\u0082\u0618\n\u0082\f\u0082\16\u0082\u061b\13\u0082\3\u0083\5\u0083" + - "\u061e\n\u0083\3\u0083\3\u0083\3\u0083\5\u0083\u0623\n\u0083\5\u0083\u0625" + - "\n\u0083\3\u0083\3\u0083\5\u0083\u0629\n\u0083\3\u0084\5\u0084\u062c\n" + - "\u0084\3\u0084\5\u0084\u062f\n\u0084\3\u0084\3\u0084\5\u0084\u0633\n\u0084" + - "\3\u0084\3\u0084\3\u0085\5\u0085\u0638\n\u0085\3\u0085\3\u0085\3\u0085" + - "\3\u0085\3\u0085\5\u0085\u063f\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086" + - "\3\u0086\5\u0086\u0646\n\u0086\3\u0087\3\u0087\3\u0087\5\u0087\u064b\n" + - "\u0087\3\u0088\3\u0088\5\u0088\u064f\n\u0088\3\u0089\3\u0089\5\u0089\u0653" + - "\n\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u0658\n\u0089\7\u0089\u065a\n" + - "\u0089\f\u0089\16\u0089\u065d\13\u0089\3\u008a\3\u008a\3\u008a\5\u008a" + - "\u0662\n\u008a\5\u008a\u0664\n\u008a\3\u008a\3\u008a\3\u008b\3\u008b\5" + - "\u008b\u066a\n\u008b\3\u008c\3\u008c\3\u008c\5\u008c\u066f\n\u008c\3\u008c" + - "\3\u008c\3\u008d\3\u008d\5\u008d\u0675\n\u008d\3\u008d\3\u008d\5\u008d" + - "\u0679\n\u008d\5\u008d\u067b\n\u008d\3\u008d\5\u008d\u067e\n\u008d\3\u008d" + - "\3\u008d\5\u008d\u0682\n\u008d\3\u008d\3\u008d\5\u008d\u0686\n\u008d\5" + - "\u008d\u0688\n\u008d\5\u008d\u068a\n\u008d\3\u008e\5\u008e\u068d\n\u008e" + - "\3\u008e\3\u008e\3\u008f\3\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091" + - "\3\u0091\6\u0091\u0699\n\u0091\r\u0091\16\u0091\u069a\3\u0092\5\u0092" + - "\u069e\n\u0092\3\u0092\5\u0092\u06a1\n\u0092\3\u0092\5\u0092\u06a4\n\u0092" + - "\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\5\u0092\u06ad" + - "\n\u0092\3\u0093\3\u0093\3\u0093\7\u0093\u06b2\n\u0093\f\u0093\16\u0093" + - "\u06b5\13\u0093\3\u0094\3\u0094\5\u0094\u06b9\n\u0094\3\u0094\5\u0094" + - "\u06bc\n\u0094\3\u0094\5\u0094\u06bf\n\u0094\5\u0094\u06c1\n\u0094\3\u0094" + - "\5\u0094\u06c4\n\u0094\3\u0094\5\u0094\u06c7\n\u0094\3\u0094\3\u0094\5" + - "\u0094\u06cb\n\u0094\3\u0095\6\u0095\u06ce\n\u0095\r\u0095\16\u0095\u06cf" + - "\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098" + - "\3\u0099\3\u0099\5\u0099\u06dd\n\u0099\3\u0099\3\u0099\3\u0099\5\u0099" + - "\u06e2\n\u0099\7\u0099\u06e4\n\u0099\f\u0099\16\u0099\u06e7\13\u0099\3" + - "\u009a\5\u009a\u06ea\n\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u06ef\n\u009a" + - "\3\u009a\3\u009a\3\u009a\5\u009a\u06f4\n\u009a\3\u009a\3\u009a\5\u009a" + - "\u06f8\n\u009a\3\u009b\5\u009b\u06fb\n\u009b\3\u009b\3\u009b\5\u009b\u06ff" + - "\n\u009b\3\u009c\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e\3\u009f" + - "\3\u009f\5\u009f\u070a\n\u009f\3\u00a0\3\u00a0\5\u00a0\u070e\n\u00a0\3" + - "\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\5\u00a2\u0715\n\u00a2\3\u00a2\3" + - "\u00a2\3\u00a2\5\u00a2\u071a\n\u00a2\7\u00a2\u071c\n\u00a2\f\u00a2\16" + - "\u00a2\u071f\13\u00a2\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u0724\n\u00a3\3" + - "\u00a3\3\u00a3\5\u00a3\u0728\n\u00a3\3\u00a4\3\u00a4\5\u00a4\u072c\n\u00a4" + - "\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u0735" + - "\n\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8" + - "\3\u00a8\7\u00a8\u0740\n\u00a8\f\u00a8\16\u00a8\u0743\13\u00a8\3\u00a9" + - "\3\u00a9\5\u00a9\u0747\n\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa" + - "\5\u00aa\u074e\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0752\n\u00aa\3\u00aa\5" + - "\u00aa\u0755\n\u00aa\3\u00aa\5\u00aa\u0758\n\u00aa\3\u00aa\5\u00aa\u075b" + - "\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u075f\n\u00aa\3\u00ab\3\u00ab\3\u00ab" + - "\5\u00ab\u0764\n\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\5\u00ac" + - "\u076b\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u076f\n\u00ac\3\u00ac\3\u00ac\5" + - "\u00ac\u0773\n\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\5\u00ae\u0779\n\u00ae" + - "\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u077e\n\u00ae\7\u00ae\u0780\n\u00ae\f" + - "\u00ae\16\u00ae\u0783\13\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u0788\n" + - "\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\5\u00b0\u078e\n\u00b0\3\u00b0\5" + - "\u00b0\u0791\n\u00b0\3\u00b1\5\u00b1\u0794\n\u00b1\3\u00b1\3\u00b1\3\u00b1" + - "\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3" + - "\3\u00b4\3\u00b4\5\u00b4\u07a4\n\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5" + - "\6\u00b5\u07aa\n\u00b5\r\u00b5\16\u00b5\u07ab\3\u00b6\3\u00b6\3\u00b6" + - "\3\u00b6\3\u00b6\3\u00b6\3\u00b7\5\u00b7\u07b5\n\u00b7\3\u00b7\3\u00b7" + - "\3\u00b7\5\u00b7\u07ba\n\u00b7\3\u00b7\5\u00b7\u07bd\n\u00b7\3\u00b8\3" + - "\u00b8\5\u00b8\u07c1\n\u00b8\3\u00b9\3\u00b9\5\u00b9\u07c5\n\u00b9\3\u00ba" + - "\3\u00ba\3\u00ba\5\u00ba\u07ca\n\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb" + - "\5\u00bb\u07d0\n\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u07d5\n\u00bb\7" + - "\u00bb\u07d7\n\u00bb\f\u00bb\16\u00bb\u07da\13\u00bb\3\u00bc\3\u00bc\3" + - "\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u07e2\n\u00bc\3\u00bd\3\u00bd\3" + - "\u00bd\5\u00bd\u07e7\n\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u07ec\n\u00bd" + - "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd" + - "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd" + - "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd" + - "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd" + - "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u0819" + - "\n\u00bd\3\u00be\3\u00be\3\u00be\2\b\f \64\u00e4\u00fa\u00fe\u00bf\2\4" + - "\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNP" + - "RTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e" + - "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6" + - "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be" + - "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6" + - "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee" + - "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106" + - "\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e" + - "\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136" + - "\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e" + - "\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166" + - "\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\2\27\4\2" + - "ccgg\6\2\32\32!!<\u02c6" + - "\3\2\2\2@\u02ce\3\2\2\2B\u02d6\3\2\2\2D\u02de\3\2\2\2F\u02eb\3\2\2\2H" + - "\u02ed\3\2\2\2J\u02f5\3\2\2\2L\u02fd\3\2\2\2N\u0305\3\2\2\2P\u030d\3\2" + - "\2\2R\u0315\3\2\2\2T\u031d\3\2\2\2V\u0325\3\2\2\2X\u0333\3\2\2\2Z\u0335" + - "\3\2\2\2\\\u0337\3\2\2\2^\u033f\3\2\2\2`\u034e\3\2\2\2b\u0351\3\2\2\2" + - "d\u035d\3\2\2\2f\u0361\3\2\2\2h\u0368\3\2\2\2j\u037b\3\2\2\2l\u0388\3" + - "\2\2\2n\u03ab\3\2\2\2p\u03af\3\2\2\2r\u03b2\3\2\2\2t\u03b9\3\2\2\2v\u03c4" + - "\3\2\2\2x\u03c8\3\2\2\2z\u03cb\3\2\2\2|\u03d8\3\2\2\2~\u03e2\3\2\2\2\u0080" + - "\u03e4\3\2\2\2\u0082\u03fb\3\2\2\2\u0084\u03fd\3\2\2\2\u0086\u0405\3\2" + - "\2\2\u0088\u0407\3\2\2\2\u008a\u0410\3\2\2\2\u008c\u0413\3\2\2\2\u008e" + - "\u041a\3\2\2\2\u0090\u041c\3\2\2\2\u0092\u041e\3\2\2\2\u0094\u0423\3\2" + - "\2\2\u0096\u0429\3\2\2\2\u0098\u042c\3\2\2\2\u009a\u0434\3\2\2\2\u009c" + - "\u0452\3\2\2\2\u009e\u0458\3\2\2\2\u00a0\u045a\3\2\2\2\u00a2\u0478\3\2" + - "\2\2\u00a4\u047a\3\2\2\2\u00a6\u047c\3\2\2\2\u00a8\u0486\3\2\2\2\u00aa" + - "\u0493\3\2\2\2\u00ac\u049d\3\2\2\2\u00ae\u04a1\3\2\2\2\u00b0\u04a4\3\2" + - "\2\2\u00b2\u04ac\3\2\2\2\u00b4\u04b1\3\2\2\2\u00b6\u04b5\3\2\2\2\u00b8" + - "\u04b7\3\2\2\2\u00ba\u04ba\3\2\2\2\u00bc\u04c7\3\2\2\2\u00be\u04c9\3\2" + - "\2\2\u00c0\u04d0\3\2\2\2\u00c2\u04d4\3\2\2\2\u00c4\u04e0\3\2\2\2\u00c6" + - "\u04ea\3\2\2\2\u00c8\u04f0\3\2\2\2\u00ca\u04fb\3\2\2\2\u00cc\u0507\3\2" + - "\2\2\u00ce\u0509\3\2\2\2\u00d0\u0514\3\2\2\2\u00d2\u0522\3\2\2\2\u00d4" + - "\u0528\3\2\2\2\u00d6\u052a\3\2\2\2\u00d8\u0531\3\2\2\2\u00da\u0546\3\2" + - "\2\2\u00dc\u0548\3\2\2\2\u00de\u0550\3\2\2\2\u00e0\u0559\3\2\2\2\u00e2" + - "\u0561\3\2\2\2\u00e4\u056f\3\2\2\2\u00e6\u0582\3\2\2\2\u00e8\u0593\3\2" + - "\2\2\u00ea\u05a6\3\2\2\2\u00ec\u05a9\3\2\2\2\u00ee\u05ad\3\2\2\2\u00f0" + - "\u05af\3\2\2\2\u00f2\u05b2\3\2\2\2\u00f4\u05b6\3\2\2\2\u00f6\u05c2\3\2" + - "\2\2\u00f8\u05cd\3\2\2\2\u00fa\u05dd\3\2\2\2\u00fc\u05f4\3\2\2\2\u00fe" + - "\u05f9\3\2\2\2\u0100\u060d\3\2\2\2\u0102\u0614\3\2\2\2\u0104\u061d\3\2" + - "\2\2\u0106\u062b\3\2\2\2\u0108\u063e\3\2\2\2\u010a\u0645\3\2\2\2\u010c" + - "\u064a\3\2\2\2\u010e\u064e\3\2\2\2\u0110\u0650\3\2\2\2\u0112\u065e\3\2" + - "\2\2\u0114\u0669\3\2\2\2\u0116\u066b\3\2\2\2\u0118\u0689\3\2\2\2\u011a" + - "\u068c\3\2\2\2\u011c\u0690\3\2\2\2\u011e\u0692\3\2\2\2\u0120\u0698\3\2" + - "\2\2\u0122\u06ac\3\2\2\2\u0124\u06ae\3\2\2\2\u0126\u06ca\3\2\2\2\u0128" + - "\u06cd\3\2\2\2\u012a\u06d1\3\2\2\2\u012c\u06d3\3\2\2\2\u012e\u06d7\3\2" + - "\2\2\u0130\u06da\3\2\2\2\u0132\u06e9\3\2\2\2\u0134\u06fe\3\2\2\2\u0136" + - "\u0700\3\2\2\2\u0138\u0702\3\2\2\2\u013a\u0704\3\2\2\2\u013c\u0707\3\2" + - "\2\2\u013e\u070b\3\2\2\2\u0140\u070f\3\2\2\2\u0142\u0712\3\2\2\2\u0144" + - "\u0720\3\2\2\2\u0146\u072b\3\2\2\2\u0148\u072d\3\2\2\2\u014a\u0730\3\2" + - "\2\2\u014c\u0736\3\2\2\2\u014e\u073c\3\2\2\2\u0150\u0746\3\2\2\2\u0152" + - "\u0751\3\2\2\2\u0154\u0760\3\2\2\2\u0156\u0772\3\2\2\2\u0158\u0774\3\2" + - "\2\2\u015a\u0776\3\2\2\2\u015c\u0787\3\2\2\2\u015e\u0789\3\2\2\2\u0160" + - "\u0793\3\2\2\2\u0162\u0798\3\2\2\2\u0164\u079d\3\2\2\2\u0166\u07a1\3\2" + - "\2\2\u0168\u07a9\3\2\2\2\u016a\u07ad\3\2\2\2\u016c\u07bc\3\2\2\2\u016e" + - "\u07be\3\2\2\2\u0170\u07c4\3\2\2\2\u0172\u07c6\3\2\2\2\u0174\u07cd\3\2" + - "\2\2\u0176\u07e1\3\2\2\2\u0178\u0818\3\2\2\2\u017a\u081a\3\2\2\2\u017c" + - "\u017e\5z>\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f\3\2\2" + - "\2\u017f\u0180\7\2\2\3\u0180\3\3\2\2\2\u0181\u0183\5\u017a\u00be\2\u0182" + - "\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2" + - "\2\2\u0185\u018e\3\2\2\2\u0186\u018e\7G\2\2\u0187\u0188\7W\2\2\u0188\u0189" + - "\5\\/\2\u0189\u018a\7X\2\2\u018a\u018e\3\2\2\2\u018b\u018e\5\6\4\2\u018c" + - "\u018e\5\16\b\2\u018d\u0182\3\2\2\2\u018d\u0186\3\2\2\2\u018d\u0187\3" + - "\2\2\2\u018d\u018b\3\2\2\2\u018d\u018c\3\2\2\2\u018e\5\3\2\2\2\u018f\u0192" + - "\5\b\5\2\u0190\u0192\5\n\6\2\u0191\u018f\3\2\2\2\u0191\u0190\3\2\2\2\u0192" + - "\7\3\2\2\2\u0193\u019e\7\u0086\2\2\u0194\u019e\5\u0148\u00a5\2\u0195\u019e" + - "\5\u013a\u009e\2\u0196\u019e\5\u014a\u00a6\2\u0197\u019a\7e\2\2\u0198" + - "\u019b\5\u0114\u008b\2\u0199\u019b\5\u00a0Q\2\u019a\u0198\3\2\2\2\u019a" + - "\u0199\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019e\5\u0156\u00ac\2\u019d\u0193" + - "\3\2\2\2\u019d\u0194\3\2\2\2\u019d\u0195\3\2\2\2\u019d\u0196\3\2\2\2\u019d" + - "\u0197\3\2\2\2\u019d\u019c\3\2\2\2\u019e\t\3\2\2\2\u019f\u01a1\5\f\7\2" + - "\u01a0\u01a2\7F\2\2\u01a1\u01a0\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a3" + - "\3\2\2\2\u01a3\u01a4\5\b\5\2\u01a4\13\3\2\2\2\u01a5\u01a9\b\7\1\2\u01a6" + - "\u01aa\5\u009eP\2\u01a7\u01aa\5\u00b6\\\2\u01a8\u01aa\5\u00a0Q\2\u01a9" + - "\u01a6\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01a8\3\2\2\2\u01a9\u01aa\3\2" + - "\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7\u0081\2\2\u01ac\u01b8\3\2\2\2\u01ad" + - "\u01b3\f\3\2\2\u01ae\u01b4\7\u0086\2\2\u01af\u01b1\7F\2\2\u01b0\u01af" + - "\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b4\5\u0154\u00ab" + - "\2\u01b3\u01ae\3\2\2\2\u01b3\u01b0\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b7" + - "\7\u0081\2\2\u01b6\u01ad\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6\3\2\2" + - "\2\u01b8\u01b9\3\2\2\2\u01b9\r\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01bd" + - "\5\20\t\2\u01bc\u01be\5\36\20\2\u01bd\u01bc\3\2\2\2\u01bd\u01be\3\2\2" + - "\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\5f\64\2\u01c0\17\3\2\2\2\u01c1\u01c3" + - "\7Y\2\2\u01c2\u01c4\5\22\n\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4" + - "\u01c5\3\2\2\2\u01c5\u01c6\7Z\2\2\u01c6\21\3\2\2\2\u01c7\u01ce\5\26\f" + - "\2\u01c8\u01cb\5\24\13\2\u01c9\u01ca\7|\2\2\u01ca\u01cc\5\26\f\2\u01cb" + - "\u01c9\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01ce\3\2\2\2\u01cd\u01c7\3\2" + - "\2\2\u01cd\u01c8\3\2\2\2\u01ce\23\3\2\2\2\u01cf\u01d0\t\2\2\2\u01d0\25" + - "\3\2\2\2\u01d1\u01d6\5\30\r\2\u01d2\u01d3\7|\2\2\u01d3\u01d5\5\30\r\2" + - "\u01d4\u01d2\3\2\2\2\u01d5\u01d8\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6\u01d7" + - "\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d9\u01db\7\u0085\2" + - "\2\u01da\u01d9\3\2\2\2\u01da\u01db\3\2\2\2\u01db\27\3\2\2\2\u01dc\u01df" + - "\5\32\16\2\u01dd\u01df\5\34\17\2\u01de\u01dc\3\2\2\2\u01de\u01dd\3\2\2" + - "\2\u01df\31\3\2\2\2\u01e0\u01e2\7c\2\2\u01e1\u01e0\3\2\2\2\u01e1\u01e2" + - "\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e6\7\u0086\2\2\u01e4\u01e6\7G\2" + - "\2\u01e5\u01e1\3\2\2\2\u01e5\u01e4\3\2\2\2\u01e6\33\3\2\2\2\u01e7\u01e9" + - "\7c\2\2\u01e8\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea" + - "\u01eb\7\u0086\2\2\u01eb\u01ec\5\u010a\u0086\2\u01ec\35\3\2\2\2\u01ed" + - "\u01ef\7W\2\2\u01ee\u01f0\5\u0100\u0081\2\u01ef\u01ee\3\2\2\2\u01ef\u01f0" + - "\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f3\7X\2\2\u01f2\u01f4\7\61\2\2\u01f3" + - "\u01f2\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\3\2\2\2\u01f5\u01f7\5\u0170" + - "\u00b9\2\u01f6\u01f5\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u01f9\3\2\2\2\u01f8" + - "\u01fa\5\u00caf\2\u01f9\u01f8\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fc" + - "\3\2\2\2\u01fb\u01fd\5\u00e8u\2\u01fc\u01fb\3\2\2\2\u01fc\u01fd\3\2\2" + - "\2\u01fd\37\3\2\2\2\u01fe\u01ff\b\21\1\2\u01ff\u021d\5\4\3\2\u0200\u0203" + - "\5\u009cO\2\u0201\u0203\5\u015e\u00b0\2\u0202\u0200\3\2\2\2\u0202\u0201" + - "\3\2\2\2\u0203\u020a\3\2\2\2\u0204\u0206\7W\2\2\u0205\u0207\5$\23\2\u0206" + - "\u0205\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u020b\7X" + - "\2\2\u0209\u020b\5\u0112\u008a\2\u020a\u0204\3\2\2\2\u020a\u0209\3\2\2" + - "\2\u020b\u021d\3\2\2\2\u020c\u020d\t\3\2\2\u020d\u020e\7h\2\2\u020e\u020f" + - "\5\u00f4{\2\u020f\u0210\7i\2\2\u0210\u0211\7W\2\2\u0211\u0212\5\\/\2\u0212" + - "\u0213\7X\2\2\u0213\u021d\3\2\2\2\u0214\u0215\5\"\22\2\u0215\u0218\7W" + - "\2\2\u0216\u0219\5\\/\2\u0217\u0219\5\u00f4{\2\u0218\u0216\3\2\2\2\u0218" + - "\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021b\7X\2\2\u021b\u021d\3\2" + - "\2\2\u021c\u01fe\3\2\2\2\u021c\u0202\3\2\2\2\u021c\u020c\3\2\2\2\u021c" + - "\u0214\3\2\2\2\u021d\u0239\3\2\2\2\u021e\u021f\f\t\2\2\u021f\u0222\7Y" + - "\2\2\u0220\u0223\5\\/\2\u0221\u0223\5\u0112\u008a\2\u0222\u0220\3\2\2" + - "\2\u0222\u0221\3\2\2\2\u0223\u0224\3\2\2\2\u0224\u0225\7Z\2\2\u0225\u0238" + - "\3\2\2\2\u0226\u0227\f\b\2\2\u0227\u0229\7W\2\2\u0228\u022a\5$\23\2\u0229" + - "\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u0238\7X" + - "\2\2\u022c\u022d\f\6\2\2\u022d\u0233\t\4\2\2\u022e\u0230\7F\2\2\u022f" + - "\u022e\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0234\5\6" + - "\4\2\u0232\u0234\5&\24\2\u0233\u022f\3\2\2\2\u0233\u0232\3\2\2\2\u0234" + - "\u0238\3\2\2\2\u0235\u0236\f\5\2\2\u0236\u0238\t\5\2\2\u0237\u021e\3\2" + - "\2\2\u0237\u0226\3\2\2\2\u0237\u022c\3\2\2\2\u0237\u0235\3\2\2\2\u0238" + - "\u023b\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u023a\3\2\2\2\u023a!\3\2\2\2" + - "\u023b\u0239\3\2\2\2\u023c\u023d\7M\2\2\u023d#\3\2\2\2\u023e\u023f\5\u0110" + - "\u0089\2\u023f%\3\2\2\2\u0240\u0242\5\f\7\2\u0241\u0240\3\2\2\2\u0241" + - "\u0242\3\2\2\2\u0242\u0246\3\2\2\2\u0243\u0244\5\u009eP\2\u0244\u0245" + - "\7\u0081\2\2\u0245\u0247\3\2\2\2\u0246\u0243\3\2\2\2\u0246\u0247\3\2\2" + - "\2\u0247\u0248\3\2\2\2\u0248\u0249\7e\2\2\u0249\u0254\5\u009eP\2\u024a" + - "\u024b\5\f\7\2\u024b\u024c\7F\2\2\u024c\u024d\5\u0154\u00ab\2\u024d\u024e" + - "\7\u0081\2\2\u024e\u024f\7e\2\2\u024f\u0250\5\u009eP\2\u0250\u0254\3\2" + - "\2\2\u0251\u0252\7e\2\2\u0252\u0254\5\u00a0Q\2\u0253\u0241\3\2\2\2\u0253" + - "\u024a\3\2\2\2\u0253\u0251\3\2\2\2\u0254\'\3\2\2\2\u0255\u0271\5 \21\2" + - "\u0256\u025b\7z\2\2\u0257\u025b\7{\2\2\u0258\u025b\5*\26\2\u0259\u025b" + - "\7@\2\2\u025a\u0256\3\2\2\2\u025a\u0257\3\2\2\2\u025a\u0258\3\2\2\2\u025a" + - "\u0259\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u0271\5(\25\2\u025d\u0266\7@" + - "\2\2\u025e\u025f\7W\2\2\u025f\u0260\5\u00f4{\2\u0260\u0261\7X\2\2\u0261" + - "\u0267\3\2\2\2\u0262\u0263\7\u0085\2\2\u0263\u0264\7W\2\2\u0264\u0265" + - "\7\u0086\2\2\u0265\u0267\7X\2\2\u0266\u025e\3\2\2\2\u0266\u0262\3\2\2" + - "\2\u0267\u0271\3\2\2\2\u0268\u0269\7\r\2\2\u0269\u026a\7W\2\2\u026a\u026b" + - "\5\u00f4{\2\u026b\u026c\7X\2\2\u026c\u0271\3\2\2\2\u026d\u0271\5:\36\2" + - "\u026e\u0271\5,\27\2\u026f\u0271\58\35\2\u0270\u0255\3\2\2\2\u0270\u025a" + - "\3\2\2\2\u0270\u025d\3\2\2\2\u0270\u0268\3\2\2\2\u0270\u026d\3\2\2\2\u0270" + - "\u026e\3\2\2\2\u0270\u026f\3\2\2\2\u0271)\3\2\2\2\u0272\u0273\t\6\2\2" + - "\u0273+\3\2\2\2\u0274\u0276\7\u0081\2\2\u0275\u0274\3\2\2\2\u0275\u0276" + - "\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0279\7\63\2\2\u0278\u027a\5.\30\2" + - "\u0279\u0278\3\2\2\2\u0279\u027a\3\2\2\2\u027a\u0280\3\2\2\2\u027b\u0281" + - "\5\60\31\2\u027c\u027d\7W\2\2\u027d\u027e\5\u00f4{\2\u027e\u027f\7X\2" + - "\2\u027f\u0281\3\2\2\2\u0280\u027b\3\2\2\2\u0280\u027c\3\2\2\2\u0281\u0283" + - "\3\2\2\2\u0282\u0284\5\66\34\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2" + - "\u0284-\3\2\2\2\u0285\u0286\7W\2\2\u0286\u0287\5$\23\2\u0287\u0288\7X" + - "\2\2\u0288/\3\2\2\2\u0289\u028b\5\u0098M\2\u028a\u028c\5\62\32\2\u028b" + - "\u028a\3\2\2\2\u028b\u028c\3\2\2\2\u028c\61\3\2\2\2\u028d\u028f\5\u00ea" + - "v\2\u028e\u0290\5\62\32\2\u028f\u028e\3\2\2\2\u028f\u0290\3\2\2\2\u0290" + - "\u0293\3\2\2\2\u0291\u0293\5\64\33\2\u0292\u028d\3\2\2\2\u0292\u0291\3" + - "\2\2\2\u0293\63\3\2\2\2\u0294\u0295\b\33\1\2\u0295\u0296\7Y\2\2\u0296" + - "\u0297\5\\/\2\u0297\u0299\7Z\2\2\u0298\u029a\5\u00caf\2\u0299\u0298\3" + - "\2\2\2\u0299\u029a\3\2\2\2\u029a\u02a4\3\2\2\2\u029b\u029c\f\3\2\2\u029c" + - "\u029d\7Y\2\2\u029d\u029e\5^\60\2\u029e\u02a0\7Z\2\2\u029f\u02a1\5\u00ca" + - "f\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2" + - "\u029b\3\2\2\2\u02a3\u02a6\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5\3\2" + - "\2\2\u02a5\65\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a7\u02a9\7W\2\2\u02a8\u02aa" + - "\5$\23\2\u02a9\u02a8\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab" + - "\u02ae\7X\2\2\u02ac\u02ae\5\u0112\u008a\2\u02ad\u02a7\3\2\2\2\u02ad\u02ac" + - "\3\2\2\2\u02ae\67\3\2\2\2\u02af\u02b1\7\u0081\2\2\u02b0\u02af\3\2\2\2" + - "\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b5\7\36\2\2\u02b3\u02b4" + - "\7Y\2\2\u02b4\u02b6\7Z\2\2\u02b5\u02b3\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6" + - "\u02b7\3\2\2\2\u02b7\u02b8\5<\37\2\u02b89\3\2\2\2\u02b9\u02ba\7\64\2\2" + - "\u02ba\u02bb\7W\2\2\u02bb\u02bc\5\\/\2\u02bc\u02bd\7X\2\2\u02bd;\3\2\2" + - "\2\u02be\u02c5\5(\25\2\u02bf\u02c0\7W\2\2\u02c0\u02c1\5\u00f4{\2\u02c1" + - "\u02c2\7X\2\2\u02c2\u02c3\5<\37\2\u02c3\u02c5\3\2\2\2\u02c4\u02be\3\2" + - "\2\2\u02c4\u02bf\3\2\2\2\u02c5=\3\2\2\2\u02c6\u02cb\5<\37\2\u02c7\u02c8" + - "\t\7\2\2\u02c8\u02ca\5<\37\2\u02c9\u02c7\3\2\2\2\u02ca\u02cd\3\2\2\2\u02cb" + - "\u02c9\3\2\2\2\u02cb\u02cc\3\2\2\2\u02cc?\3\2\2\2\u02cd\u02cb\3\2\2\2" + - "\u02ce\u02d3\5> \2\u02cf\u02d0\t\b\2\2\u02d0\u02d2\5> \2\u02d1\u02cf\3" + - "\2\2\2\u02d2\u02d5\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4" + - "A\3\2\2\2\u02d5\u02d3\3\2\2\2\u02d6\u02db\5@!\2\u02d7\u02d8\t\t\2\2\u02d8" + - "\u02da\5@!\2\u02d9\u02d7\3\2\2\2\u02da\u02dd\3\2\2\2\u02db\u02d9\3\2\2" + - "\2\u02db\u02dc\3\2\2\2\u02dcC\3\2\2\2\u02dd\u02db\3\2\2\2\u02de\u02e4" + - "\5B\"\2\u02df\u02e0\5F$\2\u02e0\u02e1\5B\"\2\u02e1\u02e3\3\2\2\2\u02e2" + - "\u02df\3\2\2\2\u02e3\u02e6\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e4\u02e5\3\2" + - "\2\2\u02e5E\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e7\u02e8\7i\2\2\u02e8\u02ec" + - "\7i\2\2\u02e9\u02ea\7h\2\2\u02ea\u02ec\7h\2\2\u02eb\u02e7\3\2\2\2\u02eb" + - "\u02e9\3\2\2\2\u02ecG\3\2\2\2\u02ed\u02f2\5D#\2\u02ee\u02ef\t\n\2\2\u02ef" + - "\u02f1\5D#\2\u02f0\u02ee\3\2\2\2\u02f1\u02f4\3\2\2\2\u02f2\u02f0\3\2\2" + - "\2\u02f2\u02f3\3\2\2\2\u02f3I\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f5\u02fa" + - "\5H%\2\u02f6\u02f7\t\13\2\2\u02f7\u02f9\5H%\2\u02f8\u02f6\3\2\2\2\u02f9" + - "\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fbK\3\2\2\2" + - "\u02fc\u02fa\3\2\2\2\u02fd\u0302\5J&\2\u02fe\u02ff\7c\2\2\u02ff\u0301" + - "\5J&\2\u0300\u02fe\3\2\2\2\u0301\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302" + - "\u0303\3\2\2\2\u0303M\3\2\2\2\u0304\u0302\3\2\2\2\u0305\u030a\5L\'\2\u0306" + - "\u0307\7b\2\2\u0307\u0309\5L\'\2\u0308\u0306\3\2\2\2\u0309\u030c\3\2\2" + - "\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030bO\3\2\2\2\u030c\u030a" + - "\3\2\2\2\u030d\u0312\5N(\2\u030e\u030f\7d\2\2\u030f\u0311\5N(\2\u0310" + - "\u030e\3\2\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2" + - "\2\2\u0313Q\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u031a\5P)\2\u0316\u0317" + - "\7x\2\2\u0317\u0319\5P)\2\u0318\u0316\3\2\2\2\u0319\u031c\3\2\2\2\u031a" + - "\u0318\3\2\2\2\u031a\u031b\3\2\2\2\u031bS\3\2\2\2\u031c\u031a\3\2\2\2" + - "\u031d\u0322\5R*\2\u031e\u031f\7y\2\2\u031f\u0321\5R*\2\u0320\u031e\3" + - "\2\2\2\u0321\u0324\3\2\2\2\u0322\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323" + - "U\3\2\2\2\u0324\u0322\3\2\2\2\u0325\u032b\5T+\2\u0326\u0327\7\177\2\2" + - "\u0327\u0328\5\\/\2\u0328\u0329\7\u0080\2\2\u0329\u032a\5X-\2\u032a\u032c" + - "\3\2\2\2\u032b\u0326\3\2\2\2\u032b\u032c\3\2\2\2\u032cW\3\2\2\2\u032d" + - "\u0334\5V,\2\u032e\u032f\5T+\2\u032f\u0330\5Z.\2\u0330\u0331\5\u010e\u0088" + - "\2\u0331\u0334\3\2\2\2\u0332\u0334\5\u016e\u00b8\2\u0333\u032d\3\2\2\2" + - "\u0333\u032e\3\2\2\2\u0333\u0332\3\2\2\2\u0334Y\3\2\2\2\u0335\u0336\t" + - "\f\2\2\u0336[\3\2\2\2\u0337\u033c\5X-\2\u0338\u0339\7|\2\2\u0339\u033b" + - "\5X-\2\u033a\u0338\3\2\2\2\u033b\u033e\3\2\2\2\u033c\u033a\3\2\2\2\u033c" + - "\u033d\3\2\2\2\u033d]\3\2\2\2\u033e\u033c\3\2\2\2\u033f\u0340\5V,\2\u0340" + - "_\3\2\2\2\u0341\u034f\5b\62\2\u0342\u0344\5\u00caf\2\u0343\u0342\3\2\2" + - "\2\u0343\u0344\3\2\2\2\u0344\u034b\3\2\2\2\u0345\u034c\5d\63\2\u0346\u034c" + - "\5f\64\2\u0347\u034c\5j\66\2\u0348\u034c\5n8\2\u0349\u034c\5v<\2\u034a" + - "\u034c\5\u0164\u00b3\2\u034b\u0345\3\2\2\2\u034b\u0346\3\2\2\2\u034b\u0347" + - "\3\2\2\2\u034b\u0348\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034a\3\2\2\2\u034c" + - "\u034f\3\2\2\2\u034d\u034f\5x=\2\u034e\u0341\3\2\2\2\u034e\u0343\3\2\2" + - "\2\u034e\u034d\3\2\2\2\u034fa\3\2\2\2\u0350\u0352\5\u00caf\2\u0351\u0350" + - "\3\2\2\2\u0351\u0352\3\2\2\2\u0352\u0357\3\2\2\2\u0353\u0358\7\u0086\2" + - "\2\u0354\u0355\7\22\2\2\u0355\u0358\5^\60\2\u0356\u0358\7\35\2\2\u0357" + - "\u0353\3\2\2\2\u0357\u0354\3\2\2\2\u0357\u0356\3\2\2\2\u0358\u0359\3\2" + - "\2\2\u0359\u035a\7\u0080\2\2\u035a\u035b\5`\61\2\u035bc\3\2\2\2\u035c" + - "\u035e\5\\/\2\u035d\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2" + - "\2\2\u035f\u0360\7\u0082\2\2\u0360e\3\2\2\2\u0361\u0363\7[\2\2\u0362\u0364" + - "\5h\65\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2\u0365" + - "\u0366\7\\\2\2\u0366g\3\2\2\2\u0367\u0369\5`\61\2\u0368\u0367\3\2\2\2" + - "\u0369\u036a\3\2\2\2\u036a\u0368\3\2\2\2\u036a\u036b\3\2\2\2\u036bi\3" + - "\2\2\2\u036c\u036d\7-\2\2\u036d\u036e\7W\2\2\u036e\u036f\5l\67\2\u036f" + - "\u0370\7X\2\2\u0370\u0373\5`\61\2\u0371\u0372\7\"\2\2\u0372\u0374\5`\61" + - "\2\u0373\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374\u037c\3\2\2\2\u0375\u0376" + - "\7E\2\2\u0376\u0377\7W\2\2\u0377\u0378\5l\67\2\u0378\u0379\7X\2\2\u0379" + - "\u037a\5`\61\2\u037a\u037c\3\2\2\2\u037b\u036c\3\2\2\2\u037b\u0375\3\2" + - "\2\2\u037ck\3\2\2\2\u037d\u0389\5\\/\2\u037e\u0380\5\u00caf\2\u037f\u037e" + - "\3\2\2\2\u037f\u0380\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0382\5\u008cG" + - "\2\u0382\u0386\5\u00e0q\2\u0383\u0384\7g\2\2\u0384\u0387\5\u010e\u0088" + - "\2\u0385\u0387\5\u0112\u008a\2\u0386\u0383\3\2\2\2\u0386\u0385\3\2\2\2" + - "\u0387\u0389\3\2\2\2\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0389m\3" + - "\2\2\2\u038a\u038b\7V\2\2\u038b\u038c\7W\2\2\u038c\u038d\5l\67\2\u038d" + - "\u038e\7X\2\2\u038e\u038f\5`\61\2\u038f\u03ac\3\2\2\2\u0390\u0391\7\37" + - "\2\2\u0391\u0392\5`\61\2\u0392\u0393\7V\2\2\u0393\u0394\7W\2\2\u0394\u0395" + - "\5\\/\2\u0395\u0396\7X\2\2\u0396\u0397\7\u0082\2\2\u0397\u03ac\3\2\2\2" + - "\u0398\u0399\7*\2\2\u0399\u03a6\7W\2\2\u039a\u039c\5p9\2\u039b\u039d\5" + - "l\67\2\u039c\u039b\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039e\3\2\2\2\u039e" + - "\u03a0\7\u0082\2\2\u039f\u03a1\5\\/\2\u03a0\u039f\3\2\2\2\u03a0\u03a1" + - "\3\2\2\2\u03a1\u03a7\3\2\2\2\u03a2\u03a3\5r:\2\u03a3\u03a4\7\u0080\2\2" + - "\u03a4\u03a5\5t;\2\u03a5\u03a7\3\2\2\2\u03a6\u039a\3\2\2\2\u03a6\u03a2" + - "\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8\u03a9\7X\2\2\u03a9\u03aa\5`\61\2\u03aa" + - "\u03ac\3\2\2\2\u03ab\u038a\3\2\2\2\u03ab\u0390\3\2\2\2\u03ab\u0398\3\2" + - "\2\2\u03aco\3\2\2\2\u03ad\u03b0\5d\63\2\u03ae\u03b0\5\u0082B\2\u03af\u03ad" + - "\3\2\2\2\u03af\u03ae\3\2\2\2\u03b0q\3\2\2\2\u03b1\u03b3\5\u00caf\2\u03b2" + - "\u03b1\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b5\5\u008c" + - "G\2\u03b5\u03b6\5\u00e0q\2\u03b6s\3\2\2\2\u03b7\u03ba\5\\/\2\u03b8\u03ba" + - "\5\u0112\u008a\2\u03b9\u03b7\3\2\2\2\u03b9\u03b8\3\2\2\2\u03bau\3\2\2" + - "\2\u03bb\u03c5\7\21\2\2\u03bc\u03c5\7\33\2\2\u03bd\u03c0\7=\2\2\u03be" + - "\u03c1\5\\/\2\u03bf\u03c1\5\u0112\u008a\2\u03c0\u03be\3\2\2\2\u03c0\u03bf" + - "\3\2\2\2\u03c0\u03c1\3\2\2\2\u03c1\u03c5\3\2\2\2\u03c2\u03c3\7,\2\2\u03c3" + - "\u03c5\7\u0086\2\2\u03c4\u03bb\3\2\2\2\u03c4\u03bc\3\2\2\2\u03c4\u03bd" + - "\3\2\2\2\u03c4\u03c2\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u03c7\7\u0082\2" + - "\2\u03c7w\3\2\2\2\u03c8\u03c9\5~@\2\u03c9y\3\2\2\2\u03ca\u03cc\5|?\2\u03cb" + - "\u03ca\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2" + - "\2\2\u03ce{\3\2\2\2\u03cf\u03d9\5~@\2\u03d0\u03d9\5\u0106\u0084\2\u03d1" + - "\u03d9\5\u014c\u00a7\2\u03d2\u03d9\5\u0160\u00b1\2\u03d3\u03d9\5\u0162" + - "\u00b2\2\u03d4\u03d9\5\u00c8e\2\u03d5\u03d9\5\u00ba^\2\u03d6\u03d9\5\u0086" + - "D\2\u03d7\u03d9\5\u0088E\2\u03d8\u03cf\3\2\2\2\u03d8\u03d0\3\2\2\2\u03d8" + - "\u03d1\3\2\2\2\u03d8\u03d2\3\2\2\2\u03d8\u03d3\3\2\2\2\u03d8\u03d4\3\2" + - "\2\2\u03d8\u03d5\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2\2\2\u03d9" + - "}\3\2\2\2\u03da\u03e3\5\u0082B\2\u03db\u03e3\5\u00c6d\2\u03dc\u03e3\5" + - "\u00be`\2\u03dd\u03e3\5\u00c2b\2\u03de\u03e3\5\u00c4c\2\u03df\u03e3\5" + - "\u0084C\2\u03e0\u03e3\5\u0080A\2\u03e1\u03e3\5\u00aaV\2\u03e2\u03da\3" + - "\2\2\2\u03e2\u03db\3\2\2\2\u03e2\u03dc\3\2\2\2\u03e2\u03dd\3\2\2\2\u03e2" + - "\u03de\3\2\2\2\u03e2\u03df\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e2\u03e1\3\2" + - "\2\2\u03e3\177\3\2\2\2\u03e4\u03e5\7Q\2\2\u03e5\u03e7\7\u0086\2\2\u03e6" + - "\u03e8\5\u00caf\2\u03e7\u03e6\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03e9" + - "\3\2\2\2\u03e9\u03ea\7g\2\2\u03ea\u03eb\5\u00f4{\2\u03eb\u03ec\7\u0082" + - "\2\2\u03ec\u0081\3\2\2\2\u03ed\u03ef\5\u008cG\2\u03ee\u03ed\3\2\2\2\u03ee" + - "\u03ef\3\2\2\2\u03ef\u03f1\3\2\2\2\u03f0\u03f2\5\u00dco\2\u03f1\u03f0" + - "\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03fc\7\u0082\2" + - "\2\u03f4\u03f6\5\u00caf\2\u03f5\u03f7\5\u008cG\2\u03f6\u03f5\3\2\2\2\u03f6" + - "\u03f7\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03f9\5\u00dco\2\u03f9\u03fa" + - "\7\u0082\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03ee\3\2\2\2\u03fb\u03f4\3\2\2" + - "\2\u03fc\u0083\3\2\2\2\u03fd\u03fe\7B\2\2\u03fe\u03ff\7W\2\2\u03ff\u0400" + - "\5^\60\2\u0400\u0401\7|\2\2\u0401\u0402\7\6\2\2\u0402\u0403\7X\2\2\u0403" + - "\u0404\7\u0082\2\2\u0404\u0085\3\2\2\2\u0405\u0406\7\u0082\2\2\u0406\u0087" + - "\3\2\2\2\u0407\u0408\5\u00caf\2\u0408\u0409\7\u0082\2\2\u0409\u0089\3" + - "\2\2\2\u040a\u0411\5\u008eH\2\u040b\u0411\5\u0094K\2\u040c\u0411\5\u0090" + - "I\2\u040d\u0411\7+\2\2\u040e\u0411\7L\2\2\u040f\u0411\7\31\2\2\u0410\u040a" + - "\3\2\2\2\u0410\u040b\3\2\2\2\u0410\u040c\3\2\2\2\u0410\u040d\3\2\2\2\u0410" + - "\u040e\3\2\2\2\u0410\u040f\3\2\2\2\u0411\u008b\3\2\2\2\u0412\u0414\5\u008a" + - "F\2\u0413\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0413\3\2\2\2\u0415" + - "\u0416\3\2\2\2\u0416\u0418\3\2\2\2\u0417\u0419\5\u00caf\2\u0418\u0417" + - "\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u008d\3\2\2\2\u041a\u041b\t\r\2\2\u041b" + - "\u008f\3\2\2\2\u041c\u041d\t\16\2\2\u041d\u0091\3\2\2\2\u041e\u041f\7" + - "\u0086\2\2\u041f\u0093\3\2\2\2\u0420\u0424\5\u0096L\2\u0421\u0424\5\u0116" + - "\u008c\2\u0422\u0424\5\u00a6T\2\u0423\u0420\3\2\2\2\u0423\u0421\3\2\2" + - "\2\u0423\u0422\3\2\2\2\u0424\u0095\3\2\2\2\u0425\u042a\5\u009cO\2\u0426" + - "\u042a\5\u00a2R\2\u0427\u042a\5\u015e\u00b0\2\u0428\u042a\5\u00eex\2\u0429" + - "\u0425\3\2\2\2\u0429\u0426\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u0428\3\2" + - "\2\2\u042a\u0097\3\2\2\2\u042b\u042d\5\u0094K\2\u042c\u042b\3\2\2\2\u042d" + - "\u042e\3\2\2\2\u042e\u042c\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\3\2" + - "\2\2\u0430\u0432\5\u00caf\2\u0431\u0430\3\2\2\2\u0431\u0432\3\2\2\2\u0432" + - "\u0099\3\2\2\2\u0433\u0435\5\u0096L\2\u0434\u0433\3\2\2\2\u0435\u0436" + - "\3\2\2\2\u0436\u0434\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0439\3\2\2\2\u0438" + - "\u043a\5\u00caf\2\u0439\u0438\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u009b" + - "\3\2\2\2\u043b\u043d\5\f\7\2\u043c\u043b\3\2\2\2\u043c\u043d\3\2\2\2\u043d" + - "\u043e\3\2\2\2\u043e\u0453\5\u009eP\2\u043f\u0440\5\f\7\2\u0440\u0441" + - "\7F\2\2\u0441\u0442\5\u0154\u00ab\2\u0442\u0453\3\2\2\2\u0443\u0453\7" + - "\24\2\2\u0444\u0453\7\25\2\2\u0445\u0453\7\26\2\2\u0446\u0453\7U\2\2\u0447" + - "\u0453\7\20\2\2\u0448\u0453\7>\2\2\u0449\u0453\7/\2\2\u044a\u0453\7\60" + - "\2\2\u044b\u0453\7?\2\2\u044c\u0453\7P\2\2\u044d\u0453\7)\2\2\u044e\u0453" + - "\7 \2\2\u044f\u0453\7S\2\2\u0450\u0453\7\17\2\2\u0451\u0453\5\u00a0Q\2" + - "\u0452\u043c\3\2\2\2\u0452\u043f\3\2\2\2\u0452\u0443\3\2\2\2\u0452\u0444" + - "\3\2\2\2\u0452\u0445\3\2\2\2\u0452\u0446\3\2\2\2\u0452\u0447\3\2\2\2\u0452" + - "\u0448\3\2\2\2\u0452\u0449\3\2\2\2\u0452\u044a\3\2\2\2\u0452\u044b\3\2" + - "\2\2\u0452\u044c\3\2\2\2\u0452\u044d\3\2\2\2\u0452\u044e\3\2\2\2\u0452" + - "\u044f\3\2\2\2\u0452\u0450\3\2\2\2\u0452\u0451\3\2\2\2\u0453\u009d\3\2" + - "\2\2\u0454\u0459\5\u0114\u008b\2\u0455\u0459\5\u00a4S\2\u0456\u0459\5" + - "\u0092J\2\u0457\u0459\5\u0154\u00ab\2\u0458\u0454\3\2\2\2\u0458\u0455" + - "\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0457\3\2\2\2\u0459\u009f\3\2\2\2\u045a" + - "\u045b\7\34\2\2\u045b\u045e\7W\2\2\u045c\u045f\5\\/\2\u045d\u045f\7\17" + - "\2\2\u045e\u045c\3\2\2\2\u045e\u045d\3\2\2\2\u045f\u0460\3\2\2\2\u0460" + - "\u0461\7X\2\2\u0461\u00a1\3\2\2\2\u0462\u0471\5\u011e\u0090\2\u0463\u0465" + - "\5\u00caf\2\u0464\u0463\3\2\2\2\u0464\u0465\3\2\2\2\u0465\u0467\3\2\2" + - "\2\u0466\u0468\5\f\7\2\u0467\u0466\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0469" + - "\3\2\2\2\u0469\u0472\7\u0086\2\2\u046a\u0472\5\u0154\u00ab\2\u046b\u046d" + - "\5\f\7\2\u046c\u046e\7F\2\2\u046d\u046c\3\2\2\2\u046d\u046e\3\2\2\2\u046e" + - "\u046f\3\2\2\2\u046f\u0470\5\u0154\u00ab\2\u0470\u0472\3\2\2\2\u0471\u0464" + - "\3\2\2\2\u0471\u046a\3\2\2\2\u0471\u046b\3\2\2\2\u0472\u0479\3\2\2\2\u0473" + - "\u0475\7#\2\2\u0474\u0476\5\f\7\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2" + - "\2\2\u0476\u0477\3\2\2\2\u0477\u0479\7\u0086\2\2\u0478\u0462\3\2\2\2\u0478" + - "\u0473\3\2\2\2\u0479\u00a3\3\2\2\2\u047a\u047b\7\u0086\2\2\u047b\u00a5" + - "\3\2\2\2\u047c\u047d\5\u00a8U\2\u047d\u0482\7[\2\2\u047e\u0480\5\u00b0" + - "Y\2\u047f\u0481\7|\2\2\u0480\u047f\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u0483" + - "\3\2\2\2\u0482\u047e\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u0484\3\2\2\2\u0484" + - "\u0485\7\\\2\2\u0485\u00a7\3\2\2\2\u0486\u0488\5\u00acW\2\u0487\u0489" + - "\5\u00caf\2\u0488\u0487\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048e\3\2\2" + - "\2\u048a\u048c\5\f\7\2\u048b\u048a\3\2\2\2\u048b\u048c\3\2\2\2\u048c\u048d" + - "\3\2\2\2\u048d\u048f\7\u0086\2\2\u048e\u048b\3\2\2\2\u048e\u048f\3\2\2" + - "\2\u048f\u0491\3\2\2\2\u0490\u0492\5\u00aeX\2\u0491\u0490\3\2\2\2\u0491" + - "\u0492\3\2\2\2\u0492\u00a9\3\2\2\2\u0493\u0495\5\u00acW\2\u0494\u0496" + - "\5\u00caf\2\u0495\u0494\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u0497\3\2\2" + - "\2\u0497\u0499\7\u0086\2\2\u0498\u049a\5\u00aeX\2\u0499\u0498\3\2\2\2" + - "\u0499\u049a\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049c\7\u0082\2\2\u049c" + - "\u00ab\3\2\2\2\u049d\u049f\7#\2\2\u049e\u04a0\t\17\2\2\u049f\u049e\3\2" + - "\2\2\u049f\u04a0\3\2\2\2\u04a0\u00ad\3\2\2\2\u04a1\u04a2\7\u0080\2\2\u04a2" + - "\u04a3\5\u0098M\2\u04a3\u00af\3\2\2\2\u04a4\u04a9\5\u00b2Z\2\u04a5\u04a6" + - "\7|\2\2\u04a6\u04a8\5\u00b2Z\2\u04a7\u04a5\3\2\2\2\u04a8\u04ab\3\2\2\2" + - "\u04a9\u04a7\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u00b1\3\2\2\2\u04ab\u04a9" + - "\3\2\2\2\u04ac\u04af\5\u00b4[\2\u04ad\u04ae\7g\2\2\u04ae\u04b0\5^\60\2" + - "\u04af\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u00b3\3\2\2\2\u04b1\u04b2" + - "\7\u0086\2\2\u04b2\u00b5\3\2\2\2\u04b3\u04b6\5\u00b8]\2\u04b4\u04b6\5" + - "\u00bc_\2\u04b5\u04b3\3\2\2\2\u04b5\u04b4\3\2\2\2\u04b6\u00b7\3\2\2\2" + - "\u04b7\u04b8\7\u0086\2\2\u04b8\u00b9\3\2\2\2\u04b9\u04bb\7.\2\2\u04ba" + - "\u04b9\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04bf\7\62" + - "\2\2\u04bd\u04c0\7\u0086\2\2\u04be\u04c0\5\u00b8]\2\u04bf\u04bd\3\2\2" + - "\2\u04bf\u04be\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1\u04c3" + - "\7[\2\2\u04c2\u04c4\5z>\2\u04c3\u04c2\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4" + - "\u04c5\3\2\2\2\u04c5\u04c6\7\\\2\2\u04c6\u00bb\3\2\2\2\u04c7\u04c8\7\u0086" + - "\2\2\u04c8\u00bd\3\2\2\2\u04c9\u04ca\7\62\2\2\u04ca\u04cb\7\u0086\2\2" + - "\u04cb\u04cc\7g\2\2\u04cc\u04cd\5\u00c0a\2\u04cd\u04ce\7\u0082\2\2\u04ce" + - "\u00bf\3\2\2\2\u04cf\u04d1\5\f\7\2\u04d0\u04cf\3\2\2\2\u04d0\u04d1\3\2" + - "\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\5\u00b6\\\2\u04d3\u00c1\3\2\2\2\u04d4" + - "\u04da\7Q\2\2\u04d5\u04d7\7N\2\2\u04d6\u04d5\3\2\2\2\u04d6\u04d7\3\2\2" + - "\2\u04d7\u04d8\3\2\2\2\u04d8\u04db\5\f\7\2\u04d9\u04db\7\u0081\2\2\u04da" + - "\u04d6\3\2\2\2\u04da\u04d9\3\2\2\2\u04db\u04dc\3\2\2\2\u04dc\u04dd\5\b" + - "\5\2\u04dd\u04de\7\u0082\2\2\u04de\u00c3\3\2\2\2\u04df\u04e1\5\u00caf" + - "\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e3" + - "\7Q\2\2\u04e3\u04e5\7\62\2\2\u04e4\u04e6\5\f\7\2\u04e5\u04e4\3\2\2\2\u04e5" + - "\u04e6\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7\u04e8\5\u00b6\\\2\u04e8\u04e9" + - "\7\u0082\2\2\u04e9\u00c5\3\2\2\2\u04ea\u04eb\7\16\2\2\u04eb\u04ec\7W\2" + - "\2\u04ec\u04ed\7\6\2\2\u04ed\u04ee\7X\2\2\u04ee\u04ef\7\u0082\2\2\u04ef" + - "\u00c7\3\2\2\2\u04f0\u04f1\7&\2\2\u04f1\u04f8\7\6\2\2\u04f2\u04f4\7[\2" + - "\2\u04f3\u04f5\5z>\2\u04f4\u04f3\3\2\2\2\u04f4\u04f5\3\2\2\2\u04f5\u04f6" + - "\3\2\2\2\u04f6\u04f9\7\\\2\2\u04f7\u04f9\5|?\2\u04f8\u04f2\3\2\2\2\u04f8" + - "\u04f7\3\2\2\2\u04f9\u00c9\3\2\2\2\u04fa\u04fc\5\u00ccg\2\u04fb\u04fa" + - "\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fd\u04fe\3\2\2\2\u04fe" + - "\u00cb\3\2\2\2\u04ff\u0500\7Y\2\2\u0500\u0502\7Y\2\2\u0501\u0503\5\u00d0" + - "i\2\u0502\u0501\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504" + - "\u0505\7Z\2\2\u0505\u0508\7Z\2\2\u0506\u0508\5\u00ceh\2\u0507\u04ff\3" + - "\2\2\2\u0507\u0506\3\2\2\2\u0508\u00cd\3\2\2\2\u0509\u050a\7\f\2\2\u050a" + - "\u050d\7W\2\2\u050b\u050e\5\u00f4{\2\u050c\u050e\5^\60\2\u050d\u050b\3" + - "\2\2\2\u050d\u050c\3\2\2\2\u050e\u0510\3\2\2\2\u050f\u0511\7\u0085\2\2" + - "\u0510\u050f\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u0512\3\2\2\2\u0512\u0513" + - "\7X\2\2\u0513\u00cf\3\2\2\2\u0514\u0519\5\u00d2j\2\u0515\u0516\7|\2\2" + - "\u0516\u0518\5\u00d2j\2\u0517\u0515\3\2\2\2\u0518\u051b\3\2\2\2\u0519" + - "\u0517\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051d\3\2\2\2\u051b\u0519\3\2" + - "\2\2\u051c\u051e\7\u0085\2\2\u051d\u051c\3\2\2\2\u051d\u051e\3\2\2\2\u051e" + - "\u00d1\3\2\2\2\u051f\u0520\5\u00d4k\2\u0520\u0521\7\u0081\2\2\u0521\u0523" + - "\3\2\2\2\u0522\u051f\3\2\2\2\u0522\u0523\3\2\2\2\u0523\u0524\3\2\2\2\u0524" + - "\u0526\7\u0086\2\2\u0525\u0527\5\u00d6l\2\u0526\u0525\3\2\2\2\u0526\u0527" + - "\3\2\2\2\u0527\u00d3\3\2\2\2\u0528\u0529\7\u0086\2\2\u0529\u00d5\3\2\2" + - "\2\u052a\u052c\7W\2\2\u052b\u052d\5\u00d8m\2\u052c\u052b\3\2\2\2\u052c" + - "\u052d\3\2\2\2\u052d\u052e\3\2\2\2\u052e\u052f\7X\2\2\u052f\u00d7\3\2" + - "\2\2\u0530\u0532\5\u00dan\2\u0531\u0530\3\2\2\2\u0532\u0533\3\2\2\2\u0533" + - "\u0531\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u00d9\3\2\2\2\u0535\u0536\7W" + - "\2\2\u0536\u0537\5\u00d8m\2\u0537\u0538\7X\2\2\u0538\u0547\3\2\2\2\u0539" + - "\u053a\7Y\2\2\u053a\u053b\5\u00d8m\2\u053b\u053c\7Z\2\2\u053c\u0547\3" + - "\2\2\2\u053d\u053e\7[\2\2\u053e\u053f\5\u00d8m\2\u053f\u0540\7\\\2\2\u0540" + - "\u0547\3\2\2\2\u0541\u0543\n\20\2\2\u0542\u0541\3\2\2\2\u0543\u0544\3" + - "\2\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0547\3\2\2\2\u0546" + - "\u0535\3\2\2\2\u0546\u0539\3\2\2\2\u0546\u053d\3\2\2\2\u0546\u0542\3\2" + - "\2\2\u0547\u00db\3\2\2\2\u0548\u054d\5\u00dep\2\u0549\u054a\7|\2\2\u054a" + - "\u054c\5\u00dep\2\u054b\u0549\3\2\2\2\u054c\u054f\3\2\2\2\u054d\u054b" + - "\3\2\2\2\u054d\u054e\3\2\2\2\u054e\u00dd\3\2\2\2\u054f\u054d\3\2\2\2\u0550" + - "\u0552\5\u00e0q\2\u0551\u0553\5\u010a\u0086\2\u0552\u0551\3\2\2\2\u0552" + - "\u0553\3\2\2\2\u0553\u00df\3\2\2\2\u0554\u055a\5\u00e2r\2\u0555\u0556" + - "\5\u00e4s\2\u0556\u0557\5\u00e6t\2\u0557\u0558\5\u00e8u\2\u0558\u055a" + - "\3\2\2\2\u0559\u0554\3\2\2\2\u0559\u0555\3\2\2\2\u055a\u00e1\3\2\2\2\u055b" + - "\u055d\5\u00eav\2\u055c\u055e\7\30\2\2\u055d\u055c\3\2\2\2\u055d\u055e" + - "\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055b\3\2\2\2\u0560\u0563\3\2\2\2\u0561" + - "\u055f\3\2\2\2\u0561\u0562\3\2\2\2\u0562\u0564\3\2\2\2\u0563\u0561\3\2" + - "\2\2\u0564\u0565\5\u00e4s\2\u0565\u00e3\3\2\2\2\u0566\u0567\bs\1\2\u0567" + - "\u0569\5\u00f2z\2\u0568\u056a\5\u00caf\2\u0569\u0568\3\2\2\2\u0569\u056a" + - "\3\2\2\2\u056a\u0570\3\2\2\2\u056b\u056c\7W\2\2\u056c\u056d\5\u00e2r\2" + - "\u056d\u056e\7X\2\2\u056e\u0570\3\2\2\2\u056f\u0566\3\2\2\2\u056f\u056b" + - "\3\2\2\2\u0570\u057f\3\2\2\2\u0571\u057b\f\4\2\2\u0572\u057c\5\u00e6t" + - "\2\u0573\u0575\7Y\2\2\u0574\u0576\5^\60\2\u0575\u0574\3\2\2\2\u0575\u0576" + - "\3\2\2\2\u0576\u0577\3\2\2\2\u0577\u0579\7Z\2\2\u0578\u057a\5\u00caf\2" + - "\u0579\u0578\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057c\3\2\2\2\u057b\u0572" + - "\3\2\2\2\u057b\u0573\3\2\2\2\u057c\u057e\3\2\2\2\u057d\u0571\3\2\2\2\u057e" + - "\u0581\3\2\2\2\u057f\u057d\3\2\2\2\u057f\u0580\3\2\2\2\u0580\u00e5\3\2" + - "\2\2\u0581\u057f\3\2\2\2\u0582\u0584\7W\2\2\u0583\u0585\5\u0100\u0081" + - "\2\u0584\u0583\3\2\2\2\u0584\u0585\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u0588" + - "\7X\2\2\u0587\u0589\5\u00ecw\2\u0588\u0587\3\2\2\2\u0588\u0589\3\2\2\2" + - "\u0589\u058b\3\2\2\2\u058a\u058c\5\u00f0y\2\u058b\u058a\3\2\2\2\u058b" + - "\u058c\3\2\2\2\u058c\u058e\3\2\2\2\u058d\u058f\5\u0170\u00b9\2\u058e\u058d" + - "\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591\3\2\2\2\u0590\u0592\5\u00caf" + - "\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2\2\u0592\u00e7\3\2\2\2\u0593\u0594" + - "\7~\2\2\u0594\u0596\5\u009aN\2\u0595\u0597\5\u00f6|\2\u0596\u0595\3\2" + - "\2\2\u0596\u0597\3\2\2\2\u0597\u00e9\3\2\2\2\u0598\u059a\t\21\2\2\u0599" + - "\u059b\5\u00caf\2\u059a\u0599\3\2\2\2\u059a\u059b\3\2\2\2\u059b\u05a7" + - "\3\2\2\2\u059c\u059e\5\f\7\2\u059d\u059c\3\2\2\2\u059d\u059e\3\2\2\2\u059e" + - "\u059f\3\2\2\2\u059f\u05a1\7_\2\2\u05a0\u05a2\5\u00caf\2\u05a1\u05a0\3" + - "\2\2\2\u05a1\u05a2\3\2\2\2\u05a2\u05a4\3\2\2\2\u05a3\u05a5\5\u00ecw\2" + - "\u05a4\u05a3\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a7\3\2\2\2\u05a6\u0598" + - "\3\2\2\2\u05a6\u059d\3\2\2\2\u05a7\u00eb\3\2\2\2\u05a8\u05aa\5\u00eex" + - "\2\u05a9\u05a8\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05a9\3\2\2\2\u05ab\u05ac" + - "\3\2\2\2\u05ac\u00ed\3\2\2\2\u05ad\u05ae\t\22\2\2\u05ae\u00ef\3\2\2\2" + - "\u05af\u05b0\t\21\2\2\u05b0\u00f1\3\2\2\2\u05b1\u05b3\7\u0085\2\2\u05b2" + - "\u05b1\3\2\2\2\u05b2\u05b3\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4\u05b5\5\6" + - "\4\2\u05b5\u00f3\3\2\2\2\u05b6\u05b8\5\u0098M\2\u05b7\u05b9\5\u00f6|\2" + - "\u05b8\u05b7\3\2\2\2\u05b8\u05b9\3\2\2\2\u05b9\u00f5\3\2\2\2\u05ba\u05c3" + - "\5\u00f8}\2\u05bb\u05bd\5\u00fa~\2\u05bc\u05bb\3\2\2\2\u05bc\u05bd\3\2" + - "\2\2\u05bd\u05be\3\2\2\2\u05be\u05bf\5\u00e6t\2\u05bf\u05c0\5\u00e8u\2" + - "\u05c0\u05c3\3\2\2\2\u05c1\u05c3\5\u00fc\177\2\u05c2\u05ba\3\2\2\2\u05c2" + - "\u05bc\3\2\2\2\u05c2\u05c1\3\2\2\2\u05c3\u00f7\3\2\2\2\u05c4\u05ce\5\u00fa" + - "~\2\u05c5\u05c7\5\u00eav\2\u05c6\u05c5\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8" + - "\u05c6\3\2\2\2\u05c8\u05c9\3\2\2\2\u05c9\u05cb\3\2\2\2\u05ca\u05cc\5\u00fa" + - "~\2\u05cb\u05ca\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05ce\3\2\2\2\u05cd" + - "\u05c4\3\2\2\2\u05cd\u05c6\3\2\2\2\u05ce\u00f9\3\2\2\2\u05cf\u05d0\b~" + - "\1\2\u05d0\u05de\5\u00e6t\2\u05d1\u05d3\7Y\2\2\u05d2\u05d4\5^\60\2\u05d3" + - "\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d7\7Z" + - "\2\2\u05d6\u05d8\5\u00caf\2\u05d7\u05d6\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8" + - "\u05de\3\2\2\2\u05d9\u05da\7W\2\2\u05da\u05db\5\u00f8}\2\u05db\u05dc\7" + - "X\2\2\u05dc\u05de\3\2\2\2\u05dd\u05cf\3\2\2\2\u05dd\u05d1\3\2\2\2\u05dd" + - "\u05d9\3\2\2\2\u05de\u05ee\3\2\2\2\u05df\u05ea\f\6\2\2\u05e0\u05eb\5\u00e6" + - "t\2\u05e1\u05e2\5\u00fa~\2\u05e2\u05e4\7Y\2\2\u05e3\u05e5\5^\60\2\u05e4" + - "\u05e3\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u05e8\7Z" + - "\2\2\u05e7\u05e9\5\u00caf\2\u05e8\u05e7\3\2\2\2\u05e8\u05e9\3\2\2\2\u05e9" + - "\u05eb\3\2\2\2\u05ea\u05e0\3\2\2\2\u05ea\u05e1\3\2\2\2\u05eb\u05ed\3\2" + - "\2\2\u05ec\u05df\3\2\2\2\u05ed\u05f0\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ee" + - "\u05ef\3\2\2\2\u05ef\u00fb\3\2\2\2\u05f0\u05ee\3\2\2\2\u05f1\u05f3\5\u00ea" + - "v\2\u05f2\u05f1\3\2\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4" + - "\u05f5\3\2\2\2\u05f5\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\5\u00fe" + - "\u0080\2\u05f8\u00fd\3\2\2\2\u05f9\u05fa\b\u0080\1\2\u05fa\u05fb\7\u0085" + - "\2\2\u05fb\u060a\3\2\2\2\u05fc\u0606\f\4\2\2\u05fd\u0607\5\u00e6t\2\u05fe" + - "\u0600\7Y\2\2\u05ff\u0601\5^\60\2\u0600\u05ff\3\2\2\2\u0600\u0601\3\2" + - "\2\2\u0601\u0602\3\2\2\2\u0602\u0604\7Z\2\2\u0603\u0605\5\u00caf\2\u0604" + - "\u0603\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0607\3\2\2\2\u0606\u05fd\3\2" + - "\2\2\u0606\u05fe\3\2\2\2\u0607\u0609\3\2\2\2\u0608\u05fc\3\2\2\2\u0609" + - "\u060c\3\2\2\2\u060a\u0608\3\2\2\2\u060a\u060b\3\2\2\2\u060b\u00ff\3\2" + - "\2\2\u060c\u060a\3\2\2\2\u060d\u0612\5\u0102\u0082\2\u060e\u0610\7|\2" + - "\2\u060f\u060e\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0611\3\2\2\2\u0611\u0613" + - "\7\u0085\2\2\u0612\u060f\3\2\2\2\u0612\u0613\3\2\2\2\u0613\u0101\3\2\2" + - "\2\u0614\u0619\5\u0104\u0083\2\u0615\u0616\7|\2\2\u0616\u0618\5\u0104" + - "\u0083\2\u0617\u0615\3\2\2\2\u0618\u061b\3\2\2\2\u0619\u0617\3\2\2\2\u0619" + - "\u061a\3\2\2\2\u061a\u0103\3\2\2\2\u061b\u0619\3\2\2\2\u061c\u061e\5\u00ca" + - "f\2\u061d\u061c\3\2\2\2\u061d\u061e\3\2\2\2\u061e\u061f\3\2\2\2\u061f" + - "\u0624\5\u008cG\2\u0620\u0625\5\u00e0q\2\u0621\u0623\5\u00f6|\2\u0622" + - "\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2\2\2\u0624\u0620\3\2" + - "\2\2\u0624\u0622\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0627\7g\2\2\u0627" + - "\u0629\5\u010e\u0088\2\u0628\u0626\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u0105" + - "\3\2\2\2\u062a\u062c\5\u00caf\2\u062b\u062a\3\2\2\2\u062b\u062c\3\2\2" + - "\2\u062c\u062e\3\2\2\2\u062d\u062f\5\u008cG\2\u062e\u062d\3\2\2\2\u062e" + - "\u062f\3\2\2\2\u062f\u0630\3\2\2\2\u0630\u0632\5\u00e0q\2\u0631\u0633" + - "\5\u0128\u0095\2\u0632\u0631\3\2\2\2\u0632\u0633\3\2\2\2\u0633\u0634\3" + - "\2\2\2\u0634\u0635\5\u0108\u0085\2\u0635\u0107\3\2\2\2\u0636\u0638\5\u0140" + - "\u00a1\2\u0637\u0636\3\2\2\2\u0637\u0638\3\2\2\2\u0638\u0639\3\2\2\2\u0639" + - "\u063f\5f\64\2\u063a\u063f\5\u0166\u00b4\2\u063b\u063c\7g\2\2\u063c\u063d" + - "\t\23\2\2\u063d\u063f\7\u0082\2\2\u063e\u0637\3\2\2\2\u063e\u063a\3\2" + - "\2\2\u063e\u063b\3\2\2\2\u063f\u0109\3\2\2\2\u0640\u0646\5\u010c\u0087" + - "\2\u0641\u0642\7W\2\2\u0642\u0643\5$\23\2\u0643\u0644\7X\2\2\u0644\u0646" + - "\3\2\2\2\u0645\u0640\3\2\2\2\u0645\u0641\3\2\2\2\u0646\u010b\3\2\2\2\u0647" + - "\u0648\7g\2\2\u0648\u064b\5\u010e\u0088\2\u0649\u064b\5\u0112\u008a\2" + - "\u064a\u0647\3\2\2\2\u064a\u0649\3\2\2\2\u064b\u010d\3\2\2\2\u064c\u064f" + - "\5X-\2\u064d\u064f\5\u0112\u008a\2\u064e\u064c\3\2\2\2\u064e\u064d\3\2" + - "\2\2\u064f\u010f\3\2\2\2\u0650\u0652\5\u010e\u0088\2\u0651\u0653\7\u0085" + - "\2\2\u0652\u0651\3\2\2\2\u0652\u0653\3\2\2\2\u0653\u065b\3\2\2\2\u0654" + - "\u0655\7|\2\2\u0655\u0657\5\u010e\u0088\2\u0656\u0658\7\u0085\2\2\u0657" + - "\u0656\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u065a\3\2\2\2\u0659\u0654\3\2" + - "\2\2\u065a\u065d\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c" + - "\u0111\3\2\2\2\u065d\u065b\3\2\2\2\u065e\u0663\7[\2\2\u065f\u0661\5\u0110" + - "\u0089\2\u0660\u0662\7|\2\2\u0661\u0660\3\2\2\2\u0661\u0662\3\2\2\2\u0662" + - "\u0664\3\2\2\2\u0663\u065f\3\2\2\2\u0663\u0664\3\2\2\2\u0664\u0665\3\2" + - "\2\2\u0665\u0666\7\\\2\2\u0666\u0113\3\2\2\2\u0667\u066a\7\u0086\2\2\u0668" + - "\u066a\5\u0154\u00ab\2\u0669\u0667\3\2\2\2\u0669\u0668\3\2\2\2\u066a\u0115" + - "\3\2\2\2\u066b\u066c\5\u0118\u008d\2\u066c\u066e\7[\2\2\u066d\u066f\5" + - "\u0120\u0091\2\u066e\u066d\3\2\2\2\u066e\u066f\3\2\2\2\u066f\u0670\3\2" + - "\2\2\u0670\u0671\7\\\2\2\u0671\u0117\3\2\2\2\u0672\u0674\5\u011e\u0090" + - "\2\u0673\u0675\5\u00caf\2\u0674\u0673\3\2\2\2\u0674\u0675\3\2\2\2\u0675" + - "\u067a\3\2\2\2\u0676\u0678\5\u011a\u008e\2\u0677\u0679\5\u011c\u008f\2" + - "\u0678\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067b\3\2\2\2\u067a\u0676" + - "\3\2\2\2\u067a\u067b\3\2\2\2\u067b\u067d\3\2\2\2\u067c\u067e\5\u012e\u0098" + - "\2\u067d\u067c\3\2\2\2\u067d\u067e\3\2\2\2\u067e\u068a\3\2\2\2\u067f\u0681" + - "\7O\2\2\u0680\u0682\5\u00caf\2\u0681\u0680\3\2\2\2\u0681\u0682\3\2\2\2" + - "\u0682\u0687\3\2\2\2\u0683\u0685\5\u011a\u008e\2\u0684\u0686\5\u011c\u008f" + - "\2\u0685\u0684\3\2\2\2\u0685\u0686\3\2\2\2\u0686\u0688\3\2\2\2\u0687\u0683" + - "\3\2\2\2\u0687\u0688\3\2\2\2\u0688\u068a\3\2\2\2\u0689\u0672\3\2\2\2\u0689" + - "\u067f\3\2\2\2\u068a\u0119\3\2\2\2\u068b\u068d\5\f\7\2\u068c\u068b\3\2" + - "\2\2\u068c\u068d\3\2\2\2\u068d\u068e\3\2\2\2\u068e\u068f\5\u0114\u008b" + - "\2\u068f\u011b\3\2\2\2\u0690\u0691\7(\2\2\u0691\u011d\3\2\2\2\u0692\u0693" + - "\t\17\2\2\u0693\u011f\3\2\2\2\u0694\u0699\5\u0122\u0092\2\u0695\u0696" + - "\5\u0138\u009d\2\u0696\u0697\7\u0080\2\2\u0697\u0699\3\2\2\2\u0698\u0694" + - "\3\2\2\2\u0698\u0695\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u0698\3\2\2\2\u069a" + - "\u069b\3\2\2\2\u069b\u0121\3\2\2\2\u069c\u069e\5\u00caf\2\u069d\u069c" + - "\3\2\2\2\u069d\u069e\3\2\2\2\u069e\u06a0\3\2\2\2\u069f\u06a1\5\u008cG" + - "\2\u06a0\u069f\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1\u06a3\3\2\2\2\u06a2\u06a4" + - "\5\u0124\u0093\2\u06a3\u06a2\3\2\2\2\u06a3\u06a4\3\2\2\2\u06a4\u06a5\3" + - "\2\2\2\u06a5\u06ad\7\u0082\2\2\u06a6\u06ad\5\u0106\u0084\2\u06a7\u06ad" + - "\5\u00c2b\2\u06a8\u06ad\5\u0084C\2\u06a9\u06ad\5\u014c\u00a7\2\u06aa\u06ad" + - "\5\u0080A\2\u06ab\u06ad\5\u0086D\2\u06ac\u069d\3\2\2\2\u06ac\u06a6\3\2" + - "\2\2\u06ac\u06a7\3\2\2\2\u06ac\u06a8\3\2\2\2\u06ac\u06a9\3\2\2\2\u06ac" + - "\u06aa\3\2\2\2\u06ac\u06ab\3\2\2\2\u06ad\u0123\3\2\2\2\u06ae\u06b3\5\u0126" + - "\u0094\2\u06af\u06b0\7|\2\2\u06b0\u06b2\5\u0126\u0094\2\u06b1\u06af\3" + - "\2\2\2\u06b2\u06b5\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4" + - "\u0125\3\2\2\2\u06b5\u06b3\3\2\2\2\u06b6\u06c0\5\u00e0q\2\u06b7\u06b9" + - "\5\u0128\u0095\2\u06b8\u06b7\3\2\2\2\u06b8\u06b9\3\2\2\2\u06b9\u06bb\3" + - "\2\2\2\u06ba\u06bc\5\u012c\u0097\2\u06bb\u06ba\3\2\2\2\u06bb\u06bc\3\2" + - "\2\2\u06bc\u06c1\3\2\2\2\u06bd\u06bf\5\u010c\u0087\2\u06be\u06bd\3\2\2" + - "\2\u06be\u06bf\3\2\2\2\u06bf\u06c1\3\2\2\2\u06c0\u06b8\3\2\2\2\u06c0\u06be" + - "\3\2\2\2\u06c1\u06cb\3\2\2\2\u06c2\u06c4\7\u0086\2\2\u06c3\u06c2\3\2\2" + - "\2\u06c3\u06c4\3\2\2\2\u06c4\u06c6\3\2\2\2\u06c5\u06c7\5\u00caf\2\u06c6" + - "\u06c5\3\2\2\2\u06c6\u06c7\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06c9\7\u0080" + - "\2\2\u06c9\u06cb\5^\60\2\u06ca\u06b6\3\2\2\2\u06ca\u06c3\3\2\2\2\u06cb" + - "\u0127\3\2\2\2\u06cc\u06ce\5\u012a\u0096\2\u06cd\u06cc\3\2\2\2\u06ce\u06cf" + - "\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u0129\3\2\2\2\u06d1" + - "\u06d2\t\24\2\2\u06d2\u012b\3\2\2\2\u06d3\u06d4\7g\2\2\u06d4\u06d5\7\u0088" + - "\2\2\u06d5\u06d6\b\u0097\1\2\u06d6\u012d\3\2\2\2\u06d7\u06d8\7\u0080\2" + - "\2\u06d8\u06d9\5\u0130\u0099\2\u06d9\u012f\3\2\2\2\u06da\u06dc\5\u0132" + - "\u009a\2\u06db\u06dd\7\u0085\2\2\u06dc\u06db\3\2\2\2\u06dc\u06dd\3\2\2" + - "\2\u06dd\u06e5\3\2\2\2\u06de\u06df\7|\2\2\u06df\u06e1\5\u0132\u009a\2" + - "\u06e0\u06e2\7\u0085\2\2\u06e1\u06e0\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2" + - "\u06e4\3\2\2\2\u06e3\u06de\3\2\2\2\u06e4\u06e7\3\2\2\2\u06e5\u06e3\3\2" + - "\2\2\u06e5\u06e6\3\2\2\2\u06e6\u0131\3\2\2\2\u06e7\u06e5\3\2\2\2\u06e8" + - "\u06ea\5\u00caf\2\u06e9\u06e8\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06f7" + - "\3\2\2\2\u06eb\u06f8\5\u0136\u009c\2\u06ec\u06ee\7R\2\2\u06ed\u06ef\5" + - "\u0138\u009d\2\u06ee\u06ed\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06f0\3\2" + - "\2\2\u06f0\u06f8\5\u0136\u009c\2\u06f1\u06f3\5\u0138\u009d\2\u06f2\u06f4" + - "\7R\2\2\u06f3\u06f2\3\2\2\2\u06f3\u06f4\3\2\2\2\u06f4\u06f5\3\2\2\2\u06f5" + - "\u06f6\5\u0136\u009c\2\u06f6\u06f8\3\2\2\2\u06f7\u06eb\3\2\2\2\u06f7\u06ec" + - "\3\2\2\2\u06f7\u06f1\3\2\2\2\u06f8\u0133\3\2\2\2\u06f9\u06fb\5\f\7\2\u06fa" + - "\u06f9\3\2\2\2\u06fa\u06fb\3\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u06ff\5\u0114" + - "\u008b\2\u06fd\u06ff\5\u00a0Q\2\u06fe\u06fa\3\2\2\2\u06fe\u06fd\3\2\2" + - "\2\u06ff\u0135\3\2\2\2\u0700\u0701\5\u0134\u009b\2\u0701\u0137\3\2\2\2" + - "\u0702\u0703\t\25\2\2\u0703\u0139\3\2\2\2\u0704\u0705\7\66\2\2\u0705\u0706" + - "\5\u013c\u009f\2\u0706\u013b\3\2\2\2\u0707\u0709\5\u0098M\2\u0708\u070a" + - "\5\u013e\u00a0\2\u0709\u0708\3\2\2\2\u0709\u070a\3\2\2\2\u070a\u013d\3" + - "\2\2\2\u070b\u070d\5\u00eav\2\u070c\u070e\5\u013e\u00a0\2\u070d\u070c" + - "\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u013f\3\2\2\2\u070f\u0710\7\u0080\2" + - "\2\u0710\u0711\5\u0142\u00a2\2\u0711\u0141\3\2\2\2\u0712\u0714\5\u0144" + - "\u00a3\2\u0713\u0715\7\u0085\2\2\u0714\u0713\3\2\2\2\u0714\u0715\3\2\2" + - "\2\u0715\u071d\3\2\2\2\u0716\u0717\7|\2\2\u0717\u0719\5\u0144\u00a3\2" + - "\u0718\u071a\7\u0085\2\2\u0719\u0718\3\2\2\2\u0719\u071a\3\2\2\2\u071a" + - "\u071c\3\2\2\2\u071b\u0716\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2" + - "\2\2\u071d\u071e\3\2\2\2\u071e\u0143\3\2\2\2\u071f\u071d\3\2\2\2\u0720" + - "\u0727\5\u0146\u00a4\2\u0721\u0723\7W\2\2\u0722\u0724\5$\23\2\u0723\u0722" + - "\3\2\2\2\u0723\u0724\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u0728\7X\2\2\u0726" + - "\u0728\5\u0112\u008a\2\u0727\u0721\3\2\2\2\u0727\u0726\3\2\2\2\u0728\u0145" + - "\3\2\2\2\u0729\u072c\5\u0134\u009b\2\u072a\u072c\7\u0086\2\2\u072b\u0729" + - "\3\2\2\2\u072b\u072a\3\2\2\2\u072c\u0147\3\2\2\2\u072d\u072e\7\66\2\2" + - "\u072e\u072f\5\u0178\u00bd\2\u072f\u0149\3\2\2\2\u0730\u0734\7\66\2\2" + - "\u0731\u0732\7\6\2\2\u0732\u0735\7\u0086\2\2\u0733\u0735\7\u008e\2\2\u0734" + - "\u0731\3\2\2\2\u0734\u0733\3\2\2\2\u0735\u014b\3\2\2\2\u0736\u0737\7F" + - "\2\2\u0737\u0738\7h\2\2\u0738\u0739\5\u014e\u00a8\2\u0739\u073a\7i\2\2" + - "\u073a\u073b\5|?\2\u073b\u014d\3\2\2\2\u073c\u0741\5\u0150\u00a9\2\u073d" + - "\u073e\7|\2\2\u073e\u0740\5\u0150\u00a9\2\u073f\u073d\3\2\2\2\u0740\u0743" + - "\3\2\2\2\u0741\u073f\3\2\2\2\u0741\u0742\3\2\2\2\u0742\u014f\3\2\2\2\u0743" + - "\u0741\3\2\2\2\u0744\u0747\5\u0152\u00aa\2\u0745\u0747\5\u0104\u0083\2" + - "\u0746\u0744\3\2\2\2\u0746\u0745\3\2\2\2\u0747\u0151\3\2\2\2\u0748\u0749" + - "\7F\2\2\u0749\u074a\7h\2\2\u074a\u074b\5\u014e\u00a8\2\u074b\u074c\7i" + - "\2\2\u074c\u074e\3\2\2\2\u074d\u0748\3\2\2\2\u074d\u074e\3\2\2\2\u074e" + - "\u074f\3\2\2\2\u074f\u0752\7\27\2\2\u0750\u0752\7N\2\2\u0751\u074d\3\2" + - "\2\2\u0751\u0750\3\2\2\2\u0752\u075e\3\2\2\2\u0753\u0755\7\u0085\2\2\u0754" + - "\u0753\3\2\2\2\u0754\u0755\3\2\2\2\u0755\u0757\3\2\2\2\u0756\u0758\7\u0086" + - "\2\2\u0757\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u075f\3\2\2\2\u0759" + - "\u075b\7\u0086\2\2\u075a\u0759\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075c" + - "\3\2\2\2\u075c\u075d\7g\2\2\u075d\u075f\5\u00f4{\2\u075e\u0754\3\2\2\2" + - "\u075e\u075a\3\2\2\2\u075f\u0153\3\2\2\2\u0760\u0761\5\u0158\u00ad\2\u0761" + - "\u0763\7h\2\2\u0762\u0764\5\u015a\u00ae\2\u0763\u0762\3\2\2\2\u0763\u0764" + - "\3\2\2\2\u0764\u0765\3\2\2\2\u0765\u0766\7i\2\2\u0766\u0155\3\2\2\2\u0767" + - "\u0773\5\u0154\u00ab\2\u0768\u076b\5\u0148\u00a5\2\u0769\u076b\5\u014a" + - "\u00a6\2\u076a\u0768\3\2\2\2\u076a\u0769\3\2\2\2\u076b\u076c\3\2\2\2\u076c" + - "\u076e\7h\2\2\u076d\u076f\5\u015a\u00ae\2\u076e\u076d\3\2\2\2\u076e\u076f" + - "\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0771\7i\2\2\u0771\u0773\3\2\2\2\u0772" + - "\u0767\3\2\2\2\u0772\u076a\3\2\2\2\u0773\u0157\3\2\2\2\u0774\u0775\7\u0086" + - "\2\2\u0775\u0159\3\2\2\2\u0776\u0778\5\u015c\u00af\2\u0777\u0779\7\u0085" + - "\2\2\u0778\u0777\3\2\2\2\u0778\u0779\3\2\2\2\u0779\u0781\3\2\2\2\u077a" + - "\u077b\7|\2\2\u077b\u077d\5\u015c\u00af\2\u077c\u077e\7\u0085\2\2\u077d" + - "\u077c\3\2\2\2\u077d\u077e\3\2\2\2\u077e\u0780\3\2\2\2\u077f\u077a\3\2" + - "\2\2\u0780\u0783\3\2\2\2\u0781\u077f\3\2\2\2\u0781\u0782\3\2\2\2\u0782" + - "\u015b\3\2\2\2\u0783\u0781\3\2\2\2\u0784\u0788\5\u00f4{\2\u0785\u0788" + - "\5^\60\2\u0786\u0788\5\6\4\2\u0787\u0784\3\2\2\2\u0787\u0785\3\2\2\2\u0787" + - "\u0786\3\2\2\2\u0788\u015d\3\2\2\2\u0789\u078a\7N\2\2\u078a\u0790\5\f" + - "\7\2\u078b\u0791\7\u0086\2\2\u078c\u078e\7F\2\2\u078d\u078c\3\2\2\2\u078d" + - "\u078e\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u0791\5\u0154\u00ab\2\u0790\u078b" + - "\3\2\2\2\u0790\u078d\3\2\2\2\u0791\u015f\3\2\2\2\u0792\u0794\7&\2\2\u0793" + - "\u0792\3\2\2\2\u0793\u0794\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\7F" + - "\2\2\u0796\u0797\5|?\2\u0797\u0161\3\2\2\2\u0798\u0799\7F\2\2\u0799\u079a" + - "\7h\2\2\u079a\u079b\7i\2\2\u079b\u079c\5|?\2\u079c\u0163\3\2\2\2\u079d" + - "\u079e\7K\2\2\u079e\u079f\5f\64\2\u079f\u07a0\5\u0168\u00b5\2\u07a0\u0165" + - "\3\2\2\2\u07a1\u07a3\7K\2\2\u07a2\u07a4\5\u0140\u00a1\2\u07a3\u07a2\3" + - "\2\2\2\u07a3\u07a4\3\2\2\2\u07a4\u07a5\3\2\2\2\u07a5\u07a6\5f\64\2\u07a6" + - "\u07a7\5\u0168\u00b5\2\u07a7\u0167\3\2\2\2\u07a8\u07aa\5\u016a\u00b6\2" + - "\u07a9\u07a8\3\2\2\2\u07aa\u07ab\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac" + - "\3\2\2\2\u07ac\u0169\3\2\2\2\u07ad\u07ae\7\23\2\2\u07ae\u07af\7W\2\2\u07af" + - "\u07b0\5\u016c\u00b7\2\u07b0\u07b1\7X\2\2\u07b1\u07b2\5f\64\2\u07b2\u016b" + - "\3\2\2\2\u07b3\u07b5\5\u00caf\2\u07b4\u07b3\3\2\2\2\u07b4\u07b5\3\2\2" + - "\2\u07b5\u07b6\3\2\2\2\u07b6\u07b9\5\u0098M\2\u07b7\u07ba\5\u00e0q\2\u07b8" + - "\u07ba\5\u00f6|\2\u07b9\u07b7\3\2\2\2\u07b9\u07b8\3\2\2\2\u07b9\u07ba" + - "\3\2\2\2\u07ba\u07bd\3\2\2\2\u07bb\u07bd\7\u0085\2\2\u07bc\u07b4\3\2\2" + - "\2\u07bc\u07bb\3\2\2\2\u07bd\u016d\3\2\2\2\u07be\u07c0\7I\2\2\u07bf\u07c1" + - "\5X-\2\u07c0\u07bf\3\2\2\2\u07c0\u07c1\3\2\2\2\u07c1\u016f\3\2\2\2\u07c2" + - "\u07c5\5\u0172\u00ba\2\u07c3\u07c5\5\u0176\u00bc\2\u07c4\u07c2\3\2\2\2" + - "\u07c4\u07c3\3\2\2\2\u07c5\u0171\3\2\2\2\u07c6\u07c7\7I\2\2\u07c7\u07c9" + - "\7W\2\2\u07c8\u07ca\5\u0174\u00bb\2\u07c9\u07c8\3\2\2\2\u07c9\u07ca\3" + - "\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u07cc\7X\2\2\u07cc\u0173\3\2\2\2\u07cd" + - "\u07cf\5\u00f4{\2\u07ce\u07d0\7\u0085\2\2\u07cf\u07ce\3\2\2\2\u07cf\u07d0" + - "\3\2\2\2\u07d0\u07d8\3\2\2\2\u07d1\u07d2\7|\2\2\u07d2\u07d4\5\u00f4{\2" + - "\u07d3\u07d5\7\u0085\2\2\u07d4\u07d3\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5" + - "\u07d7\3\2\2\2\u07d6\u07d1\3\2\2\2\u07d7\u07da\3\2\2\2\u07d8\u07d6\3\2" + - "\2\2\u07d8\u07d9\3\2\2\2\u07d9\u0175\3\2\2\2\u07da\u07d8\3\2\2\2\u07db" + - "\u07dc\7\64\2\2\u07dc\u07dd\7W\2\2\u07dd\u07de\5^\60\2\u07de\u07df\7X" + - "\2\2\u07df\u07e2\3\2\2\2\u07e0\u07e2\7\64\2\2\u07e1\u07db\3\2\2\2\u07e1" + - "\u07e0\3\2\2\2\u07e2\u0177\3\2\2\2\u07e3\u07e6\7\63\2\2\u07e4\u07e5\7" + - "Y\2\2\u07e5\u07e7\7Z\2\2\u07e6\u07e4\3\2\2\2\u07e6\u07e7\3\2\2\2\u07e7" + - "\u0819\3\2\2\2\u07e8\u07eb\7\36\2\2\u07e9\u07ea\7Y\2\2\u07ea\u07ec\7Z" + - "\2\2\u07eb\u07e9\3\2\2\2\u07eb\u07ec\3\2\2\2\u07ec\u0819\3\2\2\2\u07ed" + - "\u0819\7]\2\2\u07ee\u0819\7^\2\2\u07ef\u0819\7_\2\2\u07f0\u0819\7`\2\2" + - "\u07f1\u0819\7a\2\2\u07f2\u0819\7b\2\2\u07f3\u0819\7c\2\2\u07f4\u0819" + - "\7d\2\2\u07f5\u0819\7e\2\2\u07f6\u0819\7f\2\2\u07f7\u0819\7g\2\2\u07f8" + - "\u0819\7i\2\2\u07f9\u0819\7h\2\2\u07fa\u0819\7w\2\2\u07fb\u0819\7j\2\2" + - "\u07fc\u0819\7k\2\2\u07fd\u0819\7l\2\2\u07fe\u0819\7g\2\2\u07ff\u0819" + - "\7n\2\2\u0800\u0819\7o\2\2\u0801\u0819\7p\2\2\u0802\u0819\7q\2\2\u0803" + - "\u0804\7h\2\2\u0804\u0819\7h\2\2\u0805\u0806\7i\2\2\u0806\u0819\7i\2\2" + - "\u0807\u0819\7s\2\2\u0808\u0819\7r\2\2\u0809\u0819\7t\2\2\u080a\u0819" + - "\7u\2\2\u080b\u0819\7v\2\2\u080c\u0819\7w\2\2\u080d\u0819\7x\2\2\u080e" + - "\u0819\7y\2\2\u080f\u0819\7z\2\2\u0810\u0819\7{\2\2\u0811\u0819\7|\2\2" + - "\u0812\u0819\7}\2\2\u0813\u0819\7~\2\2\u0814\u0815\7W\2\2\u0815\u0819" + - "\7X\2\2\u0816\u0817\7Y\2\2\u0817\u0819\7Z\2\2\u0818\u07e3\3\2\2\2\u0818" + - "\u07e8\3\2\2\2\u0818\u07ed\3\2\2\2\u0818\u07ee\3\2\2\2\u0818\u07ef\3\2" + - "\2\2\u0818\u07f0\3\2\2\2\u0818\u07f1\3\2\2\2\u0818\u07f2\3\2\2\2\u0818" + - "\u07f3\3\2\2\2\u0818\u07f4\3\2\2\2\u0818\u07f5\3\2\2\2\u0818\u07f6\3\2" + - "\2\2\u0818\u07f7\3\2\2\2\u0818\u07f8\3\2\2\2\u0818\u07f9\3\2\2\2\u0818" + - "\u07fa\3\2\2\2\u0818\u07fb\3\2\2\2\u0818\u07fc\3\2\2\2\u0818\u07fd\3\2" + - "\2\2\u0818\u07fe\3\2\2\2\u0818\u07ff\3\2\2\2\u0818\u0800\3\2\2\2\u0818" + - "\u0801\3\2\2\2\u0818\u0802\3\2\2\2\u0818\u0803\3\2\2\2\u0818\u0805\3\2" + - "\2\2\u0818\u0807\3\2\2\2\u0818\u0808\3\2\2\2\u0818\u0809\3\2\2\2\u0818" + - "\u080a\3\2\2\2\u0818\u080b\3\2\2\2\u0818\u080c\3\2\2\2\u0818\u080d\3\2" + - "\2\2\u0818\u080e\3\2\2\2\u0818\u080f\3\2\2\2\u0818\u0810\3\2\2\2\u0818" + - "\u0811\3\2\2\2\u0818\u0812\3\2\2\2\u0818\u0813\3\2\2\2\u0818\u0814\3\2" + - "\2\2\u0818\u0816\3\2\2\2\u0819\u0179\3\2\2\2\u081a\u081b\t\26\2\2\u081b" + - "\u017b\3\2\2\2\u012b\u017d\u0184\u018d\u0191\u019a\u019d\u01a1\u01a9\u01b0" + - "\u01b3\u01b8\u01bd\u01c3\u01cb\u01cd\u01d6\u01da\u01de\u01e1\u01e5\u01e8" + - "\u01ef\u01f3\u01f6\u01f9\u01fc\u0202\u0206\u020a\u0218\u021c\u0222\u0229" + - "\u022f\u0233\u0237\u0239\u0241\u0246\u0253\u025a\u0266\u0270\u0275\u0279" + - "\u0280\u0283\u028b\u028f\u0292\u0299\u02a0\u02a4\u02a9\u02ad\u02b0\u02b5" + - "\u02c4\u02cb\u02d3\u02db\u02e4\u02eb\u02f2\u02fa\u0302\u030a\u0312\u031a" + - "\u0322\u032b\u0333\u033c\u0343\u034b\u034e\u0351\u0357\u035d\u0363\u036a" + - "\u0373\u037b\u037f\u0386\u0388\u039c\u03a0\u03a6\u03ab\u03af\u03b2\u03b9" + - "\u03c0\u03c4\u03cd\u03d8\u03e2\u03e7\u03ee\u03f1\u03f6\u03fb\u0410\u0415" + - "\u0418\u0423\u0429\u042e\u0431\u0436\u0439\u043c\u0452\u0458\u045e\u0464" + - "\u0467\u046d\u0471\u0475\u0478\u0480\u0482\u0488\u048b\u048e\u0491\u0495" + - "\u0499\u049f\u04a9\u04af\u04b5\u04ba\u04bf\u04c3\u04d0\u04d6\u04da\u04e0" + - "\u04e5\u04f4\u04f8\u04fd\u0502\u0507\u050d\u0510\u0519\u051d\u0522\u0526" + - "\u052c\u0533\u0544\u0546\u054d\u0552\u0559\u055d\u0561\u0569\u056f\u0575" + - "\u0579\u057b\u057f\u0584\u0588\u058b\u058e\u0591\u0596\u059a\u059d\u05a1" + - "\u05a4\u05a6\u05ab\u05b2\u05b8\u05bc\u05c2\u05c8\u05cb\u05cd\u05d3\u05d7" + - "\u05dd\u05e4\u05e8\u05ea\u05ee\u05f4\u0600\u0604\u0606\u060a\u060f\u0612" + - "\u0619\u061d\u0622\u0624\u0628\u062b\u062e\u0632\u0637\u063e\u0645\u064a" + - "\u064e\u0652\u0657\u065b\u0661\u0663\u0669\u066e\u0674\u0678\u067a\u067d" + - "\u0681\u0685\u0687\u0689\u068c\u0698\u069a\u069d\u06a0\u06a3\u06ac\u06b3" + - "\u06b8\u06bb\u06be\u06c0\u06c3\u06c6\u06ca\u06cf\u06dc\u06e1\u06e5\u06e9" + - "\u06ee\u06f3\u06f7\u06fa\u06fe\u0709\u070d\u0714\u0719\u071d\u0723\u0727" + - "\u072b\u0734\u0741\u0746\u074d\u0751\u0754\u0757\u075a\u075e\u0763\u076a" + - "\u076e\u0772\u0778\u077d\u0781\u0787\u078d\u0790\u0793\u07a3\u07ab\u07b4" + - "\u07b9\u07bc\u07c0\u07c4\u07c9\u07cf\u07d4\u07d8\u07e1\u07e6\u07eb\u0818"; + "\u0004\u0001\u0091\u081b\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001" + + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004" + + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007" + + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b" + + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007" + + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007" + + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007" + + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007" + + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007" + + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007" + + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007" + + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007" + + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007" + + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007" + + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007" + + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007" + + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007" + + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007" + + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007" + + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007" + + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007" + + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007" + + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007" + + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007" + + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007" + + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007" + + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007" + + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007" + + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007" + + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007" + + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007" + + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007" + + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007" + + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007" + + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007" + + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007" + + "\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007" + + "\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007" + + "\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007" + + "\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007" + + "\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007" + + "\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007" + + "\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007" + + "\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007" + + "\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007" + + "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007" + + "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007" + + "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007" + + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007" + + "\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007" + + "\u00bc\u0001\u0000\u0003\u0000\u017c\b\u0000\u0001\u0000\u0001\u0000\u0001" + + "\u0001\u0004\u0001\u0181\b\u0001\u000b\u0001\f\u0001\u0182\u0001\u0001" + + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001" + + "\u0003\u0001\u018c\b\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u0190\b" + + "\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0003\u0003\u0003\u0199\b\u0003\u0001\u0003\u0003\u0003\u019c" + + "\b\u0003\u0001\u0004\u0001\u0004\u0003\u0004\u01a0\b\u0004\u0001\u0004" + + "\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005" + + "\u01a8\b\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005" + + "\u0003\u0005\u01af\b\u0005\u0001\u0005\u0003\u0005\u01b2\b\u0005\u0001" + + "\u0005\u0005\u0005\u01b5\b\u0005\n\u0005\f\u0005\u01b8\t\u0005\u0001\u0006" + + "\u0001\u0006\u0003\u0006\u01bc\b\u0006\u0001\u0006\u0001\u0006\u0001\u0007" + + "\u0001\u0007\u0003\u0007\u01c2\b\u0007\u0001\u0007\u0001\u0007\u0001\b" + + "\u0001\b\u0001\b\u0001\b\u0003\b\u01ca\b\b\u0003\b\u01cc\b\b\u0001\t\u0001" + + "\t\u0001\n\u0001\n\u0001\n\u0005\n\u01d3\b\n\n\n\f\n\u01d6\t\n\u0001\n" + + "\u0003\n\u01d9\b\n\u0001\u000b\u0001\u000b\u0003\u000b\u01dd\b\u000b\u0001" + + "\f\u0003\f\u01e0\b\f\u0001\f\u0001\f\u0003\f\u01e4\b\f\u0001\r\u0003\r" + + "\u01e7\b\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0003\u000e" + + "\u01ee\b\u000e\u0001\u000e\u0001\u000e\u0003\u000e\u01f2\b\u000e\u0001" + + "\u000e\u0003\u000e\u01f5\b\u000e\u0001\u000e\u0003\u000e\u01f8\b\u000e" + + "\u0001\u000e\u0003\u000e\u01fb\b\u000e\u0001\u000f\u0001\u000f\u0001\u000f" + + "\u0001\u000f\u0003\u000f\u0201\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f" + + "\u0205\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0209\b\u000f\u0001" + + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001" + + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003" + + "\u000f\u0217\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u021b\b\u000f" + + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0221\b\u000f" + + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f" + + "\u0228\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f" + + "\u022e\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0232\b\u000f\u0001" + + "\u000f\u0001\u000f\u0005\u000f\u0236\b\u000f\n\u000f\f\u000f\u0239\t\u000f" + + "\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0003\u0012" + + "\u0240\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u0245\b" + + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001" + + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003" + + "\u0012\u0252\b\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0003\u0013\u0259\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0003\u0013\u0265\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u026f" + + "\b\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0003\u0015\u0274\b\u0015" + + "\u0001\u0015\u0001\u0015\u0003\u0015\u0278\b\u0015\u0001\u0015\u0001\u0015" + + "\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u027f\b\u0015\u0001\u0015" + + "\u0003\u0015\u0282\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016" + + "\u0001\u0017\u0001\u0017\u0003\u0017\u028a\b\u0017\u0001\u0018\u0001\u0018" + + "\u0003\u0018\u028e\b\u0018\u0001\u0018\u0003\u0018\u0291\b\u0018\u0001" + + "\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u0298" + + "\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003" + + "\u0019\u029f\b\u0019\u0005\u0019\u02a1\b\u0019\n\u0019\f\u0019\u02a4\t" + + "\u0019\u0001\u001a\u0001\u001a\u0003\u001a\u02a8\b\u001a\u0001\u001a\u0001" + + "\u001a\u0003\u001a\u02ac\b\u001a\u0001\u001b\u0003\u001b\u02af\b\u001b" + + "\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u02b4\b\u001b\u0001\u001b" + + "\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c" + + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d" + + "\u0003\u001d\u02c3\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e" + + "\u02c8\b\u001e\n\u001e\f\u001e\u02cb\t\u001e\u0001\u001f\u0001\u001f\u0001" + + "\u001f\u0005\u001f\u02d0\b\u001f\n\u001f\f\u001f\u02d3\t\u001f\u0001 " + + "\u0001 \u0001 \u0005 \u02d8\b \n \f \u02db\t \u0001!\u0001!\u0001!\u0001" + + "!\u0005!\u02e1\b!\n!\f!\u02e4\t!\u0001\"\u0001\"\u0001\"\u0001\"\u0003" + + "\"\u02ea\b\"\u0001#\u0001#\u0001#\u0005#\u02ef\b#\n#\f#\u02f2\t#\u0001" + + "$\u0001$\u0001$\u0005$\u02f7\b$\n$\f$\u02fa\t$\u0001%\u0001%\u0001%\u0005" + + "%\u02ff\b%\n%\f%\u0302\t%\u0001&\u0001&\u0001&\u0005&\u0307\b&\n&\f&\u030a" + + "\t&\u0001\'\u0001\'\u0001\'\u0005\'\u030f\b\'\n\'\f\'\u0312\t\'\u0001" + + "(\u0001(\u0001(\u0005(\u0317\b(\n(\f(\u031a\t(\u0001)\u0001)\u0001)\u0005" + + ")\u031f\b)\n)\f)\u0322\t)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003" + + "*\u032a\b*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0003+\u0332\b+\u0001" + + ",\u0001,\u0001-\u0001-\u0001-\u0005-\u0339\b-\n-\f-\u033c\t-\u0001.\u0001" + + ".\u0001/\u0001/\u0003/\u0342\b/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001" + + "/\u0003/\u034a\b/\u0001/\u0003/\u034d\b/\u00010\u00030\u0350\b0\u0001" + + "0\u00010\u00010\u00010\u00030\u0356\b0\u00010\u00010\u00010\u00011\u0003" + + "1\u035c\b1\u00011\u00011\u00012\u00012\u00032\u0362\b2\u00012\u00012\u0001" + + "3\u00043\u0367\b3\u000b3\f3\u0368\u00014\u00014\u00014\u00014\u00014\u0001" + + "4\u00014\u00034\u0372\b4\u00014\u00014\u00014\u00014\u00014\u00014\u0003" + + "4\u037a\b4\u00015\u00015\u00035\u037e\b5\u00015\u00015\u00015\u00015\u0001" + + "5\u00035\u0385\b5\u00035\u0387\b5\u00016\u00016\u00016\u00016\u00016\u0001" + + "6\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u0001" + + "6\u00016\u00016\u00036\u039b\b6\u00016\u00016\u00036\u039f\b6\u00016\u0001" + + "6\u00016\u00016\u00036\u03a5\b6\u00016\u00016\u00016\u00036\u03aa\b6\u0001" + + "7\u00017\u00037\u03ae\b7\u00018\u00038\u03b1\b8\u00018\u00018\u00018\u0001" + + "9\u00019\u00039\u03b8\b9\u0001:\u0001:\u0001:\u0001:\u0001:\u0003:\u03bf" + + "\b:\u0001:\u0001:\u0003:\u03c3\b:\u0001:\u0001:\u0001;\u0001;\u0001<\u0004" + + "<\u03ca\b<\u000b<\f<\u03cb\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001" + + "=\u0001=\u0001=\u0003=\u03d7\b=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001" + + ">\u0001>\u0001>\u0003>\u03e1\b>\u0001?\u0001?\u0001?\u0003?\u03e6\b?\u0001" + + "?\u0001?\u0001?\u0001?\u0001@\u0003@\u03ed\b@\u0001@\u0003@\u03f0\b@\u0001" + + "@\u0001@\u0001@\u0003@\u03f5\b@\u0001@\u0001@\u0001@\u0003@\u03fa\b@\u0001" + + "A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001" + + "C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0003D\u040f" + + "\bD\u0001E\u0004E\u0412\bE\u000bE\fE\u0413\u0001E\u0003E\u0417\bE\u0001" + + "F\u0001F\u0001G\u0001G\u0001H\u0001H\u0001I\u0001I\u0001I\u0003I\u0422" + + "\bI\u0001J\u0001J\u0001J\u0001J\u0003J\u0428\bJ\u0001K\u0004K\u042b\b" + + "K\u000bK\fK\u042c\u0001K\u0003K\u0430\bK\u0001L\u0004L\u0433\bL\u000b" + + "L\fL\u0434\u0001L\u0003L\u0438\bL\u0001M\u0003M\u043b\bM\u0001M\u0001" + + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001" + + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003M\u0451" + + "\bM\u0001N\u0001N\u0001N\u0001N\u0003N\u0457\bN\u0001O\u0001O\u0001O\u0001" + + "O\u0003O\u045d\bO\u0001O\u0001O\u0001P\u0001P\u0003P\u0463\bP\u0001P\u0003" + + "P\u0466\bP\u0001P\u0001P\u0001P\u0001P\u0003P\u046c\bP\u0001P\u0001P\u0003" + + "P\u0470\bP\u0001P\u0001P\u0003P\u0474\bP\u0001P\u0003P\u0477\bP\u0001" + + "Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0003R\u047f\bR\u0003R\u0481\bR\u0001" + + "R\u0001R\u0001S\u0001S\u0003S\u0487\bS\u0001S\u0003S\u048a\bS\u0001S\u0003" + + "S\u048d\bS\u0001S\u0003S\u0490\bS\u0001T\u0001T\u0003T\u0494\bT\u0001" + + "T\u0001T\u0003T\u0498\bT\u0001T\u0001T\u0001U\u0001U\u0003U\u049e\bU\u0001" + + "V\u0001V\u0001V\u0001W\u0001W\u0001W\u0005W\u04a6\bW\nW\fW\u04a9\tW\u0001" + + "X\u0001X\u0001X\u0003X\u04ae\bX\u0001Y\u0001Y\u0001Z\u0001Z\u0003Z\u04b4" + + "\bZ\u0001[\u0001[\u0001\\\u0003\\\u04b9\b\\\u0001\\\u0001\\\u0001\\\u0003" + + "\\\u04be\b\\\u0001\\\u0001\\\u0003\\\u04c2\b\\\u0001\\\u0001\\\u0001]" + + "\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0003_\u04cf" + + "\b_\u0001_\u0001_\u0001`\u0001`\u0003`\u04d5\b`\u0001`\u0001`\u0003`\u04d9" + + "\b`\u0001`\u0001`\u0001`\u0001a\u0003a\u04df\ba\u0001a\u0001a\u0001a\u0003" + + "a\u04e4\ba\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001b\u0001b\u0001" + + "b\u0001c\u0001c\u0001c\u0001c\u0003c\u04f3\bc\u0001c\u0001c\u0003c\u04f7" + + "\bc\u0001d\u0004d\u04fa\bd\u000bd\fd\u04fb\u0001e\u0001e\u0001e\u0003" + + "e\u0501\be\u0001e\u0001e\u0001e\u0003e\u0506\be\u0001f\u0001f\u0001f\u0001" + + "f\u0003f\u050c\bf\u0001f\u0003f\u050f\bf\u0001f\u0001f\u0001g\u0001g\u0001" + + "g\u0005g\u0516\bg\ng\fg\u0519\tg\u0001g\u0003g\u051c\bg\u0001h\u0001h" + + "\u0001h\u0003h\u0521\bh\u0001h\u0001h\u0003h\u0525\bh\u0001i\u0001i\u0001" + + "j\u0001j\u0003j\u052b\bj\u0001j\u0001j\u0001k\u0004k\u0530\bk\u000bk\f" + + "k\u0531\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001" + + "l\u0001l\u0001l\u0001l\u0001l\u0004l\u0541\bl\u000bl\fl\u0542\u0003l\u0545" + + "\bl\u0001m\u0001m\u0001m\u0005m\u054a\bm\nm\fm\u054d\tm\u0001n\u0001n" + + "\u0003n\u0551\bn\u0001o\u0001o\u0001o\u0001o\u0001o\u0003o\u0558\bo\u0001" + + "p\u0001p\u0003p\u055c\bp\u0005p\u055e\bp\np\fp\u0561\tp\u0001p\u0001p" + + "\u0001q\u0001q\u0001q\u0003q\u0568\bq\u0001q\u0001q\u0001q\u0001q\u0003" + + "q\u056e\bq\u0001q\u0001q\u0001q\u0001q\u0003q\u0574\bq\u0001q\u0001q\u0003" + + "q\u0578\bq\u0003q\u057a\bq\u0005q\u057c\bq\nq\fq\u057f\tq\u0001r\u0001" + + "r\u0003r\u0583\br\u0001r\u0001r\u0003r\u0587\br\u0001r\u0003r\u058a\b" + + "r\u0001r\u0003r\u058d\br\u0001r\u0003r\u0590\br\u0001s\u0001s\u0001s\u0003" + + "s\u0595\bs\u0001t\u0001t\u0003t\u0599\bt\u0001t\u0003t\u059c\bt\u0001" + + "t\u0001t\u0003t\u05a0\bt\u0001t\u0003t\u05a3\bt\u0003t\u05a5\bt\u0001" + + "u\u0004u\u05a8\bu\u000bu\fu\u05a9\u0001v\u0001v\u0001w\u0001w\u0001x\u0003" + + "x\u05b1\bx\u0001x\u0001x\u0001y\u0001y\u0003y\u05b7\by\u0001z\u0001z\u0003" + + "z\u05bb\bz\u0001z\u0001z\u0001z\u0001z\u0003z\u05c1\bz\u0001{\u0001{\u0004" + + "{\u05c5\b{\u000b{\f{\u05c6\u0001{\u0003{\u05ca\b{\u0003{\u05cc\b{\u0001" + + "|\u0001|\u0001|\u0001|\u0003|\u05d2\b|\u0001|\u0001|\u0003|\u05d6\b|\u0001" + + "|\u0001|\u0001|\u0001|\u0003|\u05dc\b|\u0001|\u0001|\u0001|\u0001|\u0001" + + "|\u0003|\u05e3\b|\u0001|\u0001|\u0003|\u05e7\b|\u0003|\u05e9\b|\u0005" + + "|\u05eb\b|\n|\f|\u05ee\t|\u0001}\u0005}\u05f1\b}\n}\f}\u05f4\t}\u0001" + + "}\u0001}\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0003~\u05ff" + + "\b~\u0001~\u0001~\u0003~\u0603\b~\u0003~\u0605\b~\u0005~\u0607\b~\n~\f" + + "~\u060a\t~\u0001\u007f\u0001\u007f\u0003\u007f\u060e\b\u007f\u0001\u007f" + + "\u0003\u007f\u0611\b\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0005\u0080" + + "\u0616\b\u0080\n\u0080\f\u0080\u0619\t\u0080\u0001\u0081\u0003\u0081\u061c" + + "\b\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u0621\b\u0081" + + "\u0003\u0081\u0623\b\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u0627\b" + + "\u0081\u0001\u0082\u0003\u0082\u062a\b\u0082\u0001\u0082\u0003\u0082\u062d" + + "\b\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u0631\b\u0082\u0001\u0082" + + "\u0001\u0082\u0001\u0083\u0003\u0083\u0636\b\u0083\u0001\u0083\u0001\u0083" + + "\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u063d\b\u0083\u0001\u0084" + + "\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084\u0644\b\u0084" + + "\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u0649\b\u0085\u0001\u0086" + + "\u0001\u0086\u0003\u0086\u064d\b\u0086\u0001\u0087\u0001\u0087\u0003\u0087" + + "\u0651\b\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0003\u0087\u0656\b" + + "\u0087\u0005\u0087\u0658\b\u0087\n\u0087\f\u0087\u065b\t\u0087\u0001\u0088" + + "\u0001\u0088\u0001\u0088\u0003\u0088\u0660\b\u0088\u0003\u0088\u0662\b" + + "\u0088\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089\u0003\u0089\u0668" + + "\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u066d\b\u008a" + + "\u0001\u008a\u0001\u008a\u0001\u008b\u0001\u008b\u0003\u008b\u0673\b\u008b" + + "\u0001\u008b\u0001\u008b\u0003\u008b\u0677\b\u008b\u0003\u008b\u0679\b" + + "\u008b\u0001\u008b\u0003\u008b\u067c\b\u008b\u0001\u008b\u0001\u008b\u0003" + + "\u008b\u0680\b\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0684\b\u008b" + + "\u0003\u008b\u0686\b\u008b\u0003\u008b\u0688\b\u008b\u0001\u008c\u0003" + + "\u008c\u068b\b\u008c\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0001" + + "\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0004" + + "\u008f\u0697\b\u008f\u000b\u008f\f\u008f\u0698\u0001\u0090\u0003\u0090" + + "\u069c\b\u0090\u0001\u0090\u0003\u0090\u069f\b\u0090\u0001\u0090\u0003" + + "\u0090\u06a2\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001" + + "\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u06ab\b\u0090\u0001\u0091\u0001" + + "\u0091\u0001\u0091\u0005\u0091\u06b0\b\u0091\n\u0091\f\u0091\u06b3\t\u0091" + + "\u0001\u0092\u0001\u0092\u0003\u0092\u06b7\b\u0092\u0001\u0092\u0003\u0092" + + "\u06ba\b\u0092\u0001\u0092\u0003\u0092\u06bd\b\u0092\u0003\u0092\u06bf" + + "\b\u0092\u0001\u0092\u0003\u0092\u06c2\b\u0092\u0001\u0092\u0003\u0092" + + "\u06c5\b\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u06c9\b\u0092\u0001" + + "\u0093\u0004\u0093\u06cc\b\u0093\u000b\u0093\f\u0093\u06cd\u0001\u0094" + + "\u0001\u0094\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0096" + + "\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0003\u0097\u06db\b\u0097" + + "\u0001\u0097\u0001\u0097\u0001\u0097\u0003\u0097\u06e0\b\u0097\u0005\u0097" + + "\u06e2\b\u0097\n\u0097\f\u0097\u06e5\t\u0097\u0001\u0098\u0003\u0098\u06e8" + + "\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u06ed\b\u0098" + + "\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u06f2\b\u0098\u0001\u0098" + + "\u0001\u0098\u0003\u0098\u06f6\b\u0098\u0001\u0099\u0003\u0099\u06f9\b" + + "\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u06fd\b\u0099\u0001\u009a\u0001" + + "\u009a\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0001\u009c\u0001" + + "\u009d\u0001\u009d\u0003\u009d\u0708\b\u009d\u0001\u009e\u0001\u009e\u0003" + + "\u009e\u070c\b\u009e\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u00a0\u0001" + + "\u00a0\u0003\u00a0\u0713\b\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003" + + "\u00a0\u0718\b\u00a0\u0005\u00a0\u071a\b\u00a0\n\u00a0\f\u00a0\u071d\t" + + "\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0003\u00a1\u0722\b\u00a1\u0001" + + "\u00a1\u0001\u00a1\u0003\u00a1\u0726\b\u00a1\u0001\u00a2\u0001\u00a2\u0003" + + "\u00a2\u072a\b\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4\u0001" + + "\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4\u0733\b\u00a4\u0001\u00a5\u0001" + + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001" + + "\u00a6\u0001\u00a6\u0005\u00a6\u073e\b\u00a6\n\u00a6\f\u00a6\u0741\t\u00a6" + + "\u0001\u00a7\u0001\u00a7\u0003\u00a7\u0745\b\u00a7\u0001\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u074c\b\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0003\u00a8\u0750\b\u00a8\u0001\u00a8\u0003\u00a8\u0753\b" + + "\u00a8\u0001\u00a8\u0003\u00a8\u0756\b\u00a8\u0001\u00a8\u0003\u00a8\u0759" + + "\b\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u075d\b\u00a8\u0001\u00a9" + + "\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0762\b\u00a9\u0001\u00a9\u0001\u00a9" + + "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa\u0769\b\u00aa\u0001\u00aa" + + "\u0001\u00aa\u0003\u00aa\u076d\b\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa" + + "\u0771\b\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0003\u00ac" + + "\u0777\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u077c\b" + + "\u00ac\u0005\u00ac\u077e\b\u00ac\n\u00ac\f\u00ac\u0781\t\u00ac\u0001\u00ad" + + "\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0786\b\u00ad\u0001\u00ae\u0001\u00ae" + + "\u0001\u00ae\u0001\u00ae\u0003\u00ae\u078c\b\u00ae\u0001\u00ae\u0003\u00ae" + + "\u078f\b\u00ae\u0001\u00af\u0003\u00af\u0792\b\u00af\u0001\u00af\u0001" + + "\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001" + + "\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0001" + + "\u00b2\u0003\u00b2\u07a2\b\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001" + + "\u00b3\u0004\u00b3\u07a8\b\u00b3\u000b\u00b3\f\u00b3\u07a9\u0001\u00b4" + + "\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b5" + + "\u0003\u00b5\u07b3\b\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003\u00b5" + + "\u07b8\b\u00b5\u0001\u00b5\u0003\u00b5\u07bb\b\u00b5\u0001\u00b6\u0001" + + "\u00b6\u0003\u00b6\u07bf\b\u00b6\u0001\u00b7\u0001\u00b7\u0003\u00b7\u07c3" + + "\b\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8\u07c8\b\u00b8" + + "\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0003\u00b9\u07ce\b\u00b9" + + "\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u07d3\b\u00b9\u0005\u00b9" + + "\u07d5\b\u00b9\n\u00b9\f\u00b9\u07d8\t\u00b9\u0001\u00ba\u0001\u00ba\u0001" + + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u07e0\b\u00ba\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb\u07e5\b\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0003\u00bb\u07ea\b\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb\u0817" + + "\b\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0000\u0006\n\u001e2\u00e2" + + "\u00f8\u00fc\u00bd\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014" + + "\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfh" + + "jlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092" + + "\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa" + + "\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2" + + "\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da" + + "\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2" + + "\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a" + + "\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122" + + "\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a" + + "\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152" + + "\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a" + + "\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u0000\u0015\u0002\u0000aae" + + "e\u0004\u0000\u0018\u0018\u001f\u001f::AA\u0002\u0000||\u0081\u0081\u0001" + + "\u0000xy\u0002\u0000[]ad\u0002\u0000{{\u0082\u0082\u0001\u0000]_\u0001" + + "\u0000[\\\u0002\u0000fgtu\u0001\u0000rs\u0002\u0000eehq\u0005\u0000$$" + + "//99??FF\u0003\u0000\"\",,PP\u0002\u0000\u0015\u0015BB\u0001\u0000UZ\u0002" + + "\u0000aavv\u0002\u0000\u0016\u0016RR\u0001\u0000\u001b\u001c\u0002\u0000" + + "&&55\u0001\u000068\u0001\u0000\u0001\u0007\u0901\u0000\u017b\u0001\u0000" + + "\u0000\u0000\u0002\u018b\u0001\u0000\u0000\u0000\u0004\u018f\u0001\u0000" + + "\u0000\u0000\u0006\u019b\u0001\u0000\u0000\u0000\b\u019d\u0001\u0000\u0000" + + "\u0000\n\u01a3\u0001\u0000\u0000\u0000\f\u01b9\u0001\u0000\u0000\u0000" + + "\u000e\u01bf\u0001\u0000\u0000\u0000\u0010\u01cb\u0001\u0000\u0000\u0000" + + "\u0012\u01cd\u0001\u0000\u0000\u0000\u0014\u01cf\u0001\u0000\u0000\u0000" + + "\u0016\u01dc\u0001\u0000\u0000\u0000\u0018\u01e3\u0001\u0000\u0000\u0000" + + "\u001a\u01e6\u0001\u0000\u0000\u0000\u001c\u01eb\u0001\u0000\u0000\u0000" + + "\u001e\u021a\u0001\u0000\u0000\u0000 \u023a\u0001\u0000\u0000\u0000\"" + + "\u023c\u0001\u0000\u0000\u0000$\u0251\u0001\u0000\u0000\u0000&\u026e\u0001" + + "\u0000\u0000\u0000(\u0270\u0001\u0000\u0000\u0000*\u0273\u0001\u0000\u0000" + + "\u0000,\u0283\u0001\u0000\u0000\u0000.\u0287\u0001\u0000\u0000\u00000" + + "\u0290\u0001\u0000\u0000\u00002\u0292\u0001\u0000\u0000\u00004\u02ab\u0001" + + "\u0000\u0000\u00006\u02ae\u0001\u0000\u0000\u00008\u02b7\u0001\u0000\u0000" + + "\u0000:\u02c2\u0001\u0000\u0000\u0000<\u02c4\u0001\u0000\u0000\u0000>" + + "\u02cc\u0001\u0000\u0000\u0000@\u02d4\u0001\u0000\u0000\u0000B\u02dc\u0001" + + "\u0000\u0000\u0000D\u02e9\u0001\u0000\u0000\u0000F\u02eb\u0001\u0000\u0000" + + "\u0000H\u02f3\u0001\u0000\u0000\u0000J\u02fb\u0001\u0000\u0000\u0000L" + + "\u0303\u0001\u0000\u0000\u0000N\u030b\u0001\u0000\u0000\u0000P\u0313\u0001" + + "\u0000\u0000\u0000R\u031b\u0001\u0000\u0000\u0000T\u0323\u0001\u0000\u0000" + + "\u0000V\u0331\u0001\u0000\u0000\u0000X\u0333\u0001\u0000\u0000\u0000Z" + + "\u0335\u0001\u0000\u0000\u0000\\\u033d\u0001\u0000\u0000\u0000^\u034c" + + "\u0001\u0000\u0000\u0000`\u034f\u0001\u0000\u0000\u0000b\u035b\u0001\u0000" + + "\u0000\u0000d\u035f\u0001\u0000\u0000\u0000f\u0366\u0001\u0000\u0000\u0000" + + "h\u0379\u0001\u0000\u0000\u0000j\u0386\u0001\u0000\u0000\u0000l\u03a9" + + "\u0001\u0000\u0000\u0000n\u03ad\u0001\u0000\u0000\u0000p\u03b0\u0001\u0000" + + "\u0000\u0000r\u03b7\u0001\u0000\u0000\u0000t\u03c2\u0001\u0000\u0000\u0000" + + "v\u03c6\u0001\u0000\u0000\u0000x\u03c9\u0001\u0000\u0000\u0000z\u03d6" + + "\u0001\u0000\u0000\u0000|\u03e0\u0001\u0000\u0000\u0000~\u03e2\u0001\u0000" + + "\u0000\u0000\u0080\u03f9\u0001\u0000\u0000\u0000\u0082\u03fb\u0001\u0000" + + "\u0000\u0000\u0084\u0403\u0001\u0000\u0000\u0000\u0086\u0405\u0001\u0000" + + "\u0000\u0000\u0088\u040e\u0001\u0000\u0000\u0000\u008a\u0411\u0001\u0000" + + "\u0000\u0000\u008c\u0418\u0001\u0000\u0000\u0000\u008e\u041a\u0001\u0000" + + "\u0000\u0000\u0090\u041c\u0001\u0000\u0000\u0000\u0092\u0421\u0001\u0000" + + "\u0000\u0000\u0094\u0427\u0001\u0000\u0000\u0000\u0096\u042a\u0001\u0000" + + "\u0000\u0000\u0098\u0432\u0001\u0000\u0000\u0000\u009a\u0450\u0001\u0000" + + "\u0000\u0000\u009c\u0456\u0001\u0000\u0000\u0000\u009e\u0458\u0001\u0000" + + "\u0000\u0000\u00a0\u0476\u0001\u0000\u0000\u0000\u00a2\u0478\u0001\u0000" + + "\u0000\u0000\u00a4\u047a\u0001\u0000\u0000\u0000\u00a6\u0484\u0001\u0000" + + "\u0000\u0000\u00a8\u0491\u0001\u0000\u0000\u0000\u00aa\u049b\u0001\u0000" + + "\u0000\u0000\u00ac\u049f\u0001\u0000\u0000\u0000\u00ae\u04a2\u0001\u0000" + + "\u0000\u0000\u00b0\u04aa\u0001\u0000\u0000\u0000\u00b2\u04af\u0001\u0000" + + "\u0000\u0000\u00b4\u04b3\u0001\u0000\u0000\u0000\u00b6\u04b5\u0001\u0000" + + "\u0000\u0000\u00b8\u04b8\u0001\u0000\u0000\u0000\u00ba\u04c5\u0001\u0000" + + "\u0000\u0000\u00bc\u04c7\u0001\u0000\u0000\u0000\u00be\u04ce\u0001\u0000" + + "\u0000\u0000\u00c0\u04d2\u0001\u0000\u0000\u0000\u00c2\u04de\u0001\u0000" + + "\u0000\u0000\u00c4\u04e8\u0001\u0000\u0000\u0000\u00c6\u04ee\u0001\u0000" + + "\u0000\u0000\u00c8\u04f9\u0001\u0000\u0000\u0000\u00ca\u0505\u0001\u0000" + + "\u0000\u0000\u00cc\u0507\u0001\u0000\u0000\u0000\u00ce\u0512\u0001\u0000" + + "\u0000\u0000\u00d0\u0520\u0001\u0000\u0000\u0000\u00d2\u0526\u0001\u0000" + + "\u0000\u0000\u00d4\u0528\u0001\u0000\u0000\u0000\u00d6\u052f\u0001\u0000" + + "\u0000\u0000\u00d8\u0544\u0001\u0000\u0000\u0000\u00da\u0546\u0001\u0000" + + "\u0000\u0000\u00dc\u054e\u0001\u0000\u0000\u0000\u00de\u0557\u0001\u0000" + + "\u0000\u0000\u00e0\u055f\u0001\u0000\u0000\u0000\u00e2\u056d\u0001\u0000" + + "\u0000\u0000\u00e4\u0580\u0001\u0000\u0000\u0000\u00e6\u0591\u0001\u0000" + + "\u0000\u0000\u00e8\u05a4\u0001\u0000\u0000\u0000\u00ea\u05a7\u0001\u0000" + + "\u0000\u0000\u00ec\u05ab\u0001\u0000\u0000\u0000\u00ee\u05ad\u0001\u0000" + + "\u0000\u0000\u00f0\u05b0\u0001\u0000\u0000\u0000\u00f2\u05b4\u0001\u0000" + + "\u0000\u0000\u00f4\u05c0\u0001\u0000\u0000\u0000\u00f6\u05cb\u0001\u0000" + + "\u0000\u0000\u00f8\u05db\u0001\u0000\u0000\u0000\u00fa\u05f2\u0001\u0000" + + "\u0000\u0000\u00fc\u05f7\u0001\u0000\u0000\u0000\u00fe\u060b\u0001\u0000" + + "\u0000\u0000\u0100\u0612\u0001\u0000\u0000\u0000\u0102\u061b\u0001\u0000" + + "\u0000\u0000\u0104\u0629\u0001\u0000\u0000\u0000\u0106\u063c\u0001\u0000" + + "\u0000\u0000\u0108\u0643\u0001\u0000\u0000\u0000\u010a\u0648\u0001\u0000" + + "\u0000\u0000\u010c\u064c\u0001\u0000\u0000\u0000\u010e\u064e\u0001\u0000" + + "\u0000\u0000\u0110\u065c\u0001\u0000\u0000\u0000\u0112\u0667\u0001\u0000" + + "\u0000\u0000\u0114\u0669\u0001\u0000\u0000\u0000\u0116\u0687\u0001\u0000" + + "\u0000\u0000\u0118\u068a\u0001\u0000\u0000\u0000\u011a\u068e\u0001\u0000" + + "\u0000\u0000\u011c\u0690\u0001\u0000\u0000\u0000\u011e\u0696\u0001\u0000" + + "\u0000\u0000\u0120\u06aa\u0001\u0000\u0000\u0000\u0122\u06ac\u0001\u0000" + + "\u0000\u0000\u0124\u06c8\u0001\u0000\u0000\u0000\u0126\u06cb\u0001\u0000" + + "\u0000\u0000\u0128\u06cf\u0001\u0000\u0000\u0000\u012a\u06d1\u0001\u0000" + + "\u0000\u0000\u012c\u06d5\u0001\u0000\u0000\u0000\u012e\u06d8\u0001\u0000" + + "\u0000\u0000\u0130\u06e7\u0001\u0000\u0000\u0000\u0132\u06fc\u0001\u0000" + + "\u0000\u0000\u0134\u06fe\u0001\u0000\u0000\u0000\u0136\u0700\u0001\u0000" + + "\u0000\u0000\u0138\u0702\u0001\u0000\u0000\u0000\u013a\u0705\u0001\u0000" + + "\u0000\u0000\u013c\u0709\u0001\u0000\u0000\u0000\u013e\u070d\u0001\u0000" + + "\u0000\u0000\u0140\u0710\u0001\u0000\u0000\u0000\u0142\u071e\u0001\u0000" + + "\u0000\u0000\u0144\u0729\u0001\u0000\u0000\u0000\u0146\u072b\u0001\u0000" + + "\u0000\u0000\u0148\u072e\u0001\u0000\u0000\u0000\u014a\u0734\u0001\u0000" + + "\u0000\u0000\u014c\u073a\u0001\u0000\u0000\u0000\u014e\u0744\u0001\u0000" + + "\u0000\u0000\u0150\u074f\u0001\u0000\u0000\u0000\u0152\u075e\u0001\u0000" + + "\u0000\u0000\u0154\u0770\u0001\u0000\u0000\u0000\u0156\u0772\u0001\u0000" + + "\u0000\u0000\u0158\u0774\u0001\u0000\u0000\u0000\u015a\u0785\u0001\u0000" + + "\u0000\u0000\u015c\u0787\u0001\u0000\u0000\u0000\u015e\u0791\u0001\u0000" + + "\u0000\u0000\u0160\u0796\u0001\u0000\u0000\u0000\u0162\u079b\u0001\u0000" + + "\u0000\u0000\u0164\u079f\u0001\u0000\u0000\u0000\u0166\u07a7\u0001\u0000" + + "\u0000\u0000\u0168\u07ab\u0001\u0000\u0000\u0000\u016a\u07ba\u0001\u0000" + + "\u0000\u0000\u016c\u07bc\u0001\u0000\u0000\u0000\u016e\u07c2\u0001\u0000" + + "\u0000\u0000\u0170\u07c4\u0001\u0000\u0000\u0000\u0172\u07cb\u0001\u0000" + + "\u0000\u0000\u0174\u07df\u0001\u0000\u0000\u0000\u0176\u0816\u0001\u0000" + + "\u0000\u0000\u0178\u0818\u0001\u0000\u0000\u0000\u017a\u017c\u0003x<\u0000" + + "\u017b\u017a\u0001\u0000\u0000\u0000\u017b\u017c\u0001\u0000\u0000\u0000" + + "\u017c\u017d\u0001\u0000\u0000\u0000\u017d\u017e\u0005\u0000\u0000\u0001" + + "\u017e\u0001\u0001\u0000\u0000\u0000\u017f\u0181\u0003\u0178\u00bc\u0000" + + "\u0180\u017f\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000\u0000\u0000" + + "\u0182\u0180\u0001\u0000\u0000\u0000\u0182\u0183\u0001\u0000\u0000\u0000" + + "\u0183\u018c\u0001\u0000\u0000\u0000\u0184\u018c\u0005E\u0000\u0000\u0185" + + "\u0186\u0005U\u0000\u0000\u0186\u0187\u0003Z-\u0000\u0187\u0188\u0005" + + "V\u0000\u0000\u0188\u018c\u0001\u0000\u0000\u0000\u0189\u018c\u0003\u0004" + + "\u0002\u0000\u018a\u018c\u0003\f\u0006\u0000\u018b\u0180\u0001\u0000\u0000" + + "\u0000\u018b\u0184\u0001\u0000\u0000\u0000\u018b\u0185\u0001\u0000\u0000" + + "\u0000\u018b\u0189\u0001\u0000\u0000\u0000\u018b\u018a\u0001\u0000\u0000" + + "\u0000\u018c\u0003\u0001\u0000\u0000\u0000\u018d\u0190\u0003\u0006\u0003" + + "\u0000\u018e\u0190\u0003\b\u0004\u0000\u018f\u018d\u0001\u0000\u0000\u0000" + + "\u018f\u018e\u0001\u0000\u0000\u0000\u0190\u0005\u0001\u0000\u0000\u0000" + + "\u0191\u019c\u0005\u0084\u0000\u0000\u0192\u019c\u0003\u0146\u00a3\u0000" + + "\u0193\u019c\u0003\u0138\u009c\u0000\u0194\u019c\u0003\u0148\u00a4\u0000" + + "\u0195\u0198\u0005c\u0000\u0000\u0196\u0199\u0003\u0112\u0089\u0000\u0197" + + "\u0199\u0003\u009eO\u0000\u0198\u0196\u0001\u0000\u0000\u0000\u0198\u0197" + + "\u0001\u0000\u0000\u0000\u0199\u019c\u0001\u0000\u0000\u0000\u019a\u019c" + + "\u0003\u0154\u00aa\u0000\u019b\u0191\u0001\u0000\u0000\u0000\u019b\u0192" + + "\u0001\u0000\u0000\u0000\u019b\u0193\u0001\u0000\u0000\u0000\u019b\u0194" + + "\u0001\u0000\u0000\u0000\u019b\u0195\u0001\u0000\u0000\u0000\u019b\u019a" + + "\u0001\u0000\u0000\u0000\u019c\u0007\u0001\u0000\u0000\u0000\u019d\u019f" + + "\u0003\n\u0005\u0000\u019e\u01a0\u0005D\u0000\u0000\u019f\u019e\u0001" + + "\u0000\u0000\u0000\u019f\u01a0\u0001\u0000\u0000\u0000\u01a0\u01a1\u0001" + + "\u0000\u0000\u0000\u01a1\u01a2\u0003\u0006\u0003\u0000\u01a2\t\u0001\u0000" + + "\u0000\u0000\u01a3\u01a7\u0006\u0005\uffff\uffff\u0000\u01a4\u01a8\u0003" + + "\u009cN\u0000\u01a5\u01a8\u0003\u00b4Z\u0000\u01a6\u01a8\u0003\u009eO" + + "\u0000\u01a7\u01a4\u0001\u0000\u0000\u0000\u01a7\u01a5\u0001\u0000\u0000" + + "\u0000\u01a7\u01a6\u0001\u0000\u0000\u0000\u01a7\u01a8\u0001\u0000\u0000" + + "\u0000\u01a8\u01a9\u0001\u0000\u0000\u0000\u01a9\u01aa\u0005\u007f\u0000" + + "\u0000\u01aa\u01b6\u0001\u0000\u0000\u0000\u01ab\u01b1\n\u0001\u0000\u0000" + + "\u01ac\u01b2\u0005\u0084\u0000\u0000\u01ad\u01af\u0005D\u0000\u0000\u01ae" + + "\u01ad\u0001\u0000\u0000\u0000\u01ae\u01af\u0001\u0000\u0000\u0000\u01af" + + "\u01b0\u0001\u0000\u0000\u0000\u01b0\u01b2\u0003\u0152\u00a9\u0000\u01b1" + + "\u01ac\u0001\u0000\u0000\u0000\u01b1\u01ae\u0001\u0000\u0000\u0000\u01b2" + + "\u01b3\u0001\u0000\u0000\u0000\u01b3\u01b5\u0005\u007f\u0000\u0000\u01b4" + + "\u01ab\u0001\u0000\u0000\u0000\u01b5\u01b8\u0001\u0000\u0000\u0000\u01b6" + + "\u01b4\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000\u0000\u0000\u01b7" + + "\u000b\u0001\u0000\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000\u0000\u01b9" + + "\u01bb\u0003\u000e\u0007\u0000\u01ba\u01bc\u0003\u001c\u000e\u0000\u01bb" + + "\u01ba\u0001\u0000\u0000\u0000\u01bb\u01bc\u0001\u0000\u0000\u0000\u01bc" + + "\u01bd\u0001\u0000\u0000\u0000\u01bd\u01be\u0003d2\u0000\u01be\r\u0001" + + "\u0000\u0000\u0000\u01bf\u01c1\u0005W\u0000\u0000\u01c0\u01c2\u0003\u0010" + + "\b\u0000\u01c1\u01c0\u0001\u0000\u0000\u0000\u01c1\u01c2\u0001\u0000\u0000" + + "\u0000\u01c2\u01c3\u0001\u0000\u0000\u0000\u01c3\u01c4\u0005X\u0000\u0000" + + "\u01c4\u000f\u0001\u0000\u0000\u0000\u01c5\u01cc\u0003\u0014\n\u0000\u01c6" + + "\u01c9\u0003\u0012\t\u0000\u01c7\u01c8\u0005z\u0000\u0000\u01c8\u01ca" + + "\u0003\u0014\n\u0000\u01c9\u01c7\u0001\u0000\u0000\u0000\u01c9\u01ca\u0001" + + "\u0000\u0000\u0000\u01ca\u01cc\u0001\u0000\u0000\u0000\u01cb\u01c5\u0001" + + "\u0000\u0000\u0000\u01cb\u01c6\u0001\u0000\u0000\u0000\u01cc\u0011\u0001" + + "\u0000\u0000\u0000\u01cd\u01ce\u0007\u0000\u0000\u0000\u01ce\u0013\u0001" + + "\u0000\u0000\u0000\u01cf\u01d4\u0003\u0016\u000b\u0000\u01d0\u01d1\u0005" + + "z\u0000\u0000\u01d1\u01d3\u0003\u0016\u000b\u0000\u01d2\u01d0\u0001\u0000" + + "\u0000\u0000\u01d3\u01d6\u0001\u0000\u0000\u0000\u01d4\u01d2\u0001\u0000" + + "\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000\u0000\u01d5\u01d8\u0001\u0000" + + "\u0000\u0000\u01d6\u01d4\u0001\u0000\u0000\u0000\u01d7\u01d9\u0005\u0083" + + "\u0000\u0000\u01d8\u01d7\u0001\u0000\u0000\u0000\u01d8\u01d9\u0001\u0000" + + "\u0000\u0000\u01d9\u0015\u0001\u0000\u0000\u0000\u01da\u01dd\u0003\u0018" + + "\f\u0000\u01db\u01dd\u0003\u001a\r\u0000\u01dc\u01da\u0001\u0000\u0000" + + "\u0000\u01dc\u01db\u0001\u0000\u0000\u0000\u01dd\u0017\u0001\u0000\u0000" + + "\u0000\u01de\u01e0\u0005a\u0000\u0000\u01df\u01de\u0001\u0000\u0000\u0000" + + "\u01df\u01e0\u0001\u0000\u0000\u0000\u01e0\u01e1\u0001\u0000\u0000\u0000" + + "\u01e1\u01e4\u0005\u0084\u0000\u0000\u01e2\u01e4\u0005E\u0000\u0000\u01e3" + + "\u01df\u0001\u0000\u0000\u0000\u01e3\u01e2\u0001\u0000\u0000\u0000\u01e4" + + "\u0019\u0001\u0000\u0000\u0000\u01e5\u01e7\u0005a\u0000\u0000\u01e6\u01e5" + + "\u0001\u0000\u0000\u0000\u01e6\u01e7\u0001\u0000\u0000\u0000\u01e7\u01e8" + + "\u0001\u0000\u0000\u0000\u01e8\u01e9\u0005\u0084\u0000\u0000\u01e9\u01ea" + + "\u0003\u0108\u0084\u0000\u01ea\u001b\u0001\u0000\u0000\u0000\u01eb\u01ed" + + "\u0005U\u0000\u0000\u01ec\u01ee\u0003\u00fe\u007f\u0000\u01ed\u01ec\u0001" + + "\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000\u0000\u01ee\u01ef\u0001" + + "\u0000\u0000\u0000\u01ef\u01f1\u0005V\u0000\u0000\u01f0\u01f2\u0005/\u0000" + + "\u0000\u01f1\u01f0\u0001\u0000\u0000\u0000\u01f1\u01f2\u0001\u0000\u0000" + + "\u0000\u01f2\u01f4\u0001\u0000\u0000\u0000\u01f3\u01f5\u0003\u016e\u00b7" + + "\u0000\u01f4\u01f3\u0001\u0000\u0000\u0000\u01f4\u01f5\u0001\u0000\u0000" + + "\u0000\u01f5\u01f7\u0001\u0000\u0000\u0000\u01f6\u01f8\u0003\u00c8d\u0000" + + "\u01f7\u01f6\u0001\u0000\u0000\u0000\u01f7\u01f8\u0001\u0000\u0000\u0000" + + "\u01f8\u01fa\u0001\u0000\u0000\u0000\u01f9\u01fb\u0003\u00e6s\u0000\u01fa" + + "\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000\u0000\u01fb" + + "\u001d\u0001\u0000\u0000\u0000\u01fc\u01fd\u0006\u000f\uffff\uffff\u0000" + + "\u01fd\u021b\u0003\u0002\u0001\u0000\u01fe\u0201\u0003\u009aM\u0000\u01ff" + + "\u0201\u0003\u015c\u00ae\u0000\u0200\u01fe\u0001\u0000\u0000\u0000\u0200" + + "\u01ff\u0001\u0000\u0000\u0000\u0201\u0208\u0001\u0000\u0000\u0000\u0202" + + "\u0204\u0005U\u0000\u0000\u0203\u0205\u0003\"\u0011\u0000\u0204\u0203" + + "\u0001\u0000\u0000\u0000\u0204\u0205\u0001\u0000\u0000\u0000\u0205\u0206" + + "\u0001\u0000\u0000\u0000\u0206\u0209\u0005V\u0000\u0000\u0207\u0209\u0003" + + "\u0110\u0088\u0000\u0208\u0202\u0001\u0000\u0000\u0000\u0208\u0207\u0001" + + "\u0000\u0000\u0000\u0209\u021b\u0001\u0000\u0000\u0000\u020a\u020b\u0007" + + "\u0001\u0000\u0000\u020b\u020c\u0005f\u0000\u0000\u020c\u020d\u0003\u00f2" + + "y\u0000\u020d\u020e\u0005g\u0000\u0000\u020e\u020f\u0005U\u0000\u0000" + + "\u020f\u0210\u0003Z-\u0000\u0210\u0211\u0005V\u0000\u0000\u0211\u021b" + + "\u0001\u0000\u0000\u0000\u0212\u0213\u0003 \u0010\u0000\u0213\u0216\u0005" + + "U\u0000\u0000\u0214\u0217\u0003Z-\u0000\u0215\u0217\u0003\u00f2y\u0000" + + "\u0216\u0214\u0001\u0000\u0000\u0000\u0216\u0215\u0001\u0000\u0000\u0000" + + "\u0217\u0218\u0001\u0000\u0000\u0000\u0218\u0219\u0005V\u0000\u0000\u0219" + + "\u021b\u0001\u0000\u0000\u0000\u021a\u01fc\u0001\u0000\u0000\u0000\u021a" + + "\u0200\u0001\u0000\u0000\u0000\u021a\u020a\u0001\u0000\u0000\u0000\u021a" + + "\u0212\u0001\u0000\u0000\u0000\u021b\u0237\u0001\u0000\u0000\u0000\u021c" + + "\u021d\n\u0007\u0000\u0000\u021d\u0220\u0005W\u0000\u0000\u021e\u0221" + + "\u0003Z-\u0000\u021f\u0221\u0003\u0110\u0088\u0000\u0220\u021e\u0001\u0000" + + "\u0000\u0000\u0220\u021f\u0001\u0000\u0000\u0000\u0221\u0222\u0001\u0000" + + "\u0000\u0000\u0222\u0223\u0005X\u0000\u0000\u0223\u0236\u0001\u0000\u0000" + + "\u0000\u0224\u0225\n\u0006\u0000\u0000\u0225\u0227\u0005U\u0000\u0000" + + "\u0226\u0228\u0003\"\u0011\u0000\u0227\u0226\u0001\u0000\u0000\u0000\u0227" + + "\u0228\u0001\u0000\u0000\u0000\u0228\u0229\u0001\u0000\u0000\u0000\u0229" + + "\u0236\u0005V\u0000\u0000\u022a\u022b\n\u0004\u0000\u0000\u022b\u0231" + + "\u0007\u0002\u0000\u0000\u022c\u022e\u0005D\u0000\u0000\u022d\u022c\u0001" + + "\u0000\u0000\u0000\u022d\u022e\u0001\u0000\u0000\u0000\u022e\u022f\u0001" + + "\u0000\u0000\u0000\u022f\u0232\u0003\u0004\u0002\u0000\u0230\u0232\u0003" + + "$\u0012\u0000\u0231\u022d\u0001\u0000\u0000\u0000\u0231\u0230\u0001\u0000" + + "\u0000\u0000\u0232\u0236\u0001\u0000\u0000\u0000\u0233\u0234\n\u0003\u0000" + + "\u0000\u0234\u0236\u0007\u0003\u0000\u0000\u0235\u021c\u0001\u0000\u0000" + + "\u0000\u0235\u0224\u0001\u0000\u0000\u0000\u0235\u022a\u0001\u0000\u0000" + + "\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0236\u0239\u0001\u0000\u0000" + + "\u0000\u0237\u0235\u0001\u0000\u0000\u0000\u0237\u0238\u0001\u0000\u0000" + + "\u0000\u0238\u001f\u0001\u0000\u0000\u0000\u0239\u0237\u0001\u0000\u0000" + + "\u0000\u023a\u023b\u0005K\u0000\u0000\u023b!\u0001\u0000\u0000\u0000\u023c" + + "\u023d\u0003\u010e\u0087\u0000\u023d#\u0001\u0000\u0000\u0000\u023e\u0240" + + "\u0003\n\u0005\u0000\u023f\u023e\u0001\u0000\u0000\u0000\u023f\u0240\u0001" + + "\u0000\u0000\u0000\u0240\u0244\u0001\u0000\u0000\u0000\u0241\u0242\u0003" + + "\u009cN\u0000\u0242\u0243\u0005\u007f\u0000\u0000\u0243\u0245\u0001\u0000" + + "\u0000\u0000\u0244\u0241\u0001\u0000\u0000\u0000\u0244\u0245\u0001\u0000" + + "\u0000\u0000\u0245\u0246\u0001\u0000\u0000\u0000\u0246\u0247\u0005c\u0000" + + "\u0000\u0247\u0252\u0003\u009cN\u0000\u0248\u0249\u0003\n\u0005\u0000" + + "\u0249\u024a\u0005D\u0000\u0000\u024a\u024b\u0003\u0152\u00a9\u0000\u024b" + + "\u024c\u0005\u007f\u0000\u0000\u024c\u024d\u0005c\u0000\u0000\u024d\u024e" + + "\u0003\u009cN\u0000\u024e\u0252\u0001\u0000\u0000\u0000\u024f\u0250\u0005" + + "c\u0000\u0000\u0250\u0252\u0003\u009eO\u0000\u0251\u023f\u0001\u0000\u0000" + + "\u0000\u0251\u0248\u0001\u0000\u0000\u0000\u0251\u024f\u0001\u0000\u0000" + + "\u0000\u0252%\u0001\u0000\u0000\u0000\u0253\u026f\u0003\u001e\u000f\u0000" + + "\u0254\u0259\u0005x\u0000\u0000\u0255\u0259\u0005y\u0000\u0000\u0256\u0259" + + "\u0003(\u0014\u0000\u0257\u0259\u0005>\u0000\u0000\u0258\u0254\u0001\u0000" + + "\u0000\u0000\u0258\u0255\u0001\u0000\u0000\u0000\u0258\u0256\u0001\u0000" + + "\u0000\u0000\u0258\u0257\u0001\u0000\u0000\u0000\u0259\u025a\u0001\u0000" + + "\u0000\u0000\u025a\u026f\u0003&\u0013\u0000\u025b\u0264\u0005>\u0000\u0000" + + "\u025c\u025d\u0005U\u0000\u0000\u025d\u025e\u0003\u00f2y\u0000\u025e\u025f" + + "\u0005V\u0000\u0000\u025f\u0265\u0001\u0000\u0000\u0000\u0260\u0261\u0005" + + "\u0083\u0000\u0000\u0261\u0262\u0005U\u0000\u0000\u0262\u0263\u0005\u0084" + + "\u0000\u0000\u0263\u0265\u0005V\u0000\u0000\u0264\u025c\u0001\u0000\u0000" + + "\u0000\u0264\u0260\u0001\u0000\u0000\u0000\u0265\u026f\u0001\u0000\u0000" + + "\u0000\u0266\u0267\u0005\u000b\u0000\u0000\u0267\u0268\u0005U\u0000\u0000" + + "\u0268\u0269\u0003\u00f2y\u0000\u0269\u026a\u0005V\u0000\u0000\u026a\u026f" + + "\u0001\u0000\u0000\u0000\u026b\u026f\u00038\u001c\u0000\u026c\u026f\u0003" + + "*\u0015\u0000\u026d\u026f\u00036\u001b\u0000\u026e\u0253\u0001\u0000\u0000" + + "\u0000\u026e\u0258\u0001\u0000\u0000\u0000\u026e\u025b\u0001\u0000\u0000" + + "\u0000\u026e\u0266\u0001\u0000\u0000\u0000\u026e\u026b\u0001\u0000\u0000" + + "\u0000\u026e\u026c\u0001\u0000\u0000\u0000\u026e\u026d\u0001\u0000\u0000" + + "\u0000\u026f\'\u0001\u0000\u0000\u0000\u0270\u0271\u0007\u0004\u0000\u0000" + + "\u0271)\u0001\u0000\u0000\u0000\u0272\u0274\u0005\u007f\u0000\u0000\u0273" + + "\u0272\u0001\u0000\u0000\u0000\u0273\u0274\u0001\u0000\u0000\u0000\u0274" + + "\u0275\u0001\u0000\u0000\u0000\u0275\u0277\u00051\u0000\u0000\u0276\u0278" + + "\u0003,\u0016\u0000\u0277\u0276\u0001\u0000\u0000\u0000\u0277\u0278\u0001" + + "\u0000\u0000\u0000\u0278\u027e\u0001\u0000\u0000\u0000\u0279\u027f\u0003" + + ".\u0017\u0000\u027a\u027b\u0005U\u0000\u0000\u027b\u027c\u0003\u00f2y" + + "\u0000\u027c\u027d\u0005V\u0000\u0000\u027d\u027f\u0001\u0000\u0000\u0000" + + "\u027e\u0279\u0001\u0000\u0000\u0000\u027e\u027a\u0001\u0000\u0000\u0000" + + "\u027f\u0281\u0001\u0000\u0000\u0000\u0280\u0282\u00034\u001a\u0000\u0281" + + "\u0280\u0001\u0000\u0000\u0000\u0281\u0282\u0001\u0000\u0000\u0000\u0282" + + "+\u0001\u0000\u0000\u0000\u0283\u0284\u0005U\u0000\u0000\u0284\u0285\u0003" + + "\"\u0011\u0000\u0285\u0286\u0005V\u0000\u0000\u0286-\u0001\u0000\u0000" + + "\u0000\u0287\u0289\u0003\u0096K\u0000\u0288\u028a\u00030\u0018\u0000\u0289" + + "\u0288\u0001\u0000\u0000\u0000\u0289\u028a\u0001\u0000\u0000\u0000\u028a" + + "/\u0001\u0000\u0000\u0000\u028b\u028d\u0003\u00e8t\u0000\u028c\u028e\u0003" + + "0\u0018\u0000\u028d\u028c\u0001\u0000\u0000\u0000\u028d\u028e\u0001\u0000" + + "\u0000\u0000\u028e\u0291\u0001\u0000\u0000\u0000\u028f\u0291\u00032\u0019" + + "\u0000\u0290\u028b\u0001\u0000\u0000\u0000\u0290\u028f\u0001\u0000\u0000" + + "\u0000\u02911\u0001\u0000\u0000\u0000\u0292\u0293\u0006\u0019\uffff\uffff" + + "\u0000\u0293\u0294\u0005W\u0000\u0000\u0294\u0295\u0003Z-\u0000\u0295" + + "\u0297\u0005X\u0000\u0000\u0296\u0298\u0003\u00c8d\u0000\u0297\u0296\u0001" + + "\u0000\u0000\u0000\u0297\u0298\u0001\u0000\u0000\u0000\u0298\u02a2\u0001" + + "\u0000\u0000\u0000\u0299\u029a\n\u0001\u0000\u0000\u029a\u029b\u0005W" + + "\u0000\u0000\u029b\u029c\u0003\\.\u0000\u029c\u029e\u0005X\u0000\u0000" + + "\u029d\u029f\u0003\u00c8d\u0000\u029e\u029d\u0001\u0000\u0000\u0000\u029e" + + "\u029f\u0001\u0000\u0000\u0000\u029f\u02a1\u0001\u0000\u0000\u0000\u02a0" + + "\u0299\u0001\u0000\u0000\u0000\u02a1\u02a4\u0001\u0000\u0000\u0000\u02a2" + + "\u02a0\u0001\u0000\u0000\u0000\u02a2\u02a3\u0001\u0000\u0000\u0000\u02a3" + + "3\u0001\u0000\u0000\u0000\u02a4\u02a2\u0001\u0000\u0000\u0000\u02a5\u02a7" + + "\u0005U\u0000\u0000\u02a6\u02a8\u0003\"\u0011\u0000\u02a7\u02a6\u0001" + + "\u0000\u0000\u0000\u02a7\u02a8\u0001\u0000\u0000\u0000\u02a8\u02a9\u0001" + + "\u0000\u0000\u0000\u02a9\u02ac\u0005V\u0000\u0000\u02aa\u02ac\u0003\u0110" + + "\u0088\u0000\u02ab\u02a5\u0001\u0000\u0000\u0000\u02ab\u02aa\u0001\u0000" + + "\u0000\u0000\u02ac5\u0001\u0000\u0000\u0000\u02ad\u02af\u0005\u007f\u0000" + + "\u0000\u02ae\u02ad\u0001\u0000\u0000\u0000\u02ae\u02af\u0001\u0000\u0000" + + "\u0000\u02af\u02b0\u0001\u0000\u0000\u0000\u02b0\u02b3\u0005\u001c\u0000" + + "\u0000\u02b1\u02b2\u0005W\u0000\u0000\u02b2\u02b4\u0005X\u0000\u0000\u02b3" + + "\u02b1\u0001\u0000\u0000\u0000\u02b3\u02b4\u0001\u0000\u0000\u0000\u02b4" + + "\u02b5\u0001\u0000\u0000\u0000\u02b5\u02b6\u0003:\u001d\u0000\u02b67\u0001" + + "\u0000\u0000\u0000\u02b7\u02b8\u00052\u0000\u0000\u02b8\u02b9\u0005U\u0000" + + "\u0000\u02b9\u02ba\u0003Z-\u0000\u02ba\u02bb\u0005V\u0000\u0000\u02bb" + + "9\u0001\u0000\u0000\u0000\u02bc\u02c3\u0003&\u0013\u0000\u02bd\u02be\u0005" + + "U\u0000\u0000\u02be\u02bf\u0003\u00f2y\u0000\u02bf\u02c0\u0005V\u0000" + + "\u0000\u02c0\u02c1\u0003:\u001d\u0000\u02c1\u02c3\u0001\u0000\u0000\u0000" + + "\u02c2\u02bc\u0001\u0000\u0000\u0000\u02c2\u02bd\u0001\u0000\u0000\u0000" + + "\u02c3;\u0001\u0000\u0000\u0000\u02c4\u02c9\u0003:\u001d\u0000\u02c5\u02c6" + + "\u0007\u0005\u0000\u0000\u02c6\u02c8\u0003:\u001d\u0000\u02c7\u02c5\u0001" + + "\u0000\u0000\u0000\u02c8\u02cb\u0001\u0000\u0000\u0000\u02c9\u02c7\u0001" + + "\u0000\u0000\u0000\u02c9\u02ca\u0001\u0000\u0000\u0000\u02ca=\u0001\u0000" + + "\u0000\u0000\u02cb\u02c9\u0001\u0000\u0000\u0000\u02cc\u02d1\u0003<\u001e" + + "\u0000\u02cd\u02ce\u0007\u0006\u0000\u0000\u02ce\u02d0\u0003<\u001e\u0000" + + "\u02cf\u02cd\u0001\u0000\u0000\u0000\u02d0\u02d3\u0001\u0000\u0000\u0000" + + "\u02d1\u02cf\u0001\u0000\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000" + + "\u02d2?\u0001\u0000\u0000\u0000\u02d3\u02d1\u0001\u0000\u0000\u0000\u02d4" + + "\u02d9\u0003>\u001f\u0000\u02d5\u02d6\u0007\u0007\u0000\u0000\u02d6\u02d8" + + "\u0003>\u001f\u0000\u02d7\u02d5\u0001\u0000\u0000\u0000\u02d8\u02db\u0001" + + "\u0000\u0000\u0000\u02d9\u02d7\u0001\u0000\u0000\u0000\u02d9\u02da\u0001" + + "\u0000\u0000\u0000\u02daA\u0001\u0000\u0000\u0000\u02db\u02d9\u0001\u0000" + + "\u0000\u0000\u02dc\u02e2\u0003@ \u0000\u02dd\u02de\u0003D\"\u0000\u02de" + + "\u02df\u0003@ \u0000\u02df\u02e1\u0001\u0000\u0000\u0000\u02e0\u02dd\u0001" + + "\u0000\u0000\u0000\u02e1\u02e4\u0001\u0000\u0000\u0000\u02e2\u02e0\u0001" + + "\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000\u0000\u02e3C\u0001\u0000" + + "\u0000\u0000\u02e4\u02e2\u0001\u0000\u0000\u0000\u02e5\u02e6\u0005g\u0000" + + "\u0000\u02e6\u02ea\u0005g\u0000\u0000\u02e7\u02e8\u0005f\u0000\u0000\u02e8" + + "\u02ea\u0005f\u0000\u0000\u02e9\u02e5\u0001\u0000\u0000\u0000\u02e9\u02e7" + + "\u0001\u0000\u0000\u0000\u02eaE\u0001\u0000\u0000\u0000\u02eb\u02f0\u0003" + + "B!\u0000\u02ec\u02ed\u0007\b\u0000\u0000\u02ed\u02ef\u0003B!\u0000\u02ee" + + "\u02ec\u0001\u0000\u0000\u0000\u02ef\u02f2\u0001\u0000\u0000\u0000\u02f0" + + "\u02ee\u0001\u0000\u0000\u0000\u02f0\u02f1\u0001\u0000\u0000\u0000\u02f1" + + "G\u0001\u0000\u0000\u0000\u02f2\u02f0\u0001\u0000\u0000\u0000\u02f3\u02f8" + + "\u0003F#\u0000\u02f4\u02f5\u0007\t\u0000\u0000\u02f5\u02f7\u0003F#\u0000" + + "\u02f6\u02f4\u0001\u0000\u0000\u0000\u02f7\u02fa\u0001\u0000\u0000\u0000" + + "\u02f8\u02f6\u0001\u0000\u0000\u0000\u02f8\u02f9\u0001\u0000\u0000\u0000" + + "\u02f9I\u0001\u0000\u0000\u0000\u02fa\u02f8\u0001\u0000\u0000\u0000\u02fb" + + "\u0300\u0003H$\u0000\u02fc\u02fd\u0005a\u0000\u0000\u02fd\u02ff\u0003" + + "H$\u0000\u02fe\u02fc\u0001\u0000\u0000\u0000\u02ff\u0302\u0001\u0000\u0000" + + "\u0000\u0300\u02fe\u0001\u0000\u0000\u0000\u0300\u0301\u0001\u0000\u0000" + + "\u0000\u0301K\u0001\u0000\u0000\u0000\u0302\u0300\u0001\u0000\u0000\u0000" + + "\u0303\u0308\u0003J%\u0000\u0304\u0305\u0005`\u0000\u0000\u0305\u0307" + + "\u0003J%\u0000\u0306\u0304\u0001\u0000\u0000\u0000\u0307\u030a\u0001\u0000" + + "\u0000\u0000\u0308\u0306\u0001\u0000\u0000\u0000\u0308\u0309\u0001\u0000" + + "\u0000\u0000\u0309M\u0001\u0000\u0000\u0000\u030a\u0308\u0001\u0000\u0000" + + "\u0000\u030b\u0310\u0003L&\u0000\u030c\u030d\u0005b\u0000\u0000\u030d" + + "\u030f\u0003L&\u0000\u030e\u030c\u0001\u0000\u0000\u0000\u030f\u0312\u0001" + + "\u0000\u0000\u0000\u0310\u030e\u0001\u0000\u0000\u0000\u0310\u0311\u0001" + + "\u0000\u0000\u0000\u0311O\u0001\u0000\u0000\u0000\u0312\u0310\u0001\u0000" + + "\u0000\u0000\u0313\u0318\u0003N\'\u0000\u0314\u0315\u0005v\u0000\u0000" + + "\u0315\u0317\u0003N\'\u0000\u0316\u0314\u0001\u0000\u0000\u0000\u0317" + + "\u031a\u0001\u0000\u0000\u0000\u0318\u0316\u0001\u0000\u0000\u0000\u0318" + + "\u0319\u0001\u0000\u0000\u0000\u0319Q\u0001\u0000\u0000\u0000\u031a\u0318" + + "\u0001\u0000\u0000\u0000\u031b\u0320\u0003P(\u0000\u031c\u031d\u0005w" + + "\u0000\u0000\u031d\u031f\u0003P(\u0000\u031e\u031c\u0001\u0000\u0000\u0000" + + "\u031f\u0322\u0001\u0000\u0000\u0000\u0320\u031e\u0001\u0000\u0000\u0000" + + "\u0320\u0321\u0001\u0000\u0000\u0000\u0321S\u0001\u0000\u0000\u0000\u0322" + + "\u0320\u0001\u0000\u0000\u0000\u0323\u0329\u0003R)\u0000\u0324\u0325\u0005" + + "}\u0000\u0000\u0325\u0326\u0003Z-\u0000\u0326\u0327\u0005~\u0000\u0000" + + "\u0327\u0328\u0003V+\u0000\u0328\u032a\u0001\u0000\u0000\u0000\u0329\u0324" + + "\u0001\u0000\u0000\u0000\u0329\u032a\u0001\u0000\u0000\u0000\u032aU\u0001" + + "\u0000\u0000\u0000\u032b\u0332\u0003T*\u0000\u032c\u032d\u0003R)\u0000" + + "\u032d\u032e\u0003X,\u0000\u032e\u032f\u0003\u010c\u0086\u0000\u032f\u0332" + + "\u0001\u0000\u0000\u0000\u0330\u0332\u0003\u016c\u00b6\u0000\u0331\u032b" + + "\u0001\u0000\u0000\u0000\u0331\u032c\u0001\u0000\u0000\u0000\u0331\u0330" + + "\u0001\u0000\u0000\u0000\u0332W\u0001\u0000\u0000\u0000\u0333\u0334\u0007" + + "\n\u0000\u0000\u0334Y\u0001\u0000\u0000\u0000\u0335\u033a\u0003V+\u0000" + + "\u0336\u0337\u0005z\u0000\u0000\u0337\u0339\u0003V+\u0000\u0338\u0336" + + "\u0001\u0000\u0000\u0000\u0339\u033c\u0001\u0000\u0000\u0000\u033a\u0338" + + "\u0001\u0000\u0000\u0000\u033a\u033b\u0001\u0000\u0000\u0000\u033b[\u0001" + + "\u0000\u0000\u0000\u033c\u033a\u0001\u0000\u0000\u0000\u033d\u033e\u0003" + + "T*\u0000\u033e]\u0001\u0000\u0000\u0000\u033f\u034d\u0003`0\u0000\u0340" + + "\u0342\u0003\u00c8d\u0000\u0341\u0340\u0001\u0000\u0000\u0000\u0341\u0342" + + "\u0001\u0000\u0000\u0000\u0342\u0349\u0001\u0000\u0000\u0000\u0343\u034a" + + "\u0003b1\u0000\u0344\u034a\u0003d2\u0000\u0345\u034a\u0003h4\u0000\u0346" + + "\u034a\u0003l6\u0000\u0347\u034a\u0003t:\u0000\u0348\u034a\u0003\u0162" + + "\u00b1\u0000\u0349\u0343\u0001\u0000\u0000\u0000\u0349\u0344\u0001\u0000" + + "\u0000\u0000\u0349\u0345\u0001\u0000\u0000\u0000\u0349\u0346\u0001\u0000" + + "\u0000\u0000\u0349\u0347\u0001\u0000\u0000\u0000\u0349\u0348\u0001\u0000" + + "\u0000\u0000\u034a\u034d\u0001\u0000\u0000\u0000\u034b\u034d\u0003v;\u0000" + + "\u034c\u033f\u0001\u0000\u0000\u0000\u034c\u0341\u0001\u0000\u0000\u0000" + + "\u034c\u034b\u0001\u0000\u0000\u0000\u034d_\u0001\u0000\u0000\u0000\u034e" + + "\u0350\u0003\u00c8d\u0000\u034f\u034e\u0001\u0000\u0000\u0000\u034f\u0350" + + "\u0001\u0000\u0000\u0000\u0350\u0355\u0001\u0000\u0000\u0000\u0351\u0356" + + "\u0005\u0084\u0000\u0000\u0352\u0353\u0005\u0010\u0000\u0000\u0353\u0356" + + "\u0003\\.\u0000\u0354\u0356\u0005\u001b\u0000\u0000\u0355\u0351\u0001" + + "\u0000\u0000\u0000\u0355\u0352\u0001\u0000\u0000\u0000\u0355\u0354\u0001" + + "\u0000\u0000\u0000\u0356\u0357\u0001\u0000\u0000\u0000\u0357\u0358\u0005" + + "~\u0000\u0000\u0358\u0359\u0003^/\u0000\u0359a\u0001\u0000\u0000\u0000" + + "\u035a\u035c\u0003Z-\u0000\u035b\u035a\u0001\u0000\u0000\u0000\u035b\u035c" + + "\u0001\u0000\u0000\u0000\u035c\u035d\u0001\u0000\u0000\u0000\u035d\u035e" + + "\u0005\u0080\u0000\u0000\u035ec\u0001\u0000\u0000\u0000\u035f\u0361\u0005" + + "Y\u0000\u0000\u0360\u0362\u0003f3\u0000\u0361\u0360\u0001\u0000\u0000" + + "\u0000\u0361\u0362\u0001\u0000\u0000\u0000\u0362\u0363\u0001\u0000\u0000" + + "\u0000\u0363\u0364\u0005Z\u0000\u0000\u0364e\u0001\u0000\u0000\u0000\u0365" + + "\u0367\u0003^/\u0000\u0366\u0365\u0001\u0000\u0000\u0000\u0367\u0368\u0001" + + "\u0000\u0000\u0000\u0368\u0366\u0001\u0000\u0000\u0000\u0368\u0369\u0001" + + "\u0000\u0000\u0000\u0369g\u0001\u0000\u0000\u0000\u036a\u036b\u0005+\u0000" + + "\u0000\u036b\u036c\u0005U\u0000\u0000\u036c\u036d\u0003j5\u0000\u036d" + + "\u036e\u0005V\u0000\u0000\u036e\u0371\u0003^/\u0000\u036f\u0370\u0005" + + " \u0000\u0000\u0370\u0372\u0003^/\u0000\u0371\u036f\u0001\u0000\u0000" + + "\u0000\u0371\u0372\u0001\u0000\u0000\u0000\u0372\u037a\u0001\u0000\u0000" + + "\u0000\u0373\u0374\u0005C\u0000\u0000\u0374\u0375\u0005U\u0000\u0000\u0375" + + "\u0376\u0003j5\u0000\u0376\u0377\u0005V\u0000\u0000\u0377\u0378\u0003" + + "^/\u0000\u0378\u037a\u0001\u0000\u0000\u0000\u0379\u036a\u0001\u0000\u0000" + + "\u0000\u0379\u0373\u0001\u0000\u0000\u0000\u037ai\u0001\u0000\u0000\u0000" + + "\u037b\u0387\u0003Z-\u0000\u037c\u037e\u0003\u00c8d\u0000\u037d\u037c" + + "\u0001\u0000\u0000\u0000\u037d\u037e\u0001\u0000\u0000\u0000\u037e\u037f" + + "\u0001\u0000\u0000\u0000\u037f\u0380\u0003\u008aE\u0000\u0380\u0384\u0003" + + "\u00deo\u0000\u0381\u0382\u0005e\u0000\u0000\u0382\u0385\u0003\u010c\u0086" + + "\u0000\u0383\u0385\u0003\u0110\u0088\u0000\u0384\u0381\u0001\u0000\u0000" + + "\u0000\u0384\u0383\u0001\u0000\u0000\u0000\u0385\u0387\u0001\u0000\u0000" + + "\u0000\u0386\u037b\u0001\u0000\u0000\u0000\u0386\u037d\u0001\u0000\u0000" + + "\u0000\u0387k\u0001\u0000\u0000\u0000\u0388\u0389\u0005T\u0000\u0000\u0389" + + "\u038a\u0005U\u0000\u0000\u038a\u038b\u0003j5\u0000\u038b\u038c\u0005" + + "V\u0000\u0000\u038c\u038d\u0003^/\u0000\u038d\u03aa\u0001\u0000\u0000" + + "\u0000\u038e\u038f\u0005\u001d\u0000\u0000\u038f\u0390\u0003^/\u0000\u0390" + + "\u0391\u0005T\u0000\u0000\u0391\u0392\u0005U\u0000\u0000\u0392\u0393\u0003" + + "Z-\u0000\u0393\u0394\u0005V\u0000\u0000\u0394\u0395\u0005\u0080\u0000" + + "\u0000\u0395\u03aa\u0001\u0000\u0000\u0000\u0396\u0397\u0005(\u0000\u0000" + + "\u0397\u03a4\u0005U\u0000\u0000\u0398\u039a\u0003n7\u0000\u0399\u039b" + + "\u0003j5\u0000\u039a\u0399\u0001\u0000\u0000\u0000\u039a\u039b\u0001\u0000" + + "\u0000\u0000\u039b\u039c\u0001\u0000\u0000\u0000\u039c\u039e\u0005\u0080" + + "\u0000\u0000\u039d\u039f\u0003Z-\u0000\u039e\u039d\u0001\u0000\u0000\u0000" + + "\u039e\u039f\u0001\u0000\u0000\u0000\u039f\u03a5\u0001\u0000\u0000\u0000" + + "\u03a0\u03a1\u0003p8\u0000\u03a1\u03a2\u0005~\u0000\u0000\u03a2\u03a3" + + "\u0003r9\u0000\u03a3\u03a5\u0001\u0000\u0000\u0000\u03a4\u0398\u0001\u0000" + + "\u0000\u0000\u03a4\u03a0\u0001\u0000\u0000\u0000\u03a5\u03a6\u0001\u0000" + + "\u0000\u0000\u03a6\u03a7\u0005V\u0000\u0000\u03a7\u03a8\u0003^/\u0000" + + "\u03a8\u03aa\u0001\u0000\u0000\u0000\u03a9\u0388\u0001\u0000\u0000\u0000" + + "\u03a9\u038e\u0001\u0000\u0000\u0000\u03a9\u0396\u0001\u0000\u0000\u0000" + + "\u03aam\u0001\u0000\u0000\u0000\u03ab\u03ae\u0003b1\u0000\u03ac\u03ae" + + "\u0003\u0080@\u0000\u03ad\u03ab\u0001\u0000\u0000\u0000\u03ad\u03ac\u0001" + + "\u0000\u0000\u0000\u03aeo\u0001\u0000\u0000\u0000\u03af\u03b1\u0003\u00c8" + + "d\u0000\u03b0\u03af\u0001\u0000\u0000\u0000\u03b0\u03b1\u0001\u0000\u0000" + + "\u0000\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2\u03b3\u0003\u008aE\u0000" + + "\u03b3\u03b4\u0003\u00deo\u0000\u03b4q\u0001\u0000\u0000\u0000\u03b5\u03b8" + + "\u0003Z-\u0000\u03b6\u03b8\u0003\u0110\u0088\u0000\u03b7\u03b5\u0001\u0000" + + "\u0000\u0000\u03b7\u03b6\u0001\u0000\u0000\u0000\u03b8s\u0001\u0000\u0000" + + "\u0000\u03b9\u03c3\u0005\u000f\u0000\u0000\u03ba\u03c3\u0005\u0019\u0000" + + "\u0000\u03bb\u03be\u0005;\u0000\u0000\u03bc\u03bf\u0003Z-\u0000\u03bd" + + "\u03bf\u0003\u0110\u0088\u0000\u03be\u03bc\u0001\u0000\u0000\u0000\u03be" + + "\u03bd\u0001\u0000\u0000\u0000\u03be\u03bf\u0001\u0000\u0000\u0000\u03bf" + + "\u03c3\u0001\u0000\u0000\u0000\u03c0\u03c1\u0005*\u0000\u0000\u03c1\u03c3" + + "\u0005\u0084\u0000\u0000\u03c2\u03b9\u0001\u0000\u0000\u0000\u03c2\u03ba" + + "\u0001\u0000\u0000\u0000\u03c2\u03bb\u0001\u0000\u0000\u0000\u03c2\u03c0" + + "\u0001\u0000\u0000\u0000\u03c3\u03c4\u0001\u0000\u0000\u0000\u03c4\u03c5" + + "\u0005\u0080\u0000\u0000\u03c5u\u0001\u0000\u0000\u0000\u03c6\u03c7\u0003" + + "|>\u0000\u03c7w\u0001\u0000\u0000\u0000\u03c8\u03ca\u0003z=\u0000\u03c9" + + "\u03c8\u0001\u0000\u0000\u0000\u03ca\u03cb\u0001\u0000\u0000\u0000\u03cb" + + "\u03c9\u0001\u0000\u0000\u0000\u03cb\u03cc\u0001\u0000\u0000\u0000\u03cc" + + "y\u0001\u0000\u0000\u0000\u03cd\u03d7\u0003|>\u0000\u03ce\u03d7\u0003" + + "\u0104\u0082\u0000\u03cf\u03d7\u0003\u014a\u00a5\u0000\u03d0\u03d7\u0003" + + "\u015e\u00af\u0000\u03d1\u03d7\u0003\u0160\u00b0\u0000\u03d2\u03d7\u0003" + + "\u00c6c\u0000\u03d3\u03d7\u0003\u00b8\\\u0000\u03d4\u03d7\u0003\u0084" + + "B\u0000\u03d5\u03d7\u0003\u0086C\u0000\u03d6\u03cd\u0001\u0000\u0000\u0000" + + "\u03d6\u03ce\u0001\u0000\u0000\u0000\u03d6\u03cf\u0001\u0000\u0000\u0000" + + "\u03d6\u03d0\u0001\u0000\u0000\u0000\u03d6\u03d1\u0001\u0000\u0000\u0000" + + "\u03d6\u03d2\u0001\u0000\u0000\u0000\u03d6\u03d3\u0001\u0000\u0000\u0000" + + "\u03d6\u03d4\u0001\u0000\u0000\u0000\u03d6\u03d5\u0001\u0000\u0000\u0000" + + "\u03d7{\u0001\u0000\u0000\u0000\u03d8\u03e1\u0003\u0080@\u0000\u03d9\u03e1" + + "\u0003\u00c4b\u0000\u03da\u03e1\u0003\u00bc^\u0000\u03db\u03e1\u0003\u00c0" + + "`\u0000\u03dc\u03e1\u0003\u00c2a\u0000\u03dd\u03e1\u0003\u0082A\u0000" + + "\u03de\u03e1\u0003~?\u0000\u03df\u03e1\u0003\u00a8T\u0000\u03e0\u03d8" + + "\u0001\u0000\u0000\u0000\u03e0\u03d9\u0001\u0000\u0000\u0000\u03e0\u03da" + + "\u0001\u0000\u0000\u0000\u03e0\u03db\u0001\u0000\u0000\u0000\u03e0\u03dc" + + "\u0001\u0000\u0000\u0000\u03e0\u03dd\u0001\u0000\u0000\u0000\u03e0\u03de" + + "\u0001\u0000\u0000\u0000\u03e0\u03df\u0001\u0000\u0000\u0000\u03e1}\u0001" + + "\u0000\u0000\u0000\u03e2\u03e3\u0005O\u0000\u0000\u03e3\u03e5\u0005\u0084" + + "\u0000\u0000\u03e4\u03e6\u0003\u00c8d\u0000\u03e5\u03e4\u0001\u0000\u0000" + + "\u0000\u03e5\u03e6\u0001\u0000\u0000\u0000\u03e6\u03e7\u0001\u0000\u0000" + + "\u0000\u03e7\u03e8\u0005e\u0000\u0000\u03e8\u03e9\u0003\u00f2y\u0000\u03e9" + + "\u03ea\u0005\u0080\u0000\u0000\u03ea\u007f\u0001\u0000\u0000\u0000\u03eb" + + "\u03ed\u0003\u008aE\u0000\u03ec\u03eb\u0001\u0000\u0000\u0000\u03ec\u03ed" + + "\u0001\u0000\u0000\u0000\u03ed\u03ef\u0001\u0000\u0000\u0000\u03ee\u03f0" + + "\u0003\u00dam\u0000\u03ef\u03ee\u0001\u0000\u0000\u0000\u03ef\u03f0\u0001" + + "\u0000\u0000\u0000\u03f0\u03f1\u0001\u0000\u0000\u0000\u03f1\u03fa\u0005" + + "\u0080\u0000\u0000\u03f2\u03f4\u0003\u00c8d\u0000\u03f3\u03f5\u0003\u008a" + + "E\u0000\u03f4\u03f3\u0001\u0000\u0000\u0000\u03f4\u03f5\u0001\u0000\u0000" + + "\u0000\u03f5\u03f6\u0001\u0000\u0000\u0000\u03f6\u03f7\u0003\u00dam\u0000" + + "\u03f7\u03f8\u0005\u0080\u0000\u0000\u03f8\u03fa\u0001\u0000\u0000\u0000" + + "\u03f9\u03ec\u0001\u0000\u0000\u0000\u03f9\u03f2\u0001\u0000\u0000\u0000" + + "\u03fa\u0081\u0001\u0000\u0000\u0000\u03fb\u03fc\u0005@\u0000\u0000\u03fc" + + "\u03fd\u0005U\u0000\u0000\u03fd\u03fe\u0003\\.\u0000\u03fe\u03ff\u0005" + + "z\u0000\u0000\u03ff\u0400\u0005\u0004\u0000\u0000\u0400\u0401\u0005V\u0000" + + "\u0000\u0401\u0402\u0005\u0080\u0000\u0000\u0402\u0083\u0001\u0000\u0000" + + "\u0000\u0403\u0404\u0005\u0080\u0000\u0000\u0404\u0085\u0001\u0000\u0000" + + "\u0000\u0405\u0406\u0003\u00c8d\u0000\u0406\u0407\u0005\u0080\u0000\u0000" + + "\u0407\u0087\u0001\u0000\u0000\u0000\u0408\u040f\u0003\u008cF\u0000\u0409" + + "\u040f\u0003\u0092I\u0000\u040a\u040f\u0003\u008eG\u0000\u040b\u040f\u0005" + + ")\u0000\u0000\u040c\u040f\u0005J\u0000\u0000\u040d\u040f\u0005\u0017\u0000" + + "\u0000\u040e\u0408\u0001\u0000\u0000\u0000\u040e\u0409\u0001\u0000\u0000" + + "\u0000\u040e\u040a\u0001\u0000\u0000\u0000\u040e\u040b\u0001\u0000\u0000" + + "\u0000\u040e\u040c\u0001\u0000\u0000\u0000\u040e\u040d\u0001\u0000\u0000" + + "\u0000\u040f\u0089\u0001\u0000\u0000\u0000\u0410\u0412\u0003\u0088D\u0000" + + "\u0411\u0410\u0001\u0000\u0000\u0000\u0412\u0413\u0001\u0000\u0000\u0000" + + "\u0413\u0411\u0001\u0000\u0000\u0000\u0413\u0414\u0001\u0000\u0000\u0000" + + "\u0414\u0416\u0001\u0000\u0000\u0000\u0415\u0417\u0003\u00c8d\u0000\u0416" + + "\u0415\u0001\u0000\u0000\u0000\u0416\u0417\u0001\u0000\u0000\u0000\u0417" + + "\u008b\u0001\u0000\u0000\u0000\u0418\u0419\u0007\u000b\u0000\u0000\u0419" + + "\u008d\u0001\u0000\u0000\u0000\u041a\u041b\u0007\f\u0000\u0000\u041b\u008f" + + "\u0001\u0000\u0000\u0000\u041c\u041d\u0005\u0084\u0000\u0000\u041d\u0091" + + "\u0001\u0000\u0000\u0000\u041e\u0422\u0003\u0094J\u0000\u041f\u0422\u0003" + + "\u0114\u008a\u0000\u0420\u0422\u0003\u00a4R\u0000\u0421\u041e\u0001\u0000" + + "\u0000\u0000\u0421\u041f\u0001\u0000\u0000\u0000\u0421\u0420\u0001\u0000" + + "\u0000\u0000\u0422\u0093\u0001\u0000\u0000\u0000\u0423\u0428\u0003\u009a" + + "M\u0000\u0424\u0428\u0003\u00a0P\u0000\u0425\u0428\u0003\u015c\u00ae\u0000" + + "\u0426\u0428\u0003\u00ecv\u0000\u0427\u0423\u0001\u0000\u0000\u0000\u0427" + + "\u0424\u0001\u0000\u0000\u0000\u0427\u0425\u0001\u0000\u0000\u0000\u0427" + + "\u0426\u0001\u0000\u0000\u0000\u0428\u0095\u0001\u0000\u0000\u0000\u0429" + + "\u042b\u0003\u0092I\u0000\u042a\u0429\u0001\u0000\u0000\u0000\u042b\u042c" + + "\u0001\u0000\u0000\u0000\u042c\u042a\u0001\u0000\u0000\u0000\u042c\u042d" + + "\u0001\u0000\u0000\u0000\u042d\u042f\u0001\u0000\u0000\u0000\u042e\u0430" + + "\u0003\u00c8d\u0000\u042f\u042e\u0001\u0000\u0000\u0000\u042f\u0430\u0001" + + "\u0000\u0000\u0000\u0430\u0097\u0001\u0000\u0000\u0000\u0431\u0433\u0003" + + "\u0094J\u0000\u0432\u0431\u0001\u0000\u0000\u0000\u0433\u0434\u0001\u0000" + + "\u0000\u0000\u0434\u0432\u0001\u0000\u0000\u0000\u0434\u0435\u0001\u0000" + + "\u0000\u0000\u0435\u0437\u0001\u0000\u0000\u0000\u0436\u0438\u0003\u00c8" + + "d\u0000\u0437\u0436\u0001\u0000\u0000\u0000\u0437\u0438\u0001\u0000\u0000" + + "\u0000\u0438\u0099\u0001\u0000\u0000\u0000\u0439\u043b\u0003\n\u0005\u0000" + + "\u043a\u0439\u0001\u0000\u0000\u0000\u043a\u043b\u0001\u0000\u0000\u0000" + + "\u043b\u043c\u0001\u0000\u0000\u0000\u043c\u0451\u0003\u009cN\u0000\u043d" + + "\u043e\u0003\n\u0005\u0000\u043e\u043f\u0005D\u0000\u0000\u043f\u0440" + + "\u0003\u0152\u00a9\u0000\u0440\u0451\u0001\u0000\u0000\u0000\u0441\u0451" + + "\u0005\u0012\u0000\u0000\u0442\u0451\u0005\u0013\u0000\u0000\u0443\u0451" + + "\u0005\u0014\u0000\u0000\u0444\u0451\u0005S\u0000\u0000\u0445\u0451\u0005" + + "\u000e\u0000\u0000\u0446\u0451\u0005<\u0000\u0000\u0447\u0451\u0005-\u0000" + + "\u0000\u0448\u0451\u0005.\u0000\u0000\u0449\u0451\u0005=\u0000\u0000\u044a" + + "\u0451\u0005N\u0000\u0000\u044b\u0451\u0005\'\u0000\u0000\u044c\u0451" + + "\u0005\u001e\u0000\u0000\u044d\u0451\u0005Q\u0000\u0000\u044e\u0451\u0005" + + "\r\u0000\u0000\u044f\u0451\u0003\u009eO\u0000\u0450\u043a\u0001\u0000" + + "\u0000\u0000\u0450\u043d\u0001\u0000\u0000\u0000\u0450\u0441\u0001\u0000" + + "\u0000\u0000\u0450\u0442\u0001\u0000\u0000\u0000\u0450\u0443\u0001\u0000" + + "\u0000\u0000\u0450\u0444\u0001\u0000\u0000\u0000\u0450\u0445\u0001\u0000" + + "\u0000\u0000\u0450\u0446\u0001\u0000\u0000\u0000\u0450\u0447\u0001\u0000" + + "\u0000\u0000\u0450\u0448\u0001\u0000\u0000\u0000\u0450\u0449\u0001\u0000" + + "\u0000\u0000\u0450\u044a\u0001\u0000\u0000\u0000\u0450\u044b\u0001\u0000" + + "\u0000\u0000\u0450\u044c\u0001\u0000\u0000\u0000\u0450\u044d\u0001\u0000" + + "\u0000\u0000\u0450\u044e\u0001\u0000\u0000\u0000\u0450\u044f\u0001\u0000" + + "\u0000\u0000\u0451\u009b\u0001\u0000\u0000\u0000\u0452\u0457\u0003\u0112" + + "\u0089\u0000\u0453\u0457\u0003\u00a2Q\u0000\u0454\u0457\u0003\u0090H\u0000" + + "\u0455\u0457\u0003\u0152\u00a9\u0000\u0456\u0452\u0001\u0000\u0000\u0000" + + "\u0456\u0453\u0001\u0000\u0000\u0000\u0456\u0454\u0001\u0000\u0000\u0000" + + "\u0456\u0455\u0001\u0000\u0000\u0000\u0457\u009d\u0001\u0000\u0000\u0000" + + "\u0458\u0459\u0005\u001a\u0000\u0000\u0459\u045c\u0005U\u0000\u0000\u045a" + + "\u045d\u0003Z-\u0000\u045b\u045d\u0005\r\u0000\u0000\u045c\u045a\u0001" + + "\u0000\u0000\u0000\u045c\u045b\u0001\u0000\u0000\u0000\u045d\u045e\u0001" + + "\u0000\u0000\u0000\u045e\u045f\u0005V\u0000\u0000\u045f\u009f\u0001\u0000" + + "\u0000\u0000\u0460\u046f\u0003\u011c\u008e\u0000\u0461\u0463\u0003\u00c8" + + "d\u0000\u0462\u0461\u0001\u0000\u0000\u0000\u0462\u0463\u0001\u0000\u0000" + + "\u0000\u0463\u0465\u0001\u0000\u0000\u0000\u0464\u0466\u0003\n\u0005\u0000" + + "\u0465\u0464\u0001\u0000\u0000\u0000\u0465\u0466\u0001\u0000\u0000\u0000" + + "\u0466\u0467\u0001\u0000\u0000\u0000\u0467\u0470\u0005\u0084\u0000\u0000" + + "\u0468\u0470\u0003\u0152\u00a9\u0000\u0469\u046b\u0003\n\u0005\u0000\u046a" + + "\u046c\u0005D\u0000\u0000\u046b\u046a\u0001\u0000\u0000\u0000\u046b\u046c" + + "\u0001\u0000\u0000\u0000\u046c\u046d\u0001\u0000\u0000\u0000\u046d\u046e" + + "\u0003\u0152\u00a9\u0000\u046e\u0470\u0001\u0000\u0000\u0000\u046f\u0462" + + "\u0001\u0000\u0000\u0000\u046f\u0468\u0001\u0000\u0000\u0000\u046f\u0469" + + "\u0001\u0000\u0000\u0000\u0470\u0477\u0001\u0000\u0000\u0000\u0471\u0473" + + "\u0005!\u0000\u0000\u0472\u0474\u0003\n\u0005\u0000\u0473\u0472\u0001" + + "\u0000\u0000\u0000\u0473\u0474\u0001\u0000\u0000\u0000\u0474\u0475\u0001" + + "\u0000\u0000\u0000\u0475\u0477\u0005\u0084\u0000\u0000\u0476\u0460\u0001" + + "\u0000\u0000\u0000\u0476\u0471\u0001\u0000\u0000\u0000\u0477\u00a1\u0001" + + "\u0000\u0000\u0000\u0478\u0479\u0005\u0084\u0000\u0000\u0479\u00a3\u0001" + + "\u0000\u0000\u0000\u047a\u047b\u0003\u00a6S\u0000\u047b\u0480\u0005Y\u0000" + + "\u0000\u047c\u047e\u0003\u00aeW\u0000\u047d\u047f\u0005z\u0000\u0000\u047e" + + "\u047d\u0001\u0000\u0000\u0000\u047e\u047f\u0001\u0000\u0000\u0000\u047f" + + "\u0481\u0001\u0000\u0000\u0000\u0480\u047c\u0001\u0000\u0000\u0000\u0480" + + "\u0481\u0001\u0000\u0000\u0000\u0481\u0482\u0001\u0000\u0000\u0000\u0482" + + "\u0483\u0005Z\u0000\u0000\u0483\u00a5\u0001\u0000\u0000\u0000\u0484\u0486" + + "\u0003\u00aaU\u0000\u0485\u0487\u0003\u00c8d\u0000\u0486\u0485\u0001\u0000" + + "\u0000\u0000\u0486\u0487\u0001\u0000\u0000\u0000\u0487\u048c\u0001\u0000" + + "\u0000\u0000\u0488\u048a\u0003\n\u0005\u0000\u0489\u0488\u0001\u0000\u0000" + + "\u0000\u0489\u048a\u0001\u0000\u0000\u0000\u048a\u048b\u0001\u0000\u0000" + + "\u0000\u048b\u048d\u0005\u0084\u0000\u0000\u048c\u0489\u0001\u0000\u0000" + + "\u0000\u048c\u048d\u0001\u0000\u0000\u0000\u048d\u048f\u0001\u0000\u0000" + + "\u0000\u048e\u0490\u0003\u00acV\u0000\u048f\u048e\u0001\u0000\u0000\u0000" + + "\u048f\u0490\u0001\u0000\u0000\u0000\u0490\u00a7\u0001\u0000\u0000\u0000" + + "\u0491\u0493\u0003\u00aaU\u0000\u0492\u0494\u0003\u00c8d\u0000\u0493\u0492" + + "\u0001\u0000\u0000\u0000\u0493\u0494\u0001\u0000\u0000\u0000\u0494\u0495" + + "\u0001\u0000\u0000\u0000\u0495\u0497\u0005\u0084\u0000\u0000\u0496\u0498" + + "\u0003\u00acV\u0000\u0497\u0496\u0001\u0000\u0000\u0000\u0497\u0498\u0001" + + "\u0000\u0000\u0000\u0498\u0499\u0001\u0000\u0000\u0000\u0499\u049a\u0005" + + "\u0080\u0000\u0000\u049a\u00a9\u0001\u0000\u0000\u0000\u049b\u049d\u0005" + + "!\u0000\u0000\u049c\u049e\u0007\r\u0000\u0000\u049d\u049c\u0001\u0000" + + "\u0000\u0000\u049d\u049e\u0001\u0000\u0000\u0000\u049e\u00ab\u0001\u0000" + + "\u0000\u0000\u049f\u04a0\u0005~\u0000\u0000\u04a0\u04a1\u0003\u0096K\u0000" + + "\u04a1\u00ad\u0001\u0000\u0000\u0000\u04a2\u04a7\u0003\u00b0X\u0000\u04a3" + + "\u04a4\u0005z\u0000\u0000\u04a4\u04a6\u0003\u00b0X\u0000\u04a5\u04a3\u0001" + + "\u0000\u0000\u0000\u04a6\u04a9\u0001\u0000\u0000\u0000\u04a7\u04a5\u0001" + + "\u0000\u0000\u0000\u04a7\u04a8\u0001\u0000\u0000\u0000\u04a8\u00af\u0001" + + "\u0000\u0000\u0000\u04a9\u04a7\u0001\u0000\u0000\u0000\u04aa\u04ad\u0003" + + "\u00b2Y\u0000\u04ab\u04ac\u0005e\u0000\u0000\u04ac\u04ae\u0003\\.\u0000" + + "\u04ad\u04ab\u0001\u0000\u0000\u0000\u04ad\u04ae\u0001\u0000\u0000\u0000" + + "\u04ae\u00b1\u0001\u0000\u0000\u0000\u04af\u04b0\u0005\u0084\u0000\u0000" + + "\u04b0\u00b3\u0001\u0000\u0000\u0000\u04b1\u04b4\u0003\u00b6[\u0000\u04b2" + + "\u04b4\u0003\u00ba]\u0000\u04b3\u04b1\u0001\u0000\u0000\u0000\u04b3\u04b2" + + "\u0001\u0000\u0000\u0000\u04b4\u00b5\u0001\u0000\u0000\u0000\u04b5\u04b6" + + "\u0005\u0084\u0000\u0000\u04b6\u00b7\u0001\u0000\u0000\u0000\u04b7\u04b9" + + "\u0005,\u0000\u0000\u04b8\u04b7\u0001\u0000\u0000\u0000\u04b8\u04b9\u0001" + + "\u0000\u0000\u0000\u04b9\u04ba\u0001\u0000\u0000\u0000\u04ba\u04bd\u0005" + + "0\u0000\u0000\u04bb\u04be\u0005\u0084\u0000\u0000\u04bc\u04be\u0003\u00b6" + + "[\u0000\u04bd\u04bb\u0001\u0000\u0000\u0000\u04bd\u04bc\u0001\u0000\u0000" + + "\u0000\u04bd\u04be\u0001\u0000\u0000\u0000\u04be\u04bf\u0001\u0000\u0000" + + "\u0000\u04bf\u04c1\u0005Y\u0000\u0000\u04c0\u04c2\u0003x<\u0000\u04c1" + + "\u04c0\u0001\u0000\u0000\u0000\u04c1\u04c2\u0001\u0000\u0000\u0000\u04c2" + + "\u04c3\u0001\u0000\u0000\u0000\u04c3\u04c4\u0005Z\u0000\u0000\u04c4\u00b9" + + "\u0001\u0000\u0000\u0000\u04c5\u04c6\u0005\u0084\u0000\u0000\u04c6\u00bb" + + "\u0001\u0000\u0000\u0000\u04c7\u04c8\u00050\u0000\u0000\u04c8\u04c9\u0005" + + "\u0084\u0000\u0000\u04c9\u04ca\u0005e\u0000\u0000\u04ca\u04cb\u0003\u00be" + + "_\u0000\u04cb\u04cc\u0005\u0080\u0000\u0000\u04cc\u00bd\u0001\u0000\u0000" + + "\u0000\u04cd\u04cf\u0003\n\u0005\u0000\u04ce\u04cd\u0001\u0000\u0000\u0000" + + "\u04ce\u04cf\u0001\u0000\u0000\u0000\u04cf\u04d0\u0001\u0000\u0000\u0000" + + "\u04d0\u04d1\u0003\u00b4Z\u0000\u04d1\u00bf\u0001\u0000\u0000\u0000\u04d2" + + "\u04d8\u0005O\u0000\u0000\u04d3\u04d5\u0005L\u0000\u0000\u04d4\u04d3\u0001" + + "\u0000\u0000\u0000\u04d4\u04d5\u0001\u0000\u0000\u0000\u04d5\u04d6\u0001" + + "\u0000\u0000\u0000\u04d6\u04d9\u0003\n\u0005\u0000\u04d7\u04d9\u0005\u007f" + + "\u0000\u0000\u04d8\u04d4\u0001\u0000\u0000\u0000\u04d8\u04d7\u0001\u0000" + + "\u0000\u0000\u04d9\u04da\u0001\u0000\u0000\u0000\u04da\u04db\u0003\u0006" + + "\u0003\u0000\u04db\u04dc\u0005\u0080\u0000\u0000\u04dc\u00c1\u0001\u0000" + + "\u0000\u0000\u04dd\u04df\u0003\u00c8d\u0000\u04de\u04dd\u0001\u0000\u0000" + + "\u0000\u04de\u04df\u0001\u0000\u0000\u0000\u04df\u04e0\u0001\u0000\u0000" + + "\u0000\u04e0\u04e1\u0005O\u0000\u0000\u04e1\u04e3\u00050\u0000\u0000\u04e2" + + "\u04e4\u0003\n\u0005\u0000\u04e3\u04e2\u0001\u0000\u0000\u0000\u04e3\u04e4" + + "\u0001\u0000\u0000\u0000\u04e4\u04e5\u0001\u0000\u0000\u0000\u04e5\u04e6" + + "\u0003\u00b4Z\u0000\u04e6\u04e7\u0005\u0080\u0000\u0000\u04e7\u00c3\u0001" + + "\u0000\u0000\u0000\u04e8\u04e9\u0005\f\u0000\u0000\u04e9\u04ea\u0005U" + + "\u0000\u0000\u04ea\u04eb\u0005\u0004\u0000\u0000\u04eb\u04ec\u0005V\u0000" + + "\u0000\u04ec\u04ed\u0005\u0080\u0000\u0000\u04ed\u00c5\u0001\u0000\u0000" + + "\u0000\u04ee\u04ef\u0005$\u0000\u0000\u04ef\u04f6\u0005\u0004\u0000\u0000" + + "\u04f0\u04f2\u0005Y\u0000\u0000\u04f1\u04f3\u0003x<\u0000\u04f2\u04f1" + + "\u0001\u0000\u0000\u0000\u04f2\u04f3\u0001\u0000\u0000\u0000\u04f3\u04f4" + + "\u0001\u0000\u0000\u0000\u04f4\u04f7\u0005Z\u0000\u0000\u04f5\u04f7\u0003" + + "z=\u0000\u04f6\u04f0\u0001\u0000\u0000\u0000\u04f6\u04f5\u0001\u0000\u0000" + + "\u0000\u04f7\u00c7\u0001\u0000\u0000\u0000\u04f8\u04fa\u0003\u00cae\u0000" + + "\u04f9\u04f8\u0001\u0000\u0000\u0000\u04fa\u04fb\u0001\u0000\u0000\u0000" + + "\u04fb\u04f9\u0001\u0000\u0000\u0000\u04fb\u04fc\u0001\u0000\u0000\u0000" + + "\u04fc\u00c9\u0001\u0000\u0000\u0000\u04fd\u04fe\u0005W\u0000\u0000\u04fe" + + "\u0500\u0005W\u0000\u0000\u04ff\u0501\u0003\u00ceg\u0000\u0500\u04ff\u0001" + + "\u0000\u0000\u0000\u0500\u0501\u0001\u0000\u0000\u0000\u0501\u0502\u0001" + + "\u0000\u0000\u0000\u0502\u0503\u0005X\u0000\u0000\u0503\u0506\u0005X\u0000" + + "\u0000\u0504\u0506\u0003\u00ccf\u0000\u0505\u04fd\u0001\u0000\u0000\u0000" + + "\u0505\u0504\u0001\u0000\u0000\u0000\u0506\u00cb\u0001\u0000\u0000\u0000" + + "\u0507\u0508\u0005\n\u0000\u0000\u0508\u050b\u0005U\u0000\u0000\u0509" + + "\u050c\u0003\u00f2y\u0000\u050a\u050c\u0003\\.\u0000\u050b\u0509\u0001" + + "\u0000\u0000\u0000\u050b\u050a\u0001\u0000\u0000\u0000\u050c\u050e\u0001" + + "\u0000\u0000\u0000\u050d\u050f\u0005\u0083\u0000\u0000\u050e\u050d\u0001" + + "\u0000\u0000\u0000\u050e\u050f\u0001\u0000\u0000\u0000\u050f\u0510\u0001" + + "\u0000\u0000\u0000\u0510\u0511\u0005V\u0000\u0000\u0511\u00cd\u0001\u0000" + + "\u0000\u0000\u0512\u0517\u0003\u00d0h\u0000\u0513\u0514\u0005z\u0000\u0000" + + "\u0514\u0516\u0003\u00d0h\u0000\u0515\u0513\u0001\u0000\u0000\u0000\u0516" + + "\u0519\u0001\u0000\u0000\u0000\u0517\u0515\u0001\u0000\u0000\u0000\u0517" + + "\u0518\u0001\u0000\u0000\u0000\u0518\u051b\u0001\u0000\u0000\u0000\u0519" + + "\u0517\u0001\u0000\u0000\u0000\u051a\u051c\u0005\u0083\u0000\u0000\u051b" + + "\u051a\u0001\u0000\u0000\u0000\u051b\u051c\u0001\u0000\u0000\u0000\u051c" + + "\u00cf\u0001\u0000\u0000\u0000\u051d\u051e\u0003\u00d2i\u0000\u051e\u051f" + + "\u0005\u007f\u0000\u0000\u051f\u0521\u0001\u0000\u0000\u0000\u0520\u051d" + + "\u0001\u0000\u0000\u0000\u0520\u0521\u0001\u0000\u0000\u0000\u0521\u0522" + + "\u0001\u0000\u0000\u0000\u0522\u0524\u0005\u0084\u0000\u0000\u0523\u0525" + + "\u0003\u00d4j\u0000\u0524\u0523\u0001\u0000\u0000\u0000\u0524\u0525\u0001" + + "\u0000\u0000\u0000\u0525\u00d1\u0001\u0000\u0000\u0000\u0526\u0527\u0005" + + "\u0084\u0000\u0000\u0527\u00d3\u0001\u0000\u0000\u0000\u0528\u052a\u0005" + + "U\u0000\u0000\u0529\u052b\u0003\u00d6k\u0000\u052a\u0529\u0001\u0000\u0000" + + "\u0000\u052a\u052b\u0001\u0000\u0000\u0000\u052b\u052c\u0001\u0000\u0000" + + "\u0000\u052c\u052d\u0005V\u0000\u0000\u052d\u00d5\u0001\u0000\u0000\u0000" + + "\u052e\u0530\u0003\u00d8l\u0000\u052f\u052e\u0001\u0000\u0000\u0000\u0530" + + "\u0531\u0001\u0000\u0000\u0000\u0531\u052f\u0001\u0000\u0000\u0000\u0531" + + "\u0532\u0001\u0000\u0000\u0000\u0532\u00d7\u0001\u0000\u0000\u0000\u0533" + + "\u0534\u0005U\u0000\u0000\u0534\u0535\u0003\u00d6k\u0000\u0535\u0536\u0005" + + "V\u0000\u0000\u0536\u0545\u0001\u0000\u0000\u0000\u0537\u0538\u0005W\u0000" + + "\u0000\u0538\u0539\u0003\u00d6k\u0000\u0539\u053a\u0005X\u0000\u0000\u053a" + + "\u0545\u0001\u0000\u0000\u0000\u053b\u053c\u0005Y\u0000\u0000\u053c\u053d" + + "\u0003\u00d6k\u0000\u053d\u053e\u0005Z\u0000\u0000\u053e\u0545\u0001\u0000" + + "\u0000\u0000\u053f\u0541\b\u000e\u0000\u0000\u0540\u053f\u0001\u0000\u0000" + + "\u0000\u0541\u0542\u0001\u0000\u0000\u0000\u0542\u0540\u0001\u0000\u0000" + + "\u0000\u0542\u0543\u0001\u0000\u0000\u0000\u0543\u0545\u0001\u0000\u0000" + + "\u0000\u0544\u0533\u0001\u0000\u0000\u0000\u0544\u0537\u0001\u0000\u0000" + + "\u0000\u0544\u053b\u0001\u0000\u0000\u0000\u0544\u0540\u0001\u0000\u0000" + + "\u0000\u0545\u00d9\u0001\u0000\u0000\u0000\u0546\u054b\u0003\u00dcn\u0000" + + "\u0547\u0548\u0005z\u0000\u0000\u0548\u054a\u0003\u00dcn\u0000\u0549\u0547" + + "\u0001\u0000\u0000\u0000\u054a\u054d\u0001\u0000\u0000\u0000\u054b\u0549" + + "\u0001\u0000\u0000\u0000\u054b\u054c\u0001\u0000\u0000\u0000\u054c\u00db" + + "\u0001\u0000\u0000\u0000\u054d\u054b\u0001\u0000\u0000\u0000\u054e\u0550" + + "\u0003\u00deo\u0000\u054f\u0551\u0003\u0108\u0084\u0000\u0550\u054f\u0001" + + "\u0000\u0000\u0000\u0550\u0551\u0001\u0000\u0000\u0000\u0551\u00dd\u0001" + + "\u0000\u0000\u0000\u0552\u0558\u0003\u00e0p\u0000\u0553\u0554\u0003\u00e2" + + "q\u0000\u0554\u0555\u0003\u00e4r\u0000\u0555\u0556\u0003\u00e6s\u0000" + + "\u0556\u0558\u0001\u0000\u0000\u0000\u0557\u0552\u0001\u0000\u0000\u0000" + + "\u0557\u0553\u0001\u0000\u0000\u0000\u0558\u00df\u0001\u0000\u0000\u0000" + + "\u0559\u055b\u0003\u00e8t\u0000\u055a\u055c\u0005\u0016\u0000\u0000\u055b" + + "\u055a\u0001\u0000\u0000\u0000\u055b\u055c\u0001\u0000\u0000\u0000\u055c" + + "\u055e\u0001\u0000\u0000\u0000\u055d\u0559\u0001\u0000\u0000\u0000\u055e" + + "\u0561\u0001\u0000\u0000\u0000\u055f\u055d\u0001\u0000\u0000\u0000\u055f" + + "\u0560\u0001\u0000\u0000\u0000\u0560\u0562\u0001\u0000\u0000\u0000\u0561" + + "\u055f\u0001\u0000\u0000\u0000\u0562\u0563\u0003\u00e2q\u0000\u0563\u00e1" + + "\u0001\u0000\u0000\u0000\u0564\u0565\u0006q\uffff\uffff\u0000\u0565\u0567" + + "\u0003\u00f0x\u0000\u0566\u0568\u0003\u00c8d\u0000\u0567\u0566\u0001\u0000" + + "\u0000\u0000\u0567\u0568\u0001\u0000\u0000\u0000\u0568\u056e\u0001\u0000" + + "\u0000\u0000\u0569\u056a\u0005U\u0000\u0000\u056a\u056b\u0003\u00e0p\u0000" + + "\u056b\u056c\u0005V\u0000\u0000\u056c\u056e\u0001\u0000\u0000\u0000\u056d" + + "\u0564\u0001\u0000\u0000\u0000\u056d\u0569\u0001\u0000\u0000\u0000\u056e" + + "\u057d\u0001\u0000\u0000\u0000\u056f\u0579\n\u0002\u0000\u0000\u0570\u057a" + + "\u0003\u00e4r\u0000\u0571\u0573\u0005W\u0000\u0000\u0572\u0574\u0003\\" + + ".\u0000\u0573\u0572\u0001\u0000\u0000\u0000\u0573\u0574\u0001\u0000\u0000" + + "\u0000\u0574\u0575\u0001\u0000\u0000\u0000\u0575\u0577\u0005X\u0000\u0000" + + "\u0576\u0578\u0003\u00c8d\u0000\u0577\u0576\u0001\u0000\u0000\u0000\u0577" + + "\u0578\u0001\u0000\u0000\u0000\u0578\u057a\u0001\u0000\u0000\u0000\u0579" + + "\u0570\u0001\u0000\u0000\u0000\u0579\u0571\u0001\u0000\u0000\u0000\u057a" + + "\u057c\u0001\u0000\u0000\u0000\u057b\u056f\u0001\u0000\u0000\u0000\u057c" + + "\u057f\u0001\u0000\u0000\u0000\u057d\u057b\u0001\u0000\u0000\u0000\u057d" + + "\u057e\u0001\u0000\u0000\u0000\u057e\u00e3\u0001\u0000\u0000\u0000\u057f" + + "\u057d\u0001\u0000\u0000\u0000\u0580\u0582\u0005U\u0000\u0000\u0581\u0583" + + "\u0003\u00fe\u007f\u0000\u0582\u0581\u0001\u0000\u0000\u0000\u0582\u0583" + + "\u0001\u0000\u0000\u0000\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0586" + + "\u0005V\u0000\u0000\u0585\u0587\u0003\u00eau\u0000\u0586\u0585\u0001\u0000" + + "\u0000\u0000\u0586\u0587\u0001\u0000\u0000\u0000\u0587\u0589\u0001\u0000" + + "\u0000\u0000\u0588\u058a\u0003\u00eew\u0000\u0589\u0588\u0001\u0000\u0000" + + "\u0000\u0589\u058a\u0001\u0000\u0000\u0000\u058a\u058c\u0001\u0000\u0000" + + "\u0000\u058b\u058d\u0003\u016e\u00b7\u0000\u058c\u058b\u0001\u0000\u0000" + + "\u0000\u058c\u058d\u0001\u0000\u0000\u0000\u058d\u058f\u0001\u0000\u0000" + + "\u0000\u058e\u0590\u0003\u00c8d\u0000\u058f\u058e\u0001\u0000\u0000\u0000" + + "\u058f\u0590\u0001\u0000\u0000\u0000\u0590\u00e5\u0001\u0000\u0000\u0000" + + "\u0591\u0592\u0005|\u0000\u0000\u0592\u0594\u0003\u0098L\u0000\u0593\u0595" + + "\u0003\u00f4z\u0000\u0594\u0593\u0001\u0000\u0000\u0000\u0594\u0595\u0001" + + "\u0000\u0000\u0000\u0595\u00e7\u0001\u0000\u0000\u0000\u0596\u0598\u0007" + + "\u000f\u0000\u0000\u0597\u0599\u0003\u00c8d\u0000\u0598\u0597\u0001\u0000" + + "\u0000\u0000\u0598\u0599\u0001\u0000\u0000\u0000\u0599\u05a5\u0001\u0000" + + "\u0000\u0000\u059a\u059c\u0003\n\u0005\u0000\u059b\u059a\u0001\u0000\u0000" + + "\u0000\u059b\u059c\u0001\u0000\u0000\u0000\u059c\u059d\u0001\u0000\u0000" + + "\u0000\u059d\u059f\u0005]\u0000\u0000\u059e\u05a0\u0003\u00c8d\u0000\u059f" + + "\u059e\u0001\u0000\u0000\u0000\u059f\u05a0\u0001\u0000\u0000\u0000\u05a0" + + "\u05a2\u0001\u0000\u0000\u0000\u05a1\u05a3\u0003\u00eau\u0000\u05a2\u05a1" + + "\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000\u0000\u0000\u05a3\u05a5" + + "\u0001\u0000\u0000\u0000\u05a4\u0596\u0001\u0000\u0000\u0000\u05a4\u059b" + + "\u0001\u0000\u0000\u0000\u05a5\u00e9\u0001\u0000\u0000\u0000\u05a6\u05a8" + + "\u0003\u00ecv\u0000\u05a7\u05a6\u0001\u0000\u0000\u0000\u05a8\u05a9\u0001" + + "\u0000\u0000\u0000\u05a9\u05a7\u0001\u0000\u0000\u0000\u05a9\u05aa\u0001" + + "\u0000\u0000\u0000\u05aa\u00eb\u0001\u0000\u0000\u0000\u05ab\u05ac\u0007" + + "\u0010\u0000\u0000\u05ac\u00ed\u0001\u0000\u0000\u0000\u05ad\u05ae\u0007" + + "\u000f\u0000\u0000\u05ae\u00ef\u0001\u0000\u0000\u0000\u05af\u05b1\u0005" + + "\u0083\u0000\u0000\u05b0\u05af\u0001\u0000\u0000\u0000\u05b0\u05b1\u0001" + + "\u0000\u0000\u0000\u05b1\u05b2\u0001\u0000\u0000\u0000\u05b2\u05b3\u0003" + + "\u0004\u0002\u0000\u05b3\u00f1\u0001\u0000\u0000\u0000\u05b4\u05b6\u0003" + + "\u0096K\u0000\u05b5\u05b7\u0003\u00f4z\u0000\u05b6\u05b5\u0001\u0000\u0000" + + "\u0000\u05b6\u05b7\u0001\u0000\u0000\u0000\u05b7\u00f3\u0001\u0000\u0000" + + "\u0000\u05b8\u05c1\u0003\u00f6{\u0000\u05b9\u05bb\u0003\u00f8|\u0000\u05ba" + + "\u05b9\u0001\u0000\u0000\u0000\u05ba\u05bb\u0001\u0000\u0000\u0000\u05bb" + + "\u05bc\u0001\u0000\u0000\u0000\u05bc\u05bd\u0003\u00e4r\u0000\u05bd\u05be" + + "\u0003\u00e6s\u0000\u05be\u05c1\u0001\u0000\u0000\u0000\u05bf\u05c1\u0003" + + "\u00fa}\u0000\u05c0\u05b8\u0001\u0000\u0000\u0000\u05c0\u05ba\u0001\u0000" + + "\u0000\u0000\u05c0\u05bf\u0001\u0000\u0000\u0000\u05c1\u00f5\u0001\u0000" + + "\u0000\u0000\u05c2\u05cc\u0003\u00f8|\u0000\u05c3\u05c5\u0003\u00e8t\u0000" + + "\u05c4\u05c3\u0001\u0000\u0000\u0000\u05c5\u05c6\u0001\u0000\u0000\u0000" + + "\u05c6\u05c4\u0001\u0000\u0000\u0000\u05c6\u05c7\u0001\u0000\u0000\u0000" + + "\u05c7\u05c9\u0001\u0000\u0000\u0000\u05c8\u05ca\u0003\u00f8|\u0000\u05c9" + + "\u05c8\u0001\u0000\u0000\u0000\u05c9\u05ca\u0001\u0000\u0000\u0000\u05ca" + + "\u05cc\u0001\u0000\u0000\u0000\u05cb\u05c2\u0001\u0000\u0000\u0000\u05cb" + + "\u05c4\u0001\u0000\u0000\u0000\u05cc\u00f7\u0001\u0000\u0000\u0000\u05cd" + + "\u05ce\u0006|\uffff\uffff\u0000\u05ce\u05dc\u0003\u00e4r\u0000\u05cf\u05d1" + + "\u0005W\u0000\u0000\u05d0\u05d2\u0003\\.\u0000\u05d1\u05d0\u0001\u0000" + + "\u0000\u0000\u05d1\u05d2\u0001\u0000\u0000\u0000\u05d2\u05d3\u0001\u0000" + + "\u0000\u0000\u05d3\u05d5\u0005X\u0000\u0000\u05d4\u05d6\u0003\u00c8d\u0000" + + "\u05d5\u05d4\u0001\u0000\u0000\u0000\u05d5\u05d6\u0001\u0000\u0000\u0000" + + "\u05d6\u05dc\u0001\u0000\u0000\u0000\u05d7\u05d8\u0005U\u0000\u0000\u05d8" + + "\u05d9\u0003\u00f6{\u0000\u05d9\u05da\u0005V\u0000\u0000\u05da\u05dc\u0001" + + "\u0000\u0000\u0000\u05db\u05cd\u0001\u0000\u0000\u0000\u05db\u05cf\u0001" + + "\u0000\u0000\u0000\u05db\u05d7\u0001\u0000\u0000\u0000\u05dc\u05ec\u0001" + + "\u0000\u0000\u0000\u05dd\u05e8\n\u0004\u0000\u0000\u05de\u05e9\u0003\u00e4" + + "r\u0000\u05df\u05e0\u0003\u00f8|\u0000\u05e0\u05e2\u0005W\u0000\u0000" + + "\u05e1\u05e3\u0003\\.\u0000\u05e2\u05e1\u0001\u0000\u0000\u0000\u05e2" + + "\u05e3\u0001\u0000\u0000\u0000\u05e3\u05e4\u0001\u0000\u0000\u0000\u05e4" + + "\u05e6\u0005X\u0000\u0000\u05e5\u05e7\u0003\u00c8d\u0000\u05e6\u05e5\u0001" + + "\u0000\u0000\u0000\u05e6\u05e7\u0001\u0000\u0000\u0000\u05e7\u05e9\u0001" + + "\u0000\u0000\u0000\u05e8\u05de\u0001\u0000\u0000\u0000\u05e8\u05df\u0001" + + "\u0000\u0000\u0000\u05e9\u05eb\u0001\u0000\u0000\u0000\u05ea\u05dd\u0001" + + "\u0000\u0000\u0000\u05eb\u05ee\u0001\u0000\u0000\u0000\u05ec\u05ea\u0001" + + "\u0000\u0000\u0000\u05ec\u05ed\u0001\u0000\u0000\u0000\u05ed\u00f9\u0001" + + "\u0000\u0000\u0000\u05ee\u05ec\u0001\u0000\u0000\u0000\u05ef\u05f1\u0003" + + "\u00e8t\u0000\u05f0\u05ef\u0001\u0000\u0000\u0000\u05f1\u05f4\u0001\u0000" + + "\u0000\u0000\u05f2\u05f0\u0001\u0000\u0000\u0000\u05f2\u05f3\u0001\u0000" + + "\u0000\u0000\u05f3\u05f5\u0001\u0000\u0000\u0000\u05f4\u05f2\u0001\u0000" + + "\u0000\u0000\u05f5\u05f6\u0003\u00fc~\u0000\u05f6\u00fb\u0001\u0000\u0000" + + "\u0000\u05f7\u05f8\u0006~\uffff\uffff\u0000\u05f8\u05f9\u0005\u0083\u0000" + + "\u0000\u05f9\u0608\u0001\u0000\u0000\u0000\u05fa\u0604\n\u0002\u0000\u0000" + + "\u05fb\u0605\u0003\u00e4r\u0000\u05fc\u05fe\u0005W\u0000\u0000\u05fd\u05ff" + + "\u0003\\.\u0000\u05fe\u05fd\u0001\u0000\u0000\u0000\u05fe\u05ff\u0001" + + "\u0000\u0000\u0000\u05ff\u0600\u0001\u0000\u0000\u0000\u0600\u0602\u0005" + + "X\u0000\u0000\u0601\u0603\u0003\u00c8d\u0000\u0602\u0601\u0001\u0000\u0000" + + "\u0000\u0602\u0603\u0001\u0000\u0000\u0000\u0603\u0605\u0001\u0000\u0000" + + "\u0000\u0604\u05fb\u0001\u0000\u0000\u0000\u0604\u05fc\u0001\u0000\u0000" + + "\u0000\u0605\u0607\u0001\u0000\u0000\u0000\u0606\u05fa\u0001\u0000\u0000" + + "\u0000\u0607\u060a\u0001\u0000\u0000\u0000\u0608\u0606\u0001\u0000\u0000" + + "\u0000\u0608\u0609\u0001\u0000\u0000\u0000\u0609\u00fd\u0001\u0000\u0000" + + "\u0000\u060a\u0608\u0001\u0000\u0000\u0000\u060b\u0610\u0003\u0100\u0080" + + "\u0000\u060c\u060e\u0005z\u0000\u0000\u060d\u060c\u0001\u0000\u0000\u0000" + + "\u060d\u060e\u0001\u0000\u0000\u0000\u060e\u060f\u0001\u0000\u0000\u0000" + + "\u060f\u0611\u0005\u0083\u0000\u0000\u0610\u060d\u0001\u0000\u0000\u0000" + + "\u0610\u0611\u0001\u0000\u0000\u0000\u0611\u00ff\u0001\u0000\u0000\u0000" + + "\u0612\u0617\u0003\u0102\u0081\u0000\u0613\u0614\u0005z\u0000\u0000\u0614" + + "\u0616\u0003\u0102\u0081\u0000\u0615\u0613\u0001\u0000\u0000\u0000\u0616" + + "\u0619\u0001\u0000\u0000\u0000\u0617\u0615\u0001\u0000\u0000\u0000\u0617" + + "\u0618\u0001\u0000\u0000\u0000\u0618\u0101\u0001\u0000\u0000\u0000\u0619" + + "\u0617\u0001\u0000\u0000\u0000\u061a\u061c\u0003\u00c8d\u0000\u061b\u061a" + + "\u0001\u0000\u0000\u0000\u061b\u061c\u0001\u0000\u0000\u0000\u061c\u061d" + + "\u0001\u0000\u0000\u0000\u061d\u0622\u0003\u008aE\u0000\u061e\u0623\u0003" + + "\u00deo\u0000\u061f\u0621\u0003\u00f4z\u0000\u0620\u061f\u0001\u0000\u0000" + + "\u0000\u0620\u0621\u0001\u0000\u0000\u0000\u0621\u0623\u0001\u0000\u0000" + + "\u0000\u0622\u061e\u0001\u0000\u0000\u0000\u0622\u0620\u0001\u0000\u0000" + + "\u0000\u0623\u0626\u0001\u0000\u0000\u0000\u0624\u0625\u0005e\u0000\u0000" + + "\u0625\u0627\u0003\u010c\u0086\u0000\u0626\u0624\u0001\u0000\u0000\u0000" + + "\u0626\u0627\u0001\u0000\u0000\u0000\u0627\u0103\u0001\u0000\u0000\u0000" + + "\u0628\u062a\u0003\u00c8d\u0000\u0629\u0628\u0001\u0000\u0000\u0000\u0629" + + "\u062a\u0001\u0000\u0000\u0000\u062a\u062c\u0001\u0000\u0000\u0000\u062b" + + "\u062d\u0003\u008aE\u0000\u062c\u062b\u0001\u0000\u0000\u0000\u062c\u062d" + + "\u0001\u0000\u0000\u0000\u062d\u062e\u0001\u0000\u0000\u0000\u062e\u0630" + + "\u0003\u00deo\u0000\u062f\u0631\u0003\u0126\u0093\u0000\u0630\u062f\u0001" + + "\u0000\u0000\u0000\u0630\u0631\u0001\u0000\u0000\u0000\u0631\u0632\u0001" + + "\u0000\u0000\u0000\u0632\u0633\u0003\u0106\u0083\u0000\u0633\u0105\u0001" + + "\u0000\u0000\u0000\u0634\u0636\u0003\u013e\u009f\u0000\u0635\u0634\u0001" + + "\u0000\u0000\u0000\u0635\u0636\u0001\u0000\u0000\u0000\u0636\u0637\u0001" + + "\u0000\u0000\u0000\u0637\u063d\u0003d2\u0000\u0638\u063d\u0003\u0164\u00b2" + + "\u0000\u0639\u063a\u0005e\u0000\u0000\u063a\u063b\u0007\u0011\u0000\u0000" + + "\u063b\u063d\u0005\u0080\u0000\u0000\u063c\u0635\u0001\u0000\u0000\u0000" + + "\u063c\u0638\u0001\u0000\u0000\u0000\u063c\u0639\u0001\u0000\u0000\u0000" + + "\u063d\u0107\u0001\u0000\u0000\u0000\u063e\u0644\u0003\u010a\u0085\u0000" + + "\u063f\u0640\u0005U\u0000\u0000\u0640\u0641\u0003\"\u0011\u0000\u0641" + + "\u0642\u0005V\u0000\u0000\u0642\u0644\u0001\u0000\u0000\u0000\u0643\u063e" + + "\u0001\u0000\u0000\u0000\u0643\u063f\u0001\u0000\u0000\u0000\u0644\u0109" + + "\u0001\u0000\u0000\u0000\u0645\u0646\u0005e\u0000\u0000\u0646\u0649\u0003" + + "\u010c\u0086\u0000\u0647\u0649\u0003\u0110\u0088\u0000\u0648\u0645\u0001" + + "\u0000\u0000\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u010b\u0001" + + "\u0000\u0000\u0000\u064a\u064d\u0003V+\u0000\u064b\u064d\u0003\u0110\u0088" + + "\u0000\u064c\u064a\u0001\u0000\u0000\u0000\u064c\u064b\u0001\u0000\u0000" + + "\u0000\u064d\u010d\u0001\u0000\u0000\u0000\u064e\u0650\u0003\u010c\u0086" + + "\u0000\u064f\u0651\u0005\u0083\u0000\u0000\u0650\u064f\u0001\u0000\u0000" + + "\u0000\u0650\u0651\u0001\u0000\u0000\u0000\u0651\u0659\u0001\u0000\u0000" + + "\u0000\u0652\u0653\u0005z\u0000\u0000\u0653\u0655\u0003\u010c\u0086\u0000" + + "\u0654\u0656\u0005\u0083\u0000\u0000\u0655\u0654\u0001\u0000\u0000\u0000" + + "\u0655\u0656\u0001\u0000\u0000\u0000\u0656\u0658\u0001\u0000\u0000\u0000" + + "\u0657\u0652\u0001\u0000\u0000\u0000\u0658\u065b\u0001\u0000\u0000\u0000" + + "\u0659\u0657\u0001\u0000\u0000\u0000\u0659\u065a\u0001\u0000\u0000\u0000" + + "\u065a\u010f\u0001\u0000\u0000\u0000\u065b\u0659\u0001\u0000\u0000\u0000" + + "\u065c\u0661\u0005Y\u0000\u0000\u065d\u065f\u0003\u010e\u0087\u0000\u065e" + + "\u0660\u0005z\u0000\u0000\u065f\u065e\u0001\u0000\u0000\u0000\u065f\u0660" + + "\u0001\u0000\u0000\u0000\u0660\u0662\u0001\u0000\u0000\u0000\u0661\u065d" + + "\u0001\u0000\u0000\u0000\u0661\u0662\u0001\u0000\u0000\u0000\u0662\u0663" + + "\u0001\u0000\u0000\u0000\u0663\u0664\u0005Z\u0000\u0000\u0664\u0111\u0001" + + "\u0000\u0000\u0000\u0665\u0668\u0005\u0084\u0000\u0000\u0666\u0668\u0003" + + "\u0152\u00a9\u0000\u0667\u0665\u0001\u0000\u0000\u0000\u0667\u0666\u0001" + + "\u0000\u0000\u0000\u0668\u0113\u0001\u0000\u0000\u0000\u0669\u066a\u0003" + + "\u0116\u008b\u0000\u066a\u066c\u0005Y\u0000\u0000\u066b\u066d\u0003\u011e" + + "\u008f\u0000\u066c\u066b\u0001\u0000\u0000\u0000\u066c\u066d\u0001\u0000" + + "\u0000\u0000\u066d\u066e\u0001\u0000\u0000\u0000\u066e\u066f\u0005Z\u0000" + + "\u0000\u066f\u0115\u0001\u0000\u0000\u0000\u0670\u0672\u0003\u011c\u008e" + + "\u0000\u0671\u0673\u0003\u00c8d\u0000\u0672\u0671\u0001\u0000\u0000\u0000" + + "\u0672\u0673\u0001\u0000\u0000\u0000\u0673\u0678\u0001\u0000\u0000\u0000" + + "\u0674\u0676\u0003\u0118\u008c\u0000\u0675\u0677\u0003\u011a\u008d\u0000" + + "\u0676\u0675\u0001\u0000\u0000\u0000\u0676\u0677\u0001\u0000\u0000\u0000" + + "\u0677\u0679\u0001\u0000\u0000\u0000\u0678\u0674\u0001\u0000\u0000\u0000" + + "\u0678\u0679\u0001\u0000\u0000\u0000\u0679\u067b\u0001\u0000\u0000\u0000" + + "\u067a\u067c\u0003\u012c\u0096\u0000\u067b\u067a\u0001\u0000\u0000\u0000" + + "\u067b\u067c\u0001\u0000\u0000\u0000\u067c\u0688\u0001\u0000\u0000\u0000" + + "\u067d\u067f\u0005M\u0000\u0000\u067e\u0680\u0003\u00c8d\u0000\u067f\u067e" + + "\u0001\u0000\u0000\u0000\u067f\u0680\u0001\u0000\u0000\u0000\u0680\u0685" + + "\u0001\u0000\u0000\u0000\u0681\u0683\u0003\u0118\u008c\u0000\u0682\u0684" + + "\u0003\u011a\u008d\u0000\u0683\u0682\u0001\u0000\u0000\u0000\u0683\u0684" + + "\u0001\u0000\u0000\u0000\u0684\u0686\u0001\u0000\u0000\u0000\u0685\u0681" + + "\u0001\u0000\u0000\u0000\u0685\u0686\u0001\u0000\u0000\u0000\u0686\u0688" + + "\u0001\u0000\u0000\u0000\u0687\u0670\u0001\u0000\u0000\u0000\u0687\u067d" + + "\u0001\u0000\u0000\u0000\u0688\u0117\u0001\u0000\u0000\u0000\u0689\u068b" + + "\u0003\n\u0005\u0000\u068a\u0689\u0001\u0000\u0000\u0000\u068a\u068b\u0001" + + "\u0000\u0000\u0000\u068b\u068c\u0001\u0000\u0000\u0000\u068c\u068d\u0003" + + "\u0112\u0089\u0000\u068d\u0119\u0001\u0000\u0000\u0000\u068e\u068f\u0005" + + "&\u0000\u0000\u068f\u011b\u0001\u0000\u0000\u0000\u0690\u0691\u0007\r" + + "\u0000\u0000\u0691\u011d\u0001\u0000\u0000\u0000\u0692\u0697\u0003\u0120" + + "\u0090\u0000\u0693\u0694\u0003\u0136\u009b\u0000\u0694\u0695\u0005~\u0000" + + "\u0000\u0695\u0697\u0001\u0000\u0000\u0000\u0696\u0692\u0001\u0000\u0000" + + "\u0000\u0696\u0693\u0001\u0000\u0000\u0000\u0697\u0698\u0001\u0000\u0000" + + "\u0000\u0698\u0696\u0001\u0000\u0000\u0000\u0698\u0699\u0001\u0000\u0000" + + "\u0000\u0699\u011f\u0001\u0000\u0000\u0000\u069a\u069c\u0003\u00c8d\u0000" + + "\u069b\u069a\u0001\u0000\u0000\u0000\u069b\u069c\u0001\u0000\u0000\u0000" + + "\u069c\u069e\u0001\u0000\u0000\u0000\u069d\u069f\u0003\u008aE\u0000\u069e" + + "\u069d\u0001\u0000\u0000\u0000\u069e\u069f\u0001\u0000\u0000\u0000\u069f" + + "\u06a1\u0001\u0000\u0000\u0000\u06a0\u06a2\u0003\u0122\u0091\u0000\u06a1" + + "\u06a0\u0001\u0000\u0000\u0000\u06a1\u06a2\u0001\u0000\u0000\u0000\u06a2" + + "\u06a3\u0001\u0000\u0000\u0000\u06a3\u06ab\u0005\u0080\u0000\u0000\u06a4" + + "\u06ab\u0003\u0104\u0082\u0000\u06a5\u06ab\u0003\u00c0`\u0000\u06a6\u06ab" + + "\u0003\u0082A\u0000\u06a7\u06ab\u0003\u014a\u00a5\u0000\u06a8\u06ab\u0003" + + "~?\u0000\u06a9\u06ab\u0003\u0084B\u0000\u06aa\u069b\u0001\u0000\u0000" + + "\u0000\u06aa\u06a4\u0001\u0000\u0000\u0000\u06aa\u06a5\u0001\u0000\u0000" + + "\u0000\u06aa\u06a6\u0001\u0000\u0000\u0000\u06aa\u06a7\u0001\u0000\u0000" + + "\u0000\u06aa\u06a8\u0001\u0000\u0000\u0000\u06aa\u06a9\u0001\u0000\u0000" + + "\u0000\u06ab\u0121\u0001\u0000\u0000\u0000\u06ac\u06b1\u0003\u0124\u0092" + + "\u0000\u06ad\u06ae\u0005z\u0000\u0000\u06ae\u06b0\u0003\u0124\u0092\u0000" + + "\u06af\u06ad\u0001\u0000\u0000\u0000\u06b0\u06b3\u0001\u0000\u0000\u0000" + + "\u06b1\u06af\u0001\u0000\u0000\u0000\u06b1\u06b2\u0001\u0000\u0000\u0000" + + "\u06b2\u0123\u0001\u0000\u0000\u0000\u06b3\u06b1\u0001\u0000\u0000\u0000" + + "\u06b4\u06be\u0003\u00deo\u0000\u06b5\u06b7\u0003\u0126\u0093\u0000\u06b6" + + "\u06b5\u0001\u0000\u0000\u0000\u06b6\u06b7\u0001\u0000\u0000\u0000\u06b7" + + "\u06b9\u0001\u0000\u0000\u0000\u06b8\u06ba\u0003\u012a\u0095\u0000\u06b9" + + "\u06b8\u0001\u0000\u0000\u0000\u06b9\u06ba\u0001\u0000\u0000\u0000\u06ba" + + "\u06bf\u0001\u0000\u0000\u0000\u06bb\u06bd\u0003\u010a\u0085\u0000\u06bc" + + "\u06bb\u0001\u0000\u0000\u0000\u06bc\u06bd\u0001\u0000\u0000\u0000\u06bd" + + "\u06bf\u0001\u0000\u0000\u0000\u06be\u06b6\u0001\u0000\u0000\u0000\u06be" + + "\u06bc\u0001\u0000\u0000\u0000\u06bf\u06c9\u0001\u0000\u0000\u0000\u06c0" + + "\u06c2\u0005\u0084\u0000\u0000\u06c1\u06c0\u0001\u0000\u0000\u0000\u06c1" + + "\u06c2\u0001\u0000\u0000\u0000\u06c2\u06c4\u0001\u0000\u0000\u0000\u06c3" + + "\u06c5\u0003\u00c8d\u0000\u06c4\u06c3\u0001\u0000\u0000\u0000\u06c4\u06c5" + + "\u0001\u0000\u0000\u0000\u06c5\u06c6\u0001\u0000\u0000\u0000\u06c6\u06c7" + + "\u0005~\u0000\u0000\u06c7\u06c9\u0003\\.\u0000\u06c8\u06b4\u0001\u0000" + + "\u0000\u0000\u06c8\u06c1\u0001\u0000\u0000\u0000\u06c9\u0125\u0001\u0000" + + "\u0000\u0000\u06ca\u06cc\u0003\u0128\u0094\u0000\u06cb\u06ca\u0001\u0000" + + "\u0000\u0000\u06cc\u06cd\u0001\u0000\u0000\u0000\u06cd\u06cb\u0001\u0000" + + "\u0000\u0000\u06cd\u06ce\u0001\u0000\u0000\u0000\u06ce\u0127\u0001\u0000" + + "\u0000\u0000\u06cf\u06d0\u0007\u0012\u0000\u0000\u06d0\u0129\u0001\u0000" + + "\u0000\u0000\u06d1\u06d2\u0005e\u0000\u0000\u06d2\u06d3\u0005\u0086\u0000" + + "\u0000\u06d3\u06d4\u0006\u0095\uffff\uffff\u0000\u06d4\u012b\u0001\u0000" + + "\u0000\u0000\u06d5\u06d6\u0005~\u0000\u0000\u06d6\u06d7\u0003\u012e\u0097" + + "\u0000\u06d7\u012d\u0001\u0000\u0000\u0000\u06d8\u06da\u0003\u0130\u0098" + + "\u0000\u06d9\u06db\u0005\u0083\u0000\u0000\u06da\u06d9\u0001\u0000\u0000" + + "\u0000\u06da\u06db\u0001\u0000\u0000\u0000\u06db\u06e3\u0001\u0000\u0000" + + "\u0000\u06dc\u06dd\u0005z\u0000\u0000\u06dd\u06df\u0003\u0130\u0098\u0000" + + "\u06de\u06e0\u0005\u0083\u0000\u0000\u06df\u06de\u0001\u0000\u0000\u0000" + + "\u06df\u06e0\u0001\u0000\u0000\u0000\u06e0\u06e2\u0001\u0000\u0000\u0000" + + "\u06e1\u06dc\u0001\u0000\u0000\u0000\u06e2\u06e5\u0001\u0000\u0000\u0000" + + "\u06e3\u06e1\u0001\u0000\u0000\u0000\u06e3\u06e4\u0001\u0000\u0000\u0000" + + "\u06e4\u012f\u0001\u0000\u0000\u0000\u06e5\u06e3\u0001\u0000\u0000\u0000" + + "\u06e6\u06e8\u0003\u00c8d\u0000\u06e7\u06e6\u0001\u0000\u0000\u0000\u06e7" + + "\u06e8\u0001\u0000\u0000\u0000\u06e8\u06f5\u0001\u0000\u0000\u0000\u06e9" + + "\u06f6\u0003\u0134\u009a\u0000\u06ea\u06ec\u0005P\u0000\u0000\u06eb\u06ed" + + "\u0003\u0136\u009b\u0000\u06ec\u06eb\u0001\u0000\u0000\u0000\u06ec\u06ed" + + "\u0001\u0000\u0000\u0000\u06ed\u06ee\u0001\u0000\u0000\u0000\u06ee\u06f6" + + "\u0003\u0134\u009a\u0000\u06ef\u06f1\u0003\u0136\u009b\u0000\u06f0\u06f2" + + "\u0005P\u0000\u0000\u06f1\u06f0\u0001\u0000\u0000\u0000\u06f1\u06f2\u0001" + + "\u0000\u0000\u0000\u06f2\u06f3\u0001\u0000\u0000\u0000\u06f3\u06f4\u0003" + + "\u0134\u009a\u0000\u06f4\u06f6\u0001\u0000\u0000\u0000\u06f5\u06e9\u0001" + + "\u0000\u0000\u0000\u06f5\u06ea\u0001\u0000\u0000\u0000\u06f5\u06ef\u0001" + + "\u0000\u0000\u0000\u06f6\u0131\u0001\u0000\u0000\u0000\u06f7\u06f9\u0003" + + "\n\u0005\u0000\u06f8\u06f7\u0001\u0000\u0000\u0000\u06f8\u06f9\u0001\u0000" + + "\u0000\u0000\u06f9\u06fa\u0001\u0000\u0000\u0000\u06fa\u06fd\u0003\u0112" + + "\u0089\u0000\u06fb\u06fd\u0003\u009eO\u0000\u06fc\u06f8\u0001\u0000\u0000" + + "\u0000\u06fc\u06fb\u0001\u0000\u0000\u0000\u06fd\u0133\u0001\u0000\u0000" + + "\u0000\u06fe\u06ff\u0003\u0132\u0099\u0000\u06ff\u0135\u0001\u0000\u0000" + + "\u0000\u0700\u0701\u0007\u0013\u0000\u0000\u0701\u0137\u0001\u0000\u0000" + + "\u0000\u0702\u0703\u00054\u0000\u0000\u0703\u0704\u0003\u013a\u009d\u0000" + + "\u0704\u0139\u0001\u0000\u0000\u0000\u0705\u0707\u0003\u0096K\u0000\u0706" + + "\u0708\u0003\u013c\u009e\u0000\u0707\u0706\u0001\u0000\u0000\u0000\u0707" + + "\u0708\u0001\u0000\u0000\u0000\u0708\u013b\u0001\u0000\u0000\u0000\u0709" + + "\u070b\u0003\u00e8t\u0000\u070a\u070c\u0003\u013c\u009e\u0000\u070b\u070a" + + "\u0001\u0000\u0000\u0000\u070b\u070c\u0001\u0000\u0000\u0000\u070c\u013d" + + "\u0001\u0000\u0000\u0000\u070d\u070e\u0005~\u0000\u0000\u070e\u070f\u0003" + + "\u0140\u00a0\u0000\u070f\u013f\u0001\u0000\u0000\u0000\u0710\u0712\u0003" + + "\u0142\u00a1\u0000\u0711\u0713\u0005\u0083\u0000\u0000\u0712\u0711\u0001" + + "\u0000\u0000\u0000\u0712\u0713\u0001\u0000\u0000\u0000\u0713\u071b\u0001" + + "\u0000\u0000\u0000\u0714\u0715\u0005z\u0000\u0000\u0715\u0717\u0003\u0142" + + "\u00a1\u0000\u0716\u0718\u0005\u0083\u0000\u0000\u0717\u0716\u0001\u0000" + + "\u0000\u0000\u0717\u0718\u0001\u0000\u0000\u0000\u0718\u071a\u0001\u0000" + + "\u0000\u0000\u0719\u0714\u0001\u0000\u0000\u0000\u071a\u071d\u0001\u0000" + + "\u0000\u0000\u071b\u0719\u0001\u0000\u0000\u0000\u071b\u071c\u0001\u0000" + + "\u0000\u0000\u071c\u0141\u0001\u0000\u0000\u0000\u071d\u071b\u0001\u0000" + + "\u0000\u0000\u071e\u0725\u0003\u0144\u00a2\u0000\u071f\u0721\u0005U\u0000" + + "\u0000\u0720\u0722\u0003\"\u0011\u0000\u0721\u0720\u0001\u0000\u0000\u0000" + + "\u0721\u0722\u0001\u0000\u0000\u0000\u0722\u0723\u0001\u0000\u0000\u0000" + + "\u0723\u0726\u0005V\u0000\u0000\u0724\u0726\u0003\u0110\u0088\u0000\u0725" + + "\u071f\u0001\u0000\u0000\u0000\u0725\u0724\u0001\u0000\u0000\u0000\u0726" + + "\u0143\u0001\u0000\u0000\u0000\u0727\u072a\u0003\u0132\u0099\u0000\u0728" + + "\u072a\u0005\u0084\u0000\u0000\u0729\u0727\u0001\u0000\u0000\u0000\u0729" + + "\u0728\u0001\u0000\u0000\u0000\u072a\u0145\u0001\u0000\u0000\u0000\u072b" + + "\u072c\u00054\u0000\u0000\u072c\u072d\u0003\u0176\u00bb\u0000\u072d\u0147" + + "\u0001\u0000\u0000\u0000\u072e\u0732\u00054\u0000\u0000\u072f\u0730\u0005" + + "\u0004\u0000\u0000\u0730\u0733\u0005\u0084\u0000\u0000\u0731\u0733\u0005" + + "\u008c\u0000\u0000\u0732\u072f\u0001\u0000\u0000\u0000\u0732\u0731\u0001" + + "\u0000\u0000\u0000\u0733\u0149\u0001\u0000\u0000\u0000\u0734\u0735\u0005" + + "D\u0000\u0000\u0735\u0736\u0005f\u0000\u0000\u0736\u0737\u0003\u014c\u00a6" + + "\u0000\u0737\u0738\u0005g\u0000\u0000\u0738\u0739\u0003z=\u0000\u0739" + + "\u014b\u0001\u0000\u0000\u0000\u073a\u073f\u0003\u014e\u00a7\u0000\u073b" + + "\u073c\u0005z\u0000\u0000\u073c\u073e\u0003\u014e\u00a7\u0000\u073d\u073b" + + "\u0001\u0000\u0000\u0000\u073e\u0741\u0001\u0000\u0000\u0000\u073f\u073d" + + "\u0001\u0000\u0000\u0000\u073f\u0740\u0001\u0000\u0000\u0000\u0740\u014d" + + "\u0001\u0000\u0000\u0000\u0741\u073f\u0001\u0000\u0000\u0000\u0742\u0745" + + "\u0003\u0150\u00a8\u0000\u0743\u0745\u0003\u0102\u0081\u0000\u0744\u0742" + + "\u0001\u0000\u0000\u0000\u0744\u0743\u0001\u0000\u0000\u0000\u0745\u014f" + + "\u0001\u0000\u0000\u0000\u0746\u0747\u0005D\u0000\u0000\u0747\u0748\u0005" + + "f\u0000\u0000\u0748\u0749\u0003\u014c\u00a6\u0000\u0749\u074a\u0005g\u0000" + + "\u0000\u074a\u074c\u0001\u0000\u0000\u0000\u074b\u0746\u0001\u0000\u0000" + + "\u0000\u074b\u074c\u0001\u0000\u0000\u0000\u074c\u074d\u0001\u0000\u0000" + + "\u0000\u074d\u0750\u0005\u0015\u0000\u0000\u074e\u0750\u0005L\u0000\u0000" + + "\u074f\u074b\u0001\u0000\u0000\u0000\u074f\u074e\u0001\u0000\u0000\u0000" + + "\u0750\u075c\u0001\u0000\u0000\u0000\u0751\u0753\u0005\u0083\u0000\u0000" + + "\u0752\u0751\u0001\u0000\u0000\u0000\u0752\u0753\u0001\u0000\u0000\u0000" + + "\u0753\u0755\u0001\u0000\u0000\u0000\u0754\u0756\u0005\u0084\u0000\u0000" + + "\u0755\u0754\u0001\u0000\u0000\u0000\u0755\u0756\u0001\u0000\u0000\u0000" + + "\u0756\u075d\u0001\u0000\u0000\u0000\u0757\u0759\u0005\u0084\u0000\u0000" + + "\u0758\u0757\u0001\u0000\u0000\u0000\u0758\u0759\u0001\u0000\u0000\u0000" + + "\u0759\u075a\u0001\u0000\u0000\u0000\u075a\u075b\u0005e\u0000\u0000\u075b" + + "\u075d\u0003\u00f2y\u0000\u075c\u0752\u0001\u0000\u0000\u0000\u075c\u0758" + + "\u0001\u0000\u0000\u0000\u075d\u0151\u0001\u0000\u0000\u0000\u075e\u075f" + + "\u0003\u0156\u00ab\u0000\u075f\u0761\u0005f\u0000\u0000\u0760\u0762\u0003" + + "\u0158\u00ac\u0000\u0761\u0760\u0001\u0000\u0000\u0000\u0761\u0762\u0001" + + "\u0000\u0000\u0000\u0762\u0763\u0001\u0000\u0000\u0000\u0763\u0764\u0005" + + "g\u0000\u0000\u0764\u0153\u0001\u0000\u0000\u0000\u0765\u0771\u0003\u0152" + + "\u00a9\u0000\u0766\u0769\u0003\u0146\u00a3\u0000\u0767\u0769\u0003\u0148" + + "\u00a4\u0000\u0768\u0766\u0001\u0000\u0000\u0000\u0768\u0767\u0001\u0000" + + "\u0000\u0000\u0769\u076a\u0001\u0000\u0000\u0000\u076a\u076c\u0005f\u0000" + + "\u0000\u076b\u076d\u0003\u0158\u00ac\u0000\u076c\u076b\u0001\u0000\u0000" + + "\u0000\u076c\u076d\u0001\u0000\u0000\u0000\u076d\u076e\u0001\u0000\u0000" + + "\u0000\u076e\u076f\u0005g\u0000\u0000\u076f\u0771\u0001\u0000\u0000\u0000" + + "\u0770\u0765\u0001\u0000\u0000\u0000\u0770\u0768\u0001\u0000\u0000\u0000" + + "\u0771\u0155\u0001\u0000\u0000\u0000\u0772\u0773\u0005\u0084\u0000\u0000" + + "\u0773\u0157\u0001\u0000\u0000\u0000\u0774\u0776\u0003\u015a\u00ad\u0000" + + "\u0775\u0777\u0005\u0083\u0000\u0000\u0776\u0775\u0001\u0000\u0000\u0000" + + "\u0776\u0777\u0001\u0000\u0000\u0000\u0777\u077f\u0001\u0000\u0000\u0000" + + "\u0778\u0779\u0005z\u0000\u0000\u0779\u077b\u0003\u015a\u00ad\u0000\u077a" + + "\u077c\u0005\u0083\u0000\u0000\u077b\u077a\u0001\u0000\u0000\u0000\u077b" + + "\u077c\u0001\u0000\u0000\u0000\u077c\u077e\u0001\u0000\u0000\u0000\u077d" + + "\u0778\u0001\u0000\u0000\u0000\u077e\u0781\u0001\u0000\u0000\u0000\u077f" + + "\u077d\u0001\u0000\u0000\u0000\u077f\u0780\u0001\u0000\u0000\u0000\u0780" + + "\u0159\u0001\u0000\u0000\u0000\u0781\u077f\u0001\u0000\u0000\u0000\u0782" + + "\u0786\u0003\u00f2y\u0000\u0783\u0786\u0003\\.\u0000\u0784\u0786\u0003" + + "\u0004\u0002\u0000\u0785\u0782\u0001\u0000\u0000\u0000\u0785\u0783\u0001" + + "\u0000\u0000\u0000\u0785\u0784\u0001\u0000\u0000\u0000\u0786\u015b\u0001" + + "\u0000\u0000\u0000\u0787\u0788\u0005L\u0000\u0000\u0788\u078e\u0003\n" + + "\u0005\u0000\u0789\u078f\u0005\u0084\u0000\u0000\u078a\u078c\u0005D\u0000" + + "\u0000\u078b\u078a\u0001\u0000\u0000\u0000\u078b\u078c\u0001\u0000\u0000" + + "\u0000\u078c\u078d\u0001\u0000\u0000\u0000\u078d\u078f\u0003\u0152\u00a9" + + "\u0000\u078e\u0789\u0001\u0000\u0000\u0000\u078e\u078b\u0001\u0000\u0000" + + "\u0000\u078f\u015d\u0001\u0000\u0000\u0000\u0790\u0792\u0005$\u0000\u0000" + + "\u0791\u0790\u0001\u0000\u0000\u0000\u0791\u0792\u0001\u0000\u0000\u0000" + + "\u0792\u0793\u0001\u0000\u0000\u0000\u0793\u0794\u0005D\u0000\u0000\u0794" + + "\u0795\u0003z=\u0000\u0795\u015f\u0001\u0000\u0000\u0000\u0796\u0797\u0005" + + "D\u0000\u0000\u0797\u0798\u0005f\u0000\u0000\u0798\u0799\u0005g\u0000" + + "\u0000\u0799\u079a\u0003z=\u0000\u079a\u0161\u0001\u0000\u0000\u0000\u079b" + + "\u079c\u0005I\u0000\u0000\u079c\u079d\u0003d2\u0000\u079d\u079e\u0003" + + "\u0166\u00b3\u0000\u079e\u0163\u0001\u0000\u0000\u0000\u079f\u07a1\u0005" + + "I\u0000\u0000\u07a0\u07a2\u0003\u013e\u009f\u0000\u07a1\u07a0\u0001\u0000" + + "\u0000\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000\u07a2\u07a3\u0001\u0000" + + "\u0000\u0000\u07a3\u07a4\u0003d2\u0000\u07a4\u07a5\u0003\u0166\u00b3\u0000" + + "\u07a5\u0165\u0001\u0000\u0000\u0000\u07a6\u07a8\u0003\u0168\u00b4\u0000" + + "\u07a7\u07a6\u0001\u0000\u0000\u0000\u07a8\u07a9\u0001\u0000\u0000\u0000" + + "\u07a9\u07a7\u0001\u0000\u0000\u0000\u07a9\u07aa\u0001\u0000\u0000\u0000" + + "\u07aa\u0167\u0001\u0000\u0000\u0000\u07ab\u07ac\u0005\u0011\u0000\u0000" + + "\u07ac\u07ad\u0005U\u0000\u0000\u07ad\u07ae\u0003\u016a\u00b5\u0000\u07ae" + + "\u07af\u0005V\u0000\u0000\u07af\u07b0\u0003d2\u0000\u07b0\u0169\u0001" + + "\u0000\u0000\u0000\u07b1\u07b3\u0003\u00c8d\u0000\u07b2\u07b1\u0001\u0000" + + "\u0000\u0000\u07b2\u07b3\u0001\u0000\u0000\u0000\u07b3\u07b4\u0001\u0000" + + "\u0000\u0000\u07b4\u07b7\u0003\u0096K\u0000\u07b5\u07b8\u0003\u00deo\u0000" + + "\u07b6\u07b8\u0003\u00f4z\u0000\u07b7\u07b5\u0001\u0000\u0000\u0000\u07b7" + + "\u07b6\u0001\u0000\u0000\u0000\u07b7\u07b8\u0001\u0000\u0000\u0000\u07b8" + + "\u07bb\u0001\u0000\u0000\u0000\u07b9\u07bb\u0005\u0083\u0000\u0000\u07ba" + + "\u07b2\u0001\u0000\u0000\u0000\u07ba\u07b9\u0001\u0000\u0000\u0000\u07bb" + + "\u016b\u0001\u0000\u0000\u0000\u07bc\u07be\u0005G\u0000\u0000\u07bd\u07bf" + + "\u0003V+\u0000\u07be\u07bd\u0001\u0000\u0000\u0000\u07be\u07bf\u0001\u0000" + + "\u0000\u0000\u07bf\u016d\u0001\u0000\u0000\u0000\u07c0\u07c3\u0003\u0170" + + "\u00b8\u0000\u07c1\u07c3\u0003\u0174\u00ba\u0000\u07c2\u07c0\u0001\u0000" + + "\u0000\u0000\u07c2\u07c1\u0001\u0000\u0000\u0000\u07c3\u016f\u0001\u0000" + + "\u0000\u0000\u07c4\u07c5\u0005G\u0000\u0000\u07c5\u07c7\u0005U\u0000\u0000" + + "\u07c6\u07c8\u0003\u0172\u00b9\u0000\u07c7\u07c6\u0001\u0000\u0000\u0000" + + "\u07c7\u07c8\u0001\u0000\u0000\u0000\u07c8\u07c9\u0001\u0000\u0000\u0000" + + "\u07c9\u07ca\u0005V\u0000\u0000\u07ca\u0171\u0001\u0000\u0000\u0000\u07cb" + + "\u07cd\u0003\u00f2y\u0000\u07cc\u07ce\u0005\u0083\u0000\u0000\u07cd\u07cc" + + "\u0001\u0000\u0000\u0000\u07cd\u07ce\u0001\u0000\u0000\u0000\u07ce\u07d6" + + "\u0001\u0000\u0000\u0000\u07cf\u07d0\u0005z\u0000\u0000\u07d0\u07d2\u0003" + + "\u00f2y\u0000\u07d1\u07d3\u0005\u0083\u0000\u0000\u07d2\u07d1\u0001\u0000" + + "\u0000\u0000\u07d2\u07d3\u0001\u0000\u0000\u0000\u07d3\u07d5\u0001\u0000" + + "\u0000\u0000\u07d4\u07cf\u0001\u0000\u0000\u0000\u07d5\u07d8\u0001\u0000" + + "\u0000\u0000\u07d6\u07d4\u0001\u0000\u0000\u0000\u07d6\u07d7\u0001\u0000" + + "\u0000\u0000\u07d7\u0173\u0001\u0000\u0000\u0000\u07d8\u07d6\u0001\u0000" + + "\u0000\u0000\u07d9\u07da\u00052\u0000\u0000\u07da\u07db\u0005U\u0000\u0000" + + "\u07db\u07dc\u0003\\.\u0000\u07dc\u07dd\u0005V\u0000\u0000\u07dd\u07e0" + + "\u0001\u0000\u0000\u0000\u07de\u07e0\u00052\u0000\u0000\u07df\u07d9\u0001" + + "\u0000\u0000\u0000\u07df\u07de\u0001\u0000\u0000\u0000\u07e0\u0175\u0001" + + "\u0000\u0000\u0000\u07e1\u07e4\u00051\u0000\u0000\u07e2\u07e3\u0005W\u0000" + + "\u0000\u07e3\u07e5\u0005X\u0000\u0000\u07e4\u07e2\u0001\u0000\u0000\u0000" + + "\u07e4\u07e5\u0001\u0000\u0000\u0000\u07e5\u0817\u0001\u0000\u0000\u0000" + + "\u07e6\u07e9\u0005\u001c\u0000\u0000\u07e7\u07e8\u0005W\u0000\u0000\u07e8" + + "\u07ea\u0005X\u0000\u0000\u07e9\u07e7\u0001\u0000\u0000\u0000\u07e9\u07ea" + + "\u0001\u0000\u0000\u0000\u07ea\u0817\u0001\u0000\u0000\u0000\u07eb\u0817" + + "\u0005[\u0000\u0000\u07ec\u0817\u0005\\\u0000\u0000\u07ed\u0817\u0005" + + "]\u0000\u0000\u07ee\u0817\u0005^\u0000\u0000\u07ef\u0817\u0005_\u0000" + + "\u0000\u07f0\u0817\u0005`\u0000\u0000\u07f1\u0817\u0005a\u0000\u0000\u07f2" + + "\u0817\u0005b\u0000\u0000\u07f3\u0817\u0005c\u0000\u0000\u07f4\u0817\u0005" + + "d\u0000\u0000\u07f5\u0817\u0005e\u0000\u0000\u07f6\u0817\u0005g\u0000" + + "\u0000\u07f7\u0817\u0005f\u0000\u0000\u07f8\u0817\u0005u\u0000\u0000\u07f9" + + "\u0817\u0005h\u0000\u0000\u07fa\u0817\u0005i\u0000\u0000\u07fb\u0817\u0005" + + "j\u0000\u0000\u07fc\u0817\u0005e\u0000\u0000\u07fd\u0817\u0005l\u0000" + + "\u0000\u07fe\u0817\u0005m\u0000\u0000\u07ff\u0817\u0005n\u0000\u0000\u0800" + + "\u0817\u0005o\u0000\u0000\u0801\u0802\u0005f\u0000\u0000\u0802\u0817\u0005" + + "f\u0000\u0000\u0803\u0804\u0005g\u0000\u0000\u0804\u0817\u0005g\u0000" + + "\u0000\u0805\u0817\u0005q\u0000\u0000\u0806\u0817\u0005p\u0000\u0000\u0807" + + "\u0817\u0005r\u0000\u0000\u0808\u0817\u0005s\u0000\u0000\u0809\u0817\u0005" + + "t\u0000\u0000\u080a\u0817\u0005u\u0000\u0000\u080b\u0817\u0005v\u0000" + + "\u0000\u080c\u0817\u0005w\u0000\u0000\u080d\u0817\u0005x\u0000\u0000\u080e" + + "\u0817\u0005y\u0000\u0000\u080f\u0817\u0005z\u0000\u0000\u0810\u0817\u0005" + + "{\u0000\u0000\u0811\u0817\u0005|\u0000\u0000\u0812\u0813\u0005U\u0000" + + "\u0000\u0813\u0817\u0005V\u0000\u0000\u0814\u0815\u0005W\u0000\u0000\u0815" + + "\u0817\u0005X\u0000\u0000\u0816\u07e1\u0001\u0000\u0000\u0000\u0816\u07e6" + + "\u0001\u0000\u0000\u0000\u0816\u07eb\u0001\u0000\u0000\u0000\u0816\u07ec" + + "\u0001\u0000\u0000\u0000\u0816\u07ed\u0001\u0000\u0000\u0000\u0816\u07ee" + + "\u0001\u0000\u0000\u0000\u0816\u07ef\u0001\u0000\u0000\u0000\u0816\u07f0" + + "\u0001\u0000\u0000\u0000\u0816\u07f1\u0001\u0000\u0000\u0000\u0816\u07f2" + + "\u0001\u0000\u0000\u0000\u0816\u07f3\u0001\u0000\u0000\u0000\u0816\u07f4" + + "\u0001\u0000\u0000\u0000\u0816\u07f5\u0001\u0000\u0000\u0000\u0816\u07f6" + + "\u0001\u0000\u0000\u0000\u0816\u07f7\u0001\u0000\u0000\u0000\u0816\u07f8" + + "\u0001\u0000\u0000\u0000\u0816\u07f9\u0001\u0000\u0000\u0000\u0816\u07fa" + + "\u0001\u0000\u0000\u0000\u0816\u07fb\u0001\u0000\u0000\u0000\u0816\u07fc" + + "\u0001\u0000\u0000\u0000\u0816\u07fd\u0001\u0000\u0000\u0000\u0816\u07fe" + + "\u0001\u0000\u0000\u0000\u0816\u07ff\u0001\u0000\u0000\u0000\u0816\u0800" + + "\u0001\u0000\u0000\u0000\u0816\u0801\u0001\u0000\u0000\u0000\u0816\u0803" + + "\u0001\u0000\u0000\u0000\u0816\u0805\u0001\u0000\u0000\u0000\u0816\u0806" + + "\u0001\u0000\u0000\u0000\u0816\u0807\u0001\u0000\u0000\u0000\u0816\u0808" + + "\u0001\u0000\u0000\u0000\u0816\u0809\u0001\u0000\u0000\u0000\u0816\u080a" + + "\u0001\u0000\u0000\u0000\u0816\u080b\u0001\u0000\u0000\u0000\u0816\u080c" + + "\u0001\u0000\u0000\u0000\u0816\u080d\u0001\u0000\u0000\u0000\u0816\u080e" + + "\u0001\u0000\u0000\u0000\u0816\u080f\u0001\u0000\u0000\u0000\u0816\u0810" + + "\u0001\u0000\u0000\u0000\u0816\u0811\u0001\u0000\u0000\u0000\u0816\u0812" + + "\u0001\u0000\u0000\u0000\u0816\u0814\u0001\u0000\u0000\u0000\u0817\u0177" + + "\u0001\u0000\u0000\u0000\u0818\u0819\u0007\u0014\u0000\u0000\u0819\u0179" + + "\u0001\u0000\u0000\u0000\u0129\u017b\u0182\u018b\u018f\u0198\u019b\u019f" + + "\u01a7\u01ae\u01b1\u01b6\u01bb\u01c1\u01c9\u01cb\u01d4\u01d8\u01dc\u01df" + + "\u01e3\u01e6\u01ed\u01f1\u01f4\u01f7\u01fa\u0200\u0204\u0208\u0216\u021a" + + "\u0220\u0227\u022d\u0231\u0235\u0237\u023f\u0244\u0251\u0258\u0264\u026e" + + "\u0273\u0277\u027e\u0281\u0289\u028d\u0290\u0297\u029e\u02a2\u02a7\u02ab" + + "\u02ae\u02b3\u02c2\u02c9\u02d1\u02d9\u02e2\u02e9\u02f0\u02f8\u0300\u0308" + + "\u0310\u0318\u0320\u0329\u0331\u033a\u0341\u0349\u034c\u034f\u0355\u035b" + + "\u0361\u0368\u0371\u0379\u037d\u0384\u0386\u039a\u039e\u03a4\u03a9\u03ad" + + "\u03b0\u03b7\u03be\u03c2\u03cb\u03d6\u03e0\u03e5\u03ec\u03ef\u03f4\u03f9" + + "\u040e\u0413\u0416\u0421\u0427\u042c\u042f\u0434\u0437\u043a\u0450\u0456" + + "\u045c\u0462\u0465\u046b\u046f\u0473\u0476\u047e\u0480\u0486\u0489\u048c" + + "\u048f\u0493\u0497\u049d\u04a7\u04ad\u04b3\u04b8\u04bd\u04c1\u04ce\u04d4" + + "\u04d8\u04de\u04e3\u04f2\u04f6\u04fb\u0500\u0505\u050b\u050e\u0517\u051b" + + "\u0520\u0524\u052a\u0531\u0542\u0544\u054b\u0550\u0557\u055b\u055f\u0567" + + "\u056d\u0573\u0577\u0579\u057d\u0582\u0586\u0589\u058c\u058f\u0594\u0598" + + "\u059b\u059f\u05a2\u05a4\u05a9\u05b0\u05b6\u05ba\u05c0\u05c6\u05c9\u05cb" + + "\u05d1\u05d5\u05db\u05e2\u05e6\u05e8\u05ec\u05f2\u05fe\u0602\u0604\u0608" + + "\u060d\u0610\u0617\u061b\u0620\u0622\u0626\u0629\u062c\u0630\u0635\u063c" + + "\u0643\u0648\u064c\u0650\u0655\u0659\u065f\u0661\u0667\u066c\u0672\u0676" + + "\u0678\u067b\u067f\u0683\u0685\u0687\u068a\u0696\u0698\u069b\u069e\u06a1" + + "\u06aa\u06b1\u06b6\u06b9\u06bc\u06be\u06c1\u06c4\u06c8\u06cd\u06da\u06df" + + "\u06e3\u06e7\u06ec\u06f1\u06f5\u06f8\u06fc\u0707\u070b\u0712\u0717\u071b" + + "\u0721\u0725\u0729\u0732\u073f\u0744\u074b\u074f\u0752\u0755\u0758\u075c" + + "\u0761\u0768\u076c\u0770\u0776\u077b\u077f\u0785\u078b\u078e\u0791\u07a1" + + "\u07a9\u07b2\u07b7\u07ba\u07be\u07c2\u07c7\u07cd\u07d2\u07d6\u07df\u07e4" + + "\u07e9\u0816"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); @@ -18368,4 +19105,4 @@ private boolean noPointerAbstractPackDeclarator_sempred(NoPointerAbstractPackDec _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } -} +} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.tokens b/src/main/java/CPP14Parser.tokens similarity index 100% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.tokens rename to src/main/java/CPP14Parser.tokens diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserBaseListener.java b/src/main/java/CPP14ParserBaseListener.java similarity index 99% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserBaseListener.java rename to src/main/java/CPP14ParserBaseListener.java index 714a988..a3188c0 100644 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserBaseListener.java +++ b/src/main/java/CPP14ParserBaseListener.java @@ -1,6 +1,4 @@ -package jp.ac.osaka_u.sdl.nil.parser.cpp; - -// Generated from CPP14Parser.g4 by ANTLR 4.9.1 +// Generated from CPP14Parser.g4 by ANTLR 4.13.2 import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.ErrorNode; @@ -11,6 +9,7 @@ * which can be extended to create a listener which only needs to handle a subset * of the available methods. */ +@SuppressWarnings("CheckReturnValue") public class CPP14ParserBaseListener implements CPP14ParserListener { /** * {@inheritDoc} diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserListener.java b/src/main/java/CPP14ParserListener.java similarity index 99% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserListener.java rename to src/main/java/CPP14ParserListener.java index ec3e2f5..472c503 100644 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14ParserListener.java +++ b/src/main/java/CPP14ParserListener.java @@ -1,6 +1,4 @@ -// Generated from CPP14Parser.g4 by ANTLR 4.9.1 - -package jp.ac.osaka_u.sdl.nil.parser.cpp; +// Generated from CPP14Parser.g4 by ANTLR 4.13.2 import org.antlr.v4.runtime.tree.ParseTreeListener; @@ -2654,4 +2652,4 @@ public interface CPP14ParserListener extends ParseTreeListener { * @param ctx the parse tree */ void exitLiteral(CPP14Parser.LiteralContext ctx); -} +} \ No newline at end of file diff --git a/src/main/java/CSharpLexer.interp b/src/main/java/CSharpLexer.interp new file mode 100644 index 0000000..7885d92 --- /dev/null +++ b/src/main/java/CSharpLexer.interp @@ -0,0 +1,665 @@ +token literal names: +null +'\u00EF\u00BB\u00BF' +null +'/***/' +null +null +null +null +'#' +'abstract' +'add' +'alias' +'__arglist' +'as' +'ascending' +'async' +'await' +'base' +'bool' +'break' +'by' +'byte' +'case' +'catch' +'char' +'checked' +'class' +'const' +'continue' +'decimal' +'default' +'delegate' +'descending' +'do' +'double' +'dynamic' +'else' +'enum' +'equals' +'event' +'explicit' +'extern' +'false' +'finally' +'fixed' +'float' +'for' +'foreach' +'from' +'get' +'goto' +'group' +'if' +'implicit' +'in' +'int' +'interface' +'internal' +'into' +'is' +'join' +'let' +'lock' +'long' +'nameof' +'namespace' +'new' +'null' +'object' +'on' +'operator' +'orderby' +'out' +'override' +'params' +'partial' +'private' +'protected' +'public' +'readonly' +'ref' +'remove' +'return' +'sbyte' +'sealed' +'select' +'set' +'short' +'sizeof' +'stackalloc' +'static' +'string' +'struct' +'switch' +'this' +'throw' +'true' +'try' +'typeof' +'uint' +'ulong' +'unchecked' +'unmanaged' +'unsafe' +'ushort' +'using' +'var' +'virtual' +'void' +'volatile' +'when' +'where' +'while' +'yield' +null +null +null +null +null +null +null +null +null +null +null +'{' +'}' +'[' +']' +'(' +')' +'.' +',' +':' +';' +'+' +'-' +'*' +'/' +'%' +'&' +'|' +'^' +'!' +'~' +'=' +'<' +'>' +'?' +'::' +'??' +'++' +'--' +'&&' +'||' +'->' +'==' +'!=' +'<=' +'>=' +'+=' +'-=' +'*=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<' +'<<=' +'??=' +'..' +'{{' +null +null +null +null +null +null +null +null +null +null +'define' +'undef' +'elif' +'endif' +'line' +null +null +null +null +null +null +'hidden' +null +null +null +'}}' + +token symbolic names: +null +BYTE_ORDER_MARK +SINGLE_LINE_DOC_COMMENT +EMPTY_DELIMITED_DOC_COMMENT +DELIMITED_DOC_COMMENT +SINGLE_LINE_COMMENT +DELIMITED_COMMENT +WHITESPACES +SHARP +ABSTRACT +ADD +ALIAS +ARGLIST +AS +ASCENDING +ASYNC +AWAIT +BASE +BOOL +BREAK +BY +BYTE +CASE +CATCH +CHAR +CHECKED +CLASS +CONST +CONTINUE +DECIMAL +DEFAULT +DELEGATE +DESCENDING +DO +DOUBLE +DYNAMIC +ELSE +ENUM +EQUALS +EVENT +EXPLICIT +EXTERN +FALSE +FINALLY +FIXED +FLOAT +FOR +FOREACH +FROM +GET +GOTO +GROUP +IF +IMPLICIT +IN +INT +INTERFACE +INTERNAL +INTO +IS +JOIN +LET +LOCK +LONG +NAMEOF +NAMESPACE +NEW +NULL +OBJECT +ON +OPERATOR +ORDERBY +OUT +OVERRIDE +PARAMS +PARTIAL +PRIVATE +PROTECTED +PUBLIC +READONLY +REF +REMOVE +RETURN +SBYTE +SEALED +SELECT +SET +SHORT +SIZEOF +STACKALLOC +STATIC +STRING +STRUCT +SWITCH +THIS +THROW +TRUE +TRY +TYPEOF +UINT +ULONG +UNCHECKED +UNMANAGED +UNSAFE +USHORT +USING +VAR +VIRTUAL +VOID +VOLATILE +WHEN +WHERE +WHILE +YIELD +IDENTIFIER +LITERAL_ACCESS +INTEGER_LITERAL +HEX_INTEGER_LITERAL +BIN_INTEGER_LITERAL +REAL_LITERAL +CHARACTER_LITERAL +REGULAR_STRING +VERBATIUM_STRING +INTERPOLATED_REGULAR_STRING_START +INTERPOLATED_VERBATIUM_STRING_START +OPEN_BRACE +CLOSE_BRACE +OPEN_BRACKET +CLOSE_BRACKET +OPEN_PARENS +CLOSE_PARENS +DOT +COMMA +COLON +SEMICOLON +PLUS +MINUS +STAR +DIV +PERCENT +AMP +BITWISE_OR +CARET +BANG +TILDE +ASSIGNMENT +LT +GT +INTERR +DOUBLE_COLON +OP_COALESCING +OP_INC +OP_DEC +OP_AND +OP_OR +OP_PTR +OP_EQ +OP_NE +OP_LE +OP_GE +OP_ADD_ASSIGNMENT +OP_SUB_ASSIGNMENT +OP_MULT_ASSIGNMENT +OP_DIV_ASSIGNMENT +OP_MOD_ASSIGNMENT +OP_AND_ASSIGNMENT +OP_OR_ASSIGNMENT +OP_XOR_ASSIGNMENT +OP_LEFT_SHIFT +OP_LEFT_SHIFT_ASSIGNMENT +OP_COALESCING_ASSIGNMENT +OP_RANGE +DOUBLE_CURLY_INSIDE +OPEN_BRACE_INSIDE +REGULAR_CHAR_INSIDE +VERBATIUM_DOUBLE_QUOTE_INSIDE +DOUBLE_QUOTE_INSIDE +REGULAR_STRING_INSIDE +VERBATIUM_INSIDE_STRING +CLOSE_BRACE_INSIDE +FORMAT_STRING +DIRECTIVE_WHITESPACES +DIGITS +DEFINE +UNDEF +ELIF +ENDIF +LINE +ERROR +WARNING +REGION +ENDREGION +PRAGMA +NULLABLE +DIRECTIVE_HIDDEN +CONDITIONAL_SYMBOL +DIRECTIVE_NEW_LINE +TEXT +DOUBLE_CURLY_CLOSE_INSIDE + +rule names: +BYTE_ORDER_MARK +SINGLE_LINE_DOC_COMMENT +EMPTY_DELIMITED_DOC_COMMENT +DELIMITED_DOC_COMMENT +SINGLE_LINE_COMMENT +DELIMITED_COMMENT +WHITESPACES +SHARP +ABSTRACT +ADD +ALIAS +ARGLIST +AS +ASCENDING +ASYNC +AWAIT +BASE +BOOL +BREAK +BY +BYTE +CASE +CATCH +CHAR +CHECKED +CLASS +CONST +CONTINUE +DECIMAL +DEFAULT +DELEGATE +DESCENDING +DO +DOUBLE +DYNAMIC +ELSE +ENUM +EQUALS +EVENT +EXPLICIT +EXTERN +FALSE +FINALLY +FIXED +FLOAT +FOR +FOREACH +FROM +GET +GOTO +GROUP +IF +IMPLICIT +IN +INT +INTERFACE +INTERNAL +INTO +IS +JOIN +LET +LOCK +LONG +NAMEOF +NAMESPACE +NEW +NULL +OBJECT +ON +OPERATOR +ORDERBY +OUT +OVERRIDE +PARAMS +PARTIAL +PRIVATE +PROTECTED +PUBLIC +READONLY +REF +REMOVE +RETURN +SBYTE +SEALED +SELECT +SET +SHORT +SIZEOF +STACKALLOC +STATIC +STRING +STRUCT +SWITCH +THIS +THROW +TRUE +TRY +TYPEOF +UINT +ULONG +UNCHECKED +UNMANAGED +UNSAFE +USHORT +USING +VAR +VIRTUAL +VOID +VOLATILE +WHEN +WHERE +WHILE +YIELD +IDENTIFIER +LITERAL_ACCESS +INTEGER_LITERAL +HEX_INTEGER_LITERAL +BIN_INTEGER_LITERAL +REAL_LITERAL +CHARACTER_LITERAL +REGULAR_STRING +VERBATIUM_STRING +INTERPOLATED_REGULAR_STRING_START +INTERPOLATED_VERBATIUM_STRING_START +OPEN_BRACE +CLOSE_BRACE +OPEN_BRACKET +CLOSE_BRACKET +OPEN_PARENS +CLOSE_PARENS +DOT +COMMA +COLON +SEMICOLON +PLUS +MINUS +STAR +DIV +PERCENT +AMP +BITWISE_OR +CARET +BANG +TILDE +ASSIGNMENT +LT +GT +INTERR +DOUBLE_COLON +OP_COALESCING +OP_INC +OP_DEC +OP_AND +OP_OR +OP_PTR +OP_EQ +OP_NE +OP_LE +OP_GE +OP_ADD_ASSIGNMENT +OP_SUB_ASSIGNMENT +OP_MULT_ASSIGNMENT +OP_DIV_ASSIGNMENT +OP_MOD_ASSIGNMENT +OP_AND_ASSIGNMENT +OP_OR_ASSIGNMENT +OP_XOR_ASSIGNMENT +OP_LEFT_SHIFT +OP_LEFT_SHIFT_ASSIGNMENT +OP_COALESCING_ASSIGNMENT +OP_RANGE +DOUBLE_CURLY_INSIDE +OPEN_BRACE_INSIDE +REGULAR_CHAR_INSIDE +VERBATIUM_DOUBLE_QUOTE_INSIDE +DOUBLE_QUOTE_INSIDE +REGULAR_STRING_INSIDE +VERBATIUM_INSIDE_STRING +DOUBLE_CURLY_CLOSE_INSIDE +CLOSE_BRACE_INSIDE +FORMAT_STRING +DIRECTIVE_WHITESPACES +DIGITS +DIRECTIVE_TRUE +DIRECTIVE_FALSE +DEFINE +UNDEF +DIRECTIVE_IF +ELIF +DIRECTIVE_ELSE +ENDIF +LINE +ERROR +WARNING +REGION +ENDREGION +PRAGMA +NULLABLE +DIRECTIVE_DEFAULT +DIRECTIVE_HIDDEN +DIRECTIVE_OPEN_PARENS +DIRECTIVE_CLOSE_PARENS +DIRECTIVE_BANG +DIRECTIVE_OP_EQ +DIRECTIVE_OP_NE +DIRECTIVE_OP_AND +DIRECTIVE_OP_OR +DIRECTIVE_STRING +CONDITIONAL_SYMBOL +DIRECTIVE_SINGLE_LINE_COMMENT +DIRECTIVE_NEW_LINE +TEXT +TEXT_NEW_LINE +InputCharacter +NewLineCharacter +IntegerTypeSuffix +ExponentPart +CommonCharacter +SimpleEscapeSequence +HexEscapeSequence +NewLine +Whitespace +UnicodeClassZS +IdentifierOrKeyword +IdentifierStartCharacter +IdentifierPartCharacter +LetterCharacter +DecimalDigitCharacter +ConnectingCharacter +CombiningCharacter +FormattingCharacter +UnicodeEscapeSequence +HexDigit +UnicodeClassLU +UnicodeClassLL +UnicodeClassLT +UnicodeClassLM +UnicodeClassLO +UnicodeClassNL +UnicodeClassMN +UnicodeClassMC +UnicodeClassCF +UnicodeClassPC +UnicodeClassND + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN +null +null +COMMENTS_CHANNEL +DIRECTIVE + +mode names: +DEFAULT_MODE +INTERPOLATION_STRING +INTERPOLATION_FORMAT +DIRECTIVE_MODE +DIRECTIVE_TEXT + +atn: +[4, 0, 198, 2068, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 503, 8, 1, 10, 1, 12, 1, 506, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 524, 8, 3, 10, 3, 12, 3, 527, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 538, 8, 4, 10, 4, 12, 4, 541, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 549, 8, 5, 10, 5, 12, 5, 552, 9, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 4, 6, 561, 8, 6, 11, 6, 12, 6, 562, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 3, 113, 1247, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 5, 114, 1253, 8, 114, 10, 114, 12, 114, 1256, 9, 114, 1, 114, 5, 114, 1259, 8, 114, 10, 114, 12, 114, 1262, 9, 114, 1, 114, 3, 114, 1265, 8, 114, 1, 114, 1, 114, 3, 114, 1269, 8, 114, 1, 114, 1, 114, 1, 115, 1, 115, 5, 115, 1275, 8, 115, 10, 115, 12, 115, 1278, 9, 115, 1, 115, 5, 115, 1281, 8, 115, 10, 115, 12, 115, 1284, 9, 115, 1, 115, 3, 115, 1287, 8, 115, 1, 116, 1, 116, 1, 116, 5, 116, 1292, 8, 116, 10, 116, 12, 116, 1295, 9, 116, 1, 116, 4, 116, 1298, 8, 116, 11, 116, 12, 116, 1299, 1, 116, 3, 116, 1303, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 1308, 8, 117, 10, 117, 12, 117, 1311, 9, 117, 1, 117, 4, 117, 1314, 8, 117, 11, 117, 12, 117, 1315, 1, 117, 3, 117, 1319, 8, 117, 1, 118, 1, 118, 5, 118, 1323, 8, 118, 10, 118, 12, 118, 1326, 9, 118, 1, 118, 5, 118, 1329, 8, 118, 10, 118, 12, 118, 1332, 9, 118, 3, 118, 1334, 8, 118, 1, 118, 1, 118, 1, 118, 5, 118, 1339, 8, 118, 10, 118, 12, 118, 1342, 9, 118, 1, 118, 5, 118, 1345, 8, 118, 10, 118, 12, 118, 1348, 9, 118, 1, 118, 3, 118, 1351, 8, 118, 1, 118, 3, 118, 1354, 8, 118, 1, 118, 1, 118, 5, 118, 1358, 8, 118, 10, 118, 12, 118, 1361, 9, 118, 1, 118, 5, 118, 1364, 8, 118, 10, 118, 12, 118, 1367, 9, 118, 1, 118, 1, 118, 1, 118, 3, 118, 1372, 8, 118, 3, 118, 1374, 8, 118, 3, 118, 1376, 8, 118, 1, 119, 1, 119, 1, 119, 3, 119, 1381, 8, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 5, 120, 1388, 8, 120, 10, 120, 12, 120, 1391, 9, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 1401, 8, 121, 10, 121, 12, 121, 1404, 9, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 127, 1, 127, 1, 128, 1, 128, 1, 129, 1, 129, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 4, 176, 1568, 8, 176, 11, 176, 12, 176, 1569, 1, 177, 1, 177, 4, 177, 1574, 8, 177, 11, 177, 12, 177, 1575, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 4, 180, 1590, 8, 180, 11, 180, 12, 180, 1591, 1, 181, 4, 181, 1595, 8, 181, 11, 181, 12, 181, 1596, 1, 181, 1, 181, 1, 182, 4, 182, 1602, 8, 182, 11, 182, 12, 182, 1603, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 4, 192, 1685, 8, 192, 11, 192, 12, 192, 1686, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 4, 193, 1701, 8, 193, 11, 193, 12, 193, 1702, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 5, 194, 1716, 8, 194, 10, 194, 12, 194, 1719, 9, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 1735, 8, 195, 10, 195, 12, 195, 1738, 9, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 4, 196, 1751, 8, 196, 11, 196, 12, 196, 1752, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 4, 197, 1768, 8, 197, 11, 197, 12, 197, 1769, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 5, 207, 1836, 8, 207, 10, 207, 12, 207, 1839, 9, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 5, 209, 1854, 8, 209, 10, 209, 12, 209, 1857, 9, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 4, 211, 1868, 8, 211, 11, 211, 12, 211, 1869, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 214, 1, 214, 1, 215, 3, 215, 1885, 8, 215, 1, 215, 1, 215, 3, 215, 1889, 8, 215, 1, 215, 3, 215, 1892, 8, 215, 1, 216, 1, 216, 3, 216, 1896, 8, 216, 1, 216, 1, 216, 5, 216, 1900, 8, 216, 10, 216, 12, 216, 1903, 9, 216, 1, 216, 5, 216, 1906, 8, 216, 10, 216, 12, 216, 1909, 9, 216, 1, 217, 1, 217, 1, 217, 3, 217, 1914, 8, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 1938, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 1965, 8, 219, 1, 220, 1, 220, 1, 220, 3, 220, 1970, 8, 220, 1, 221, 1, 221, 3, 221, 1974, 8, 221, 1, 222, 1, 222, 1, 223, 1, 223, 5, 223, 1980, 8, 223, 10, 223, 12, 223, 1983, 9, 223, 1, 224, 1, 224, 3, 224, 1987, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 1994, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 2003, 8, 226, 1, 227, 1, 227, 3, 227, 2007, 8, 227, 1, 228, 1, 228, 3, 228, 2011, 8, 228, 1, 229, 1, 229, 1, 229, 3, 229, 2016, 8, 229, 1, 230, 1, 230, 3, 230, 2020, 8, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 2042, 8, 231, 1, 232, 3, 232, 2045, 8, 232, 1, 233, 1, 233, 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, 1, 238, 1, 239, 1, 239, 1, 240, 1, 240, 1, 241, 1, 241, 1, 242, 1, 242, 1, 243, 1, 243, 2, 525, 550, 0, 244, 5, 1, 7, 2, 9, 3, 11, 4, 13, 5, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 32, 69, 33, 71, 34, 73, 35, 75, 36, 77, 37, 79, 38, 81, 39, 83, 40, 85, 41, 87, 42, 89, 43, 91, 44, 93, 45, 95, 46, 97, 47, 99, 48, 101, 49, 103, 50, 105, 51, 107, 52, 109, 53, 111, 54, 113, 55, 115, 56, 117, 57, 119, 58, 121, 59, 123, 60, 125, 61, 127, 62, 129, 63, 131, 64, 133, 65, 135, 66, 137, 67, 139, 68, 141, 69, 143, 70, 145, 71, 147, 72, 149, 73, 151, 74, 153, 75, 155, 76, 157, 77, 159, 78, 161, 79, 163, 80, 165, 81, 167, 82, 169, 83, 171, 84, 173, 85, 175, 86, 177, 87, 179, 88, 181, 89, 183, 90, 185, 91, 187, 92, 189, 93, 191, 94, 193, 95, 195, 96, 197, 97, 199, 98, 201, 99, 203, 100, 205, 101, 207, 102, 209, 103, 211, 104, 213, 105, 215, 106, 217, 107, 219, 108, 221, 109, 223, 110, 225, 111, 227, 112, 229, 113, 231, 114, 233, 115, 235, 116, 237, 117, 239, 118, 241, 119, 243, 120, 245, 121, 247, 122, 249, 123, 251, 124, 253, 125, 255, 126, 257, 127, 259, 128, 261, 129, 263, 130, 265, 131, 267, 132, 269, 133, 271, 134, 273, 135, 275, 136, 277, 137, 279, 138, 281, 139, 283, 140, 285, 141, 287, 142, 289, 143, 291, 144, 293, 145, 295, 146, 297, 147, 299, 148, 301, 149, 303, 150, 305, 151, 307, 152, 309, 153, 311, 154, 313, 155, 315, 156, 317, 157, 319, 158, 321, 159, 323, 160, 325, 161, 327, 162, 329, 163, 331, 164, 333, 165, 335, 166, 337, 167, 339, 168, 341, 169, 343, 170, 345, 171, 347, 172, 349, 173, 351, 174, 353, 175, 355, 176, 357, 177, 359, 178, 361, 198, 363, 179, 365, 180, 367, 181, 369, 182, 371, 0, 373, 0, 375, 183, 377, 184, 379, 0, 381, 185, 383, 0, 385, 186, 387, 187, 389, 188, 391, 189, 393, 190, 395, 191, 397, 192, 399, 193, 401, 0, 403, 194, 405, 0, 407, 0, 409, 0, 411, 0, 413, 0, 415, 0, 417, 0, 419, 0, 421, 195, 423, 0, 425, 196, 427, 197, 429, 0, 431, 0, 433, 0, 435, 0, 437, 0, 439, 0, 441, 0, 443, 0, 445, 0, 447, 0, 449, 0, 451, 0, 453, 0, 455, 0, 457, 0, 459, 0, 461, 0, 463, 0, 465, 0, 467, 0, 469, 0, 471, 0, 473, 0, 475, 0, 477, 0, 479, 0, 481, 0, 483, 0, 485, 0, 487, 0, 489, 0, 491, 0, 5, 0, 1, 2, 3, 4, 31, 1, 0, 47, 47, 1, 0, 48, 57, 2, 0, 88, 88, 120, 120, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 6, 0, 68, 68, 70, 70, 77, 77, 100, 100, 102, 102, 109, 109, 6, 0, 10, 10, 13, 13, 39, 39, 92, 92, 133, 133, 8232, 8233, 6, 0, 10, 10, 13, 13, 34, 34, 92, 92, 133, 133, 8232, 8233, 1, 0, 34, 34, 3, 0, 34, 34, 92, 92, 123, 123, 2, 0, 34, 34, 123, 123, 1, 0, 125, 125, 5, 0, 10, 10, 13, 13, 34, 34, 133, 133, 8232, 8233, 4, 0, 10, 10, 13, 13, 133, 133, 8232, 8233, 2, 0, 76, 76, 108, 108, 2, 0, 85, 85, 117, 117, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 9, 9, 11, 12, 9, 0, 32, 32, 160, 160, 5760, 5760, 6158, 6158, 8192, 8198, 8200, 8202, 8239, 8239, 8287, 8287, 12288, 12288, 3, 0, 48, 57, 65, 70, 97, 102, 82, 0, 65, 90, 192, 214, 216, 222, 256, 310, 313, 327, 330, 381, 385, 386, 388, 395, 398, 401, 403, 404, 406, 408, 412, 413, 415, 416, 418, 425, 428, 435, 437, 444, 452, 461, 463, 475, 478, 494, 497, 500, 502, 504, 506, 562, 570, 571, 573, 574, 577, 582, 584, 590, 880, 882, 886, 895, 902, 906, 908, 929, 931, 939, 975, 980, 984, 1006, 1012, 1015, 1017, 1018, 1021, 1071, 1120, 1152, 1162, 1229, 1232, 1326, 1329, 1366, 4256, 4293, 4295, 4301, 7680, 7828, 7838, 7934, 7944, 7951, 7960, 7965, 7976, 7983, 7992, 7999, 8008, 8013, 8025, 8031, 8040, 8047, 8120, 8123, 8136, 8139, 8152, 8155, 8168, 8172, 8184, 8187, 8450, 8455, 8459, 8461, 8464, 8466, 8469, 8477, 8484, 8493, 8496, 8499, 8510, 8511, 8517, 8579, 11264, 11310, 11360, 11364, 11367, 11376, 11378, 11381, 11390, 11392, 11394, 11490, 11499, 11501, 11506, 42560, 42562, 42604, 42624, 42650, 42786, 42798, 42802, 42862, 42873, 42886, 42891, 42893, 42896, 42898, 42902, 42925, 42928, 42929, 65313, 65338, 81, 0, 97, 122, 181, 246, 248, 255, 257, 375, 378, 384, 387, 389, 392, 402, 405, 411, 414, 417, 419, 421, 424, 429, 432, 436, 438, 447, 454, 460, 462, 499, 501, 505, 507, 569, 572, 578, 583, 659, 661, 687, 881, 883, 887, 893, 912, 974, 976, 977, 981, 983, 985, 1011, 1013, 1119, 1121, 1153, 1163, 1215, 1218, 1327, 1377, 1415, 7424, 7467, 7531, 7543, 7545, 7578, 7681, 7837, 7839, 7943, 7952, 7957, 7968, 7975, 7984, 7991, 8000, 8005, 8016, 8023, 8032, 8039, 8048, 8061, 8064, 8071, 8080, 8087, 8096, 8103, 8112, 8116, 8118, 8119, 8126, 8132, 8134, 8135, 8144, 8147, 8150, 8151, 8160, 8167, 8178, 8180, 8182, 8183, 8458, 8467, 8495, 8505, 8508, 8509, 8518, 8521, 8526, 8580, 11312, 11358, 11361, 11372, 11377, 11387, 11393, 11500, 11502, 11507, 11520, 11557, 11559, 11565, 42561, 42605, 42625, 42651, 42787, 42801, 42803, 42872, 42874, 42876, 42879, 42887, 42892, 42894, 42897, 42901, 42903, 42921, 43002, 43866, 43876, 43877, 64256, 64262, 64275, 64279, 65345, 65370, 6, 0, 453, 459, 498, 8079, 8088, 8095, 8104, 8111, 8124, 8140, 8188, 8188, 33, 0, 688, 705, 710, 721, 736, 740, 748, 750, 884, 890, 1369, 1600, 1765, 1766, 2036, 2037, 2042, 2074, 2084, 2088, 2417, 3654, 3782, 4348, 6103, 6211, 6823, 7293, 7468, 7530, 7544, 7615, 8305, 8319, 8336, 8348, 11388, 11389, 11631, 11823, 12293, 12341, 12347, 12542, 40981, 42237, 42508, 42623, 42652, 42653, 42775, 42783, 42864, 42888, 43000, 43001, 43471, 43494, 43632, 43741, 43763, 43764, 43868, 43871, 65392, 65439, 234, 0, 170, 186, 443, 451, 660, 1514, 1520, 1522, 1568, 1599, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1788, 1791, 1808, 1810, 1839, 1869, 1957, 1969, 2026, 2048, 2069, 2112, 2136, 2208, 2226, 2308, 2361, 2365, 2384, 2392, 2401, 2418, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2489, 2493, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2913, 2929, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2986, 2990, 3001, 3024, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3713, 3714, 3716, 3722, 3725, 3735, 3737, 3743, 3745, 3747, 3749, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3780, 3804, 3807, 3840, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4181, 4186, 4189, 4193, 4208, 4213, 4225, 4238, 4346, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5873, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6108, 6210, 6212, 6263, 6272, 6312, 6314, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7401, 7404, 7406, 7409, 7413, 7414, 8501, 8504, 11568, 11623, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12294, 12348, 12353, 12438, 12447, 12538, 12543, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 40980, 40982, 42124, 42192, 42231, 42240, 42507, 42512, 42527, 42538, 42539, 42606, 42725, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43488, 43492, 43495, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43633, 43638, 43642, 43695, 43697, 43709, 43712, 43714, 43739, 43740, 43744, 43754, 43762, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65382, 65391, 65393, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 2, 0, 5870, 5872, 8544, 8559, 3, 0, 2307, 2307, 2366, 2368, 2377, 2380, 3, 0, 173, 173, 1536, 1539, 1757, 1757, 6, 0, 95, 95, 8255, 8256, 8276, 8276, 65075, 65076, 65101, 65103, 65343, 65343, 37, 0, 48, 57, 1632, 1641, 1776, 1785, 1984, 1993, 2406, 2415, 2534, 2543, 2662, 2671, 2790, 2799, 2918, 2927, 3046, 3055, 3174, 3183, 3302, 3311, 3430, 3439, 3558, 3567, 3664, 3673, 3792, 3801, 3872, 3881, 4160, 4169, 4240, 4249, 6112, 6121, 6160, 6169, 6470, 6479, 6608, 6617, 6784, 6793, 6800, 6809, 6992, 7001, 7088, 7097, 7232, 7241, 7248, 7257, 42528, 42537, 43216, 43225, 43264, 43273, 43472, 43481, 43504, 43513, 43600, 43609, 44016, 44025, 65296, 65305, 2124, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 1, 347, 1, 0, 0, 0, 1, 349, 1, 0, 0, 0, 1, 351, 1, 0, 0, 0, 1, 353, 1, 0, 0, 0, 1, 355, 1, 0, 0, 0, 1, 357, 1, 0, 0, 0, 1, 359, 1, 0, 0, 0, 2, 361, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 2, 365, 1, 0, 0, 0, 3, 367, 1, 0, 0, 0, 3, 369, 1, 0, 0, 0, 3, 371, 1, 0, 0, 0, 3, 373, 1, 0, 0, 0, 3, 375, 1, 0, 0, 0, 3, 377, 1, 0, 0, 0, 3, 379, 1, 0, 0, 0, 3, 381, 1, 0, 0, 0, 3, 383, 1, 0, 0, 0, 3, 385, 1, 0, 0, 0, 3, 387, 1, 0, 0, 0, 3, 389, 1, 0, 0, 0, 3, 391, 1, 0, 0, 0, 3, 393, 1, 0, 0, 0, 3, 395, 1, 0, 0, 0, 3, 397, 1, 0, 0, 0, 3, 399, 1, 0, 0, 0, 3, 401, 1, 0, 0, 0, 3, 403, 1, 0, 0, 0, 3, 405, 1, 0, 0, 0, 3, 407, 1, 0, 0, 0, 3, 409, 1, 0, 0, 0, 3, 411, 1, 0, 0, 0, 3, 413, 1, 0, 0, 0, 3, 415, 1, 0, 0, 0, 3, 417, 1, 0, 0, 0, 3, 419, 1, 0, 0, 0, 3, 421, 1, 0, 0, 0, 3, 423, 1, 0, 0, 0, 3, 425, 1, 0, 0, 0, 4, 427, 1, 0, 0, 0, 4, 429, 1, 0, 0, 0, 5, 493, 1, 0, 0, 0, 7, 497, 1, 0, 0, 0, 9, 509, 1, 0, 0, 0, 11, 517, 1, 0, 0, 0, 13, 533, 1, 0, 0, 0, 15, 544, 1, 0, 0, 0, 17, 560, 1, 0, 0, 0, 19, 566, 1, 0, 0, 0, 21, 570, 1, 0, 0, 0, 23, 579, 1, 0, 0, 0, 25, 583, 1, 0, 0, 0, 27, 589, 1, 0, 0, 0, 29, 599, 1, 0, 0, 0, 31, 602, 1, 0, 0, 0, 33, 612, 1, 0, 0, 0, 35, 618, 1, 0, 0, 0, 37, 624, 1, 0, 0, 0, 39, 629, 1, 0, 0, 0, 41, 634, 1, 0, 0, 0, 43, 640, 1, 0, 0, 0, 45, 643, 1, 0, 0, 0, 47, 648, 1, 0, 0, 0, 49, 653, 1, 0, 0, 0, 51, 659, 1, 0, 0, 0, 53, 664, 1, 0, 0, 0, 55, 672, 1, 0, 0, 0, 57, 678, 1, 0, 0, 0, 59, 684, 1, 0, 0, 0, 61, 693, 1, 0, 0, 0, 63, 701, 1, 0, 0, 0, 65, 709, 1, 0, 0, 0, 67, 718, 1, 0, 0, 0, 69, 729, 1, 0, 0, 0, 71, 732, 1, 0, 0, 0, 73, 739, 1, 0, 0, 0, 75, 747, 1, 0, 0, 0, 77, 752, 1, 0, 0, 0, 79, 757, 1, 0, 0, 0, 81, 764, 1, 0, 0, 0, 83, 770, 1, 0, 0, 0, 85, 779, 1, 0, 0, 0, 87, 786, 1, 0, 0, 0, 89, 792, 1, 0, 0, 0, 91, 800, 1, 0, 0, 0, 93, 806, 1, 0, 0, 0, 95, 812, 1, 0, 0, 0, 97, 816, 1, 0, 0, 0, 99, 824, 1, 0, 0, 0, 101, 829, 1, 0, 0, 0, 103, 833, 1, 0, 0, 0, 105, 838, 1, 0, 0, 0, 107, 844, 1, 0, 0, 0, 109, 847, 1, 0, 0, 0, 111, 856, 1, 0, 0, 0, 113, 859, 1, 0, 0, 0, 115, 863, 1, 0, 0, 0, 117, 873, 1, 0, 0, 0, 119, 882, 1, 0, 0, 0, 121, 887, 1, 0, 0, 0, 123, 890, 1, 0, 0, 0, 125, 895, 1, 0, 0, 0, 127, 899, 1, 0, 0, 0, 129, 904, 1, 0, 0, 0, 131, 909, 1, 0, 0, 0, 133, 916, 1, 0, 0, 0, 135, 926, 1, 0, 0, 0, 137, 930, 1, 0, 0, 0, 139, 935, 1, 0, 0, 0, 141, 942, 1, 0, 0, 0, 143, 945, 1, 0, 0, 0, 145, 954, 1, 0, 0, 0, 147, 962, 1, 0, 0, 0, 149, 966, 1, 0, 0, 0, 151, 975, 1, 0, 0, 0, 153, 982, 1, 0, 0, 0, 155, 990, 1, 0, 0, 0, 157, 998, 1, 0, 0, 0, 159, 1008, 1, 0, 0, 0, 161, 1015, 1, 0, 0, 0, 163, 1024, 1, 0, 0, 0, 165, 1028, 1, 0, 0, 0, 167, 1035, 1, 0, 0, 0, 169, 1042, 1, 0, 0, 0, 171, 1048, 1, 0, 0, 0, 173, 1055, 1, 0, 0, 0, 175, 1062, 1, 0, 0, 0, 177, 1066, 1, 0, 0, 0, 179, 1072, 1, 0, 0, 0, 181, 1079, 1, 0, 0, 0, 183, 1090, 1, 0, 0, 0, 185, 1097, 1, 0, 0, 0, 187, 1104, 1, 0, 0, 0, 189, 1111, 1, 0, 0, 0, 191, 1118, 1, 0, 0, 0, 193, 1123, 1, 0, 0, 0, 195, 1129, 1, 0, 0, 0, 197, 1134, 1, 0, 0, 0, 199, 1138, 1, 0, 0, 0, 201, 1145, 1, 0, 0, 0, 203, 1150, 1, 0, 0, 0, 205, 1156, 1, 0, 0, 0, 207, 1166, 1, 0, 0, 0, 209, 1176, 1, 0, 0, 0, 211, 1183, 1, 0, 0, 0, 213, 1190, 1, 0, 0, 0, 215, 1196, 1, 0, 0, 0, 217, 1200, 1, 0, 0, 0, 219, 1208, 1, 0, 0, 0, 221, 1213, 1, 0, 0, 0, 223, 1222, 1, 0, 0, 0, 225, 1227, 1, 0, 0, 0, 227, 1233, 1, 0, 0, 0, 229, 1239, 1, 0, 0, 0, 231, 1246, 1, 0, 0, 0, 233, 1250, 1, 0, 0, 0, 235, 1272, 1, 0, 0, 0, 237, 1288, 1, 0, 0, 0, 239, 1304, 1, 0, 0, 0, 241, 1375, 1, 0, 0, 0, 243, 1377, 1, 0, 0, 0, 245, 1384, 1, 0, 0, 0, 247, 1394, 1, 0, 0, 0, 249, 1407, 1, 0, 0, 0, 251, 1414, 1, 0, 0, 0, 253, 1422, 1, 0, 0, 0, 255, 1425, 1, 0, 0, 0, 257, 1428, 1, 0, 0, 0, 259, 1430, 1, 0, 0, 0, 261, 1432, 1, 0, 0, 0, 263, 1434, 1, 0, 0, 0, 265, 1436, 1, 0, 0, 0, 267, 1438, 1, 0, 0, 0, 269, 1440, 1, 0, 0, 0, 271, 1443, 1, 0, 0, 0, 273, 1445, 1, 0, 0, 0, 275, 1447, 1, 0, 0, 0, 277, 1449, 1, 0, 0, 0, 279, 1451, 1, 0, 0, 0, 281, 1453, 1, 0, 0, 0, 283, 1455, 1, 0, 0, 0, 285, 1457, 1, 0, 0, 0, 287, 1459, 1, 0, 0, 0, 289, 1461, 1, 0, 0, 0, 291, 1463, 1, 0, 0, 0, 293, 1465, 1, 0, 0, 0, 295, 1467, 1, 0, 0, 0, 297, 1469, 1, 0, 0, 0, 299, 1471, 1, 0, 0, 0, 301, 1473, 1, 0, 0, 0, 303, 1476, 1, 0, 0, 0, 305, 1479, 1, 0, 0, 0, 307, 1482, 1, 0, 0, 0, 309, 1485, 1, 0, 0, 0, 311, 1488, 1, 0, 0, 0, 313, 1491, 1, 0, 0, 0, 315, 1494, 1, 0, 0, 0, 317, 1497, 1, 0, 0, 0, 319, 1500, 1, 0, 0, 0, 321, 1503, 1, 0, 0, 0, 323, 1506, 1, 0, 0, 0, 325, 1509, 1, 0, 0, 0, 327, 1512, 1, 0, 0, 0, 329, 1515, 1, 0, 0, 0, 331, 1518, 1, 0, 0, 0, 333, 1521, 1, 0, 0, 0, 335, 1524, 1, 0, 0, 0, 337, 1527, 1, 0, 0, 0, 339, 1530, 1, 0, 0, 0, 341, 1533, 1, 0, 0, 0, 343, 1537, 1, 0, 0, 0, 345, 1541, 1, 0, 0, 0, 347, 1544, 1, 0, 0, 0, 349, 1547, 1, 0, 0, 0, 351, 1553, 1, 0, 0, 0, 353, 1556, 1, 0, 0, 0, 355, 1560, 1, 0, 0, 0, 357, 1565, 1, 0, 0, 0, 359, 1571, 1, 0, 0, 0, 361, 1577, 1, 0, 0, 0, 363, 1582, 1, 0, 0, 0, 365, 1589, 1, 0, 0, 0, 367, 1594, 1, 0, 0, 0, 369, 1601, 1, 0, 0, 0, 371, 1607, 1, 0, 0, 0, 373, 1615, 1, 0, 0, 0, 375, 1624, 1, 0, 0, 0, 377, 1633, 1, 0, 0, 0, 379, 1641, 1, 0, 0, 0, 381, 1647, 1, 0, 0, 0, 383, 1654, 1, 0, 0, 0, 385, 1662, 1, 0, 0, 0, 387, 1670, 1, 0, 0, 0, 389, 1677, 1, 0, 0, 0, 391, 1691, 1, 0, 0, 0, 393, 1707, 1, 0, 0, 0, 395, 1723, 1, 0, 0, 0, 397, 1742, 1, 0, 0, 0, 399, 1757, 1, 0, 0, 0, 401, 1774, 1, 0, 0, 0, 403, 1785, 1, 0, 0, 0, 405, 1794, 1, 0, 0, 0, 407, 1799, 1, 0, 0, 0, 409, 1804, 1, 0, 0, 0, 411, 1809, 1, 0, 0, 0, 413, 1815, 1, 0, 0, 0, 415, 1821, 1, 0, 0, 0, 417, 1827, 1, 0, 0, 0, 419, 1833, 1, 0, 0, 0, 421, 1845, 1, 0, 0, 0, 423, 1849, 1, 0, 0, 0, 425, 1861, 1, 0, 0, 0, 427, 1867, 1, 0, 0, 0, 429, 1873, 1, 0, 0, 0, 431, 1879, 1, 0, 0, 0, 433, 1881, 1, 0, 0, 0, 435, 1891, 1, 0, 0, 0, 437, 1893, 1, 0, 0, 0, 439, 1913, 1, 0, 0, 0, 441, 1937, 1, 0, 0, 0, 443, 1964, 1, 0, 0, 0, 445, 1969, 1, 0, 0, 0, 447, 1973, 1, 0, 0, 0, 449, 1975, 1, 0, 0, 0, 451, 1977, 1, 0, 0, 0, 453, 1986, 1, 0, 0, 0, 455, 1993, 1, 0, 0, 0, 457, 2002, 1, 0, 0, 0, 459, 2006, 1, 0, 0, 0, 461, 2010, 1, 0, 0, 0, 463, 2015, 1, 0, 0, 0, 465, 2019, 1, 0, 0, 0, 467, 2041, 1, 0, 0, 0, 469, 2044, 1, 0, 0, 0, 471, 2046, 1, 0, 0, 0, 473, 2048, 1, 0, 0, 0, 475, 2050, 1, 0, 0, 0, 477, 2052, 1, 0, 0, 0, 479, 2054, 1, 0, 0, 0, 481, 2056, 1, 0, 0, 0, 483, 2058, 1, 0, 0, 0, 485, 2060, 1, 0, 0, 0, 487, 2062, 1, 0, 0, 0, 489, 2064, 1, 0, 0, 0, 491, 2066, 1, 0, 0, 0, 493, 494, 5, 239, 0, 0, 494, 495, 5, 187, 0, 0, 495, 496, 5, 191, 0, 0, 496, 6, 1, 0, 0, 0, 497, 498, 5, 47, 0, 0, 498, 499, 5, 47, 0, 0, 499, 500, 5, 47, 0, 0, 500, 504, 1, 0, 0, 0, 501, 503, 3, 431, 213, 0, 502, 501, 1, 0, 0, 0, 503, 506, 1, 0, 0, 0, 504, 502, 1, 0, 0, 0, 504, 505, 1, 0, 0, 0, 505, 507, 1, 0, 0, 0, 506, 504, 1, 0, 0, 0, 507, 508, 6, 1, 0, 0, 508, 8, 1, 0, 0, 0, 509, 510, 5, 47, 0, 0, 510, 511, 5, 42, 0, 0, 511, 512, 5, 42, 0, 0, 512, 513, 5, 42, 0, 0, 513, 514, 5, 47, 0, 0, 514, 515, 1, 0, 0, 0, 515, 516, 6, 2, 0, 0, 516, 10, 1, 0, 0, 0, 517, 518, 5, 47, 0, 0, 518, 519, 5, 42, 0, 0, 519, 520, 5, 42, 0, 0, 520, 521, 1, 0, 0, 0, 521, 525, 8, 0, 0, 0, 522, 524, 9, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 527, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 525, 523, 1, 0, 0, 0, 526, 528, 1, 0, 0, 0, 527, 525, 1, 0, 0, 0, 528, 529, 5, 42, 0, 0, 529, 530, 5, 47, 0, 0, 530, 531, 1, 0, 0, 0, 531, 532, 6, 3, 0, 0, 532, 12, 1, 0, 0, 0, 533, 534, 5, 47, 0, 0, 534, 535, 5, 47, 0, 0, 535, 539, 1, 0, 0, 0, 536, 538, 3, 431, 213, 0, 537, 536, 1, 0, 0, 0, 538, 541, 1, 0, 0, 0, 539, 537, 1, 0, 0, 0, 539, 540, 1, 0, 0, 0, 540, 542, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 542, 543, 6, 4, 0, 0, 543, 14, 1, 0, 0, 0, 544, 545, 5, 47, 0, 0, 545, 546, 5, 42, 0, 0, 546, 550, 1, 0, 0, 0, 547, 549, 9, 0, 0, 0, 548, 547, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 551, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 554, 5, 42, 0, 0, 554, 555, 5, 47, 0, 0, 555, 556, 1, 0, 0, 0, 556, 557, 6, 5, 0, 0, 557, 16, 1, 0, 0, 0, 558, 561, 3, 447, 221, 0, 559, 561, 3, 445, 220, 0, 560, 558, 1, 0, 0, 0, 560, 559, 1, 0, 0, 0, 561, 562, 1, 0, 0, 0, 562, 560, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 564, 1, 0, 0, 0, 564, 565, 6, 6, 1, 0, 565, 18, 1, 0, 0, 0, 566, 567, 5, 35, 0, 0, 567, 568, 1, 0, 0, 0, 568, 569, 6, 7, 2, 0, 569, 20, 1, 0, 0, 0, 570, 571, 5, 97, 0, 0, 571, 572, 5, 98, 0, 0, 572, 573, 5, 115, 0, 0, 573, 574, 5, 116, 0, 0, 574, 575, 5, 114, 0, 0, 575, 576, 5, 97, 0, 0, 576, 577, 5, 99, 0, 0, 577, 578, 5, 116, 0, 0, 578, 22, 1, 0, 0, 0, 579, 580, 5, 97, 0, 0, 580, 581, 5, 100, 0, 0, 581, 582, 5, 100, 0, 0, 582, 24, 1, 0, 0, 0, 583, 584, 5, 97, 0, 0, 584, 585, 5, 108, 0, 0, 585, 586, 5, 105, 0, 0, 586, 587, 5, 97, 0, 0, 587, 588, 5, 115, 0, 0, 588, 26, 1, 0, 0, 0, 589, 590, 5, 95, 0, 0, 590, 591, 5, 95, 0, 0, 591, 592, 5, 97, 0, 0, 592, 593, 5, 114, 0, 0, 593, 594, 5, 103, 0, 0, 594, 595, 5, 108, 0, 0, 595, 596, 5, 105, 0, 0, 596, 597, 5, 115, 0, 0, 597, 598, 5, 116, 0, 0, 598, 28, 1, 0, 0, 0, 599, 600, 5, 97, 0, 0, 600, 601, 5, 115, 0, 0, 601, 30, 1, 0, 0, 0, 602, 603, 5, 97, 0, 0, 603, 604, 5, 115, 0, 0, 604, 605, 5, 99, 0, 0, 605, 606, 5, 101, 0, 0, 606, 607, 5, 110, 0, 0, 607, 608, 5, 100, 0, 0, 608, 609, 5, 105, 0, 0, 609, 610, 5, 110, 0, 0, 610, 611, 5, 103, 0, 0, 611, 32, 1, 0, 0, 0, 612, 613, 5, 97, 0, 0, 613, 614, 5, 115, 0, 0, 614, 615, 5, 121, 0, 0, 615, 616, 5, 110, 0, 0, 616, 617, 5, 99, 0, 0, 617, 34, 1, 0, 0, 0, 618, 619, 5, 97, 0, 0, 619, 620, 5, 119, 0, 0, 620, 621, 5, 97, 0, 0, 621, 622, 5, 105, 0, 0, 622, 623, 5, 116, 0, 0, 623, 36, 1, 0, 0, 0, 624, 625, 5, 98, 0, 0, 625, 626, 5, 97, 0, 0, 626, 627, 5, 115, 0, 0, 627, 628, 5, 101, 0, 0, 628, 38, 1, 0, 0, 0, 629, 630, 5, 98, 0, 0, 630, 631, 5, 111, 0, 0, 631, 632, 5, 111, 0, 0, 632, 633, 5, 108, 0, 0, 633, 40, 1, 0, 0, 0, 634, 635, 5, 98, 0, 0, 635, 636, 5, 114, 0, 0, 636, 637, 5, 101, 0, 0, 637, 638, 5, 97, 0, 0, 638, 639, 5, 107, 0, 0, 639, 42, 1, 0, 0, 0, 640, 641, 5, 98, 0, 0, 641, 642, 5, 121, 0, 0, 642, 44, 1, 0, 0, 0, 643, 644, 5, 98, 0, 0, 644, 645, 5, 121, 0, 0, 645, 646, 5, 116, 0, 0, 646, 647, 5, 101, 0, 0, 647, 46, 1, 0, 0, 0, 648, 649, 5, 99, 0, 0, 649, 650, 5, 97, 0, 0, 650, 651, 5, 115, 0, 0, 651, 652, 5, 101, 0, 0, 652, 48, 1, 0, 0, 0, 653, 654, 5, 99, 0, 0, 654, 655, 5, 97, 0, 0, 655, 656, 5, 116, 0, 0, 656, 657, 5, 99, 0, 0, 657, 658, 5, 104, 0, 0, 658, 50, 1, 0, 0, 0, 659, 660, 5, 99, 0, 0, 660, 661, 5, 104, 0, 0, 661, 662, 5, 97, 0, 0, 662, 663, 5, 114, 0, 0, 663, 52, 1, 0, 0, 0, 664, 665, 5, 99, 0, 0, 665, 666, 5, 104, 0, 0, 666, 667, 5, 101, 0, 0, 667, 668, 5, 99, 0, 0, 668, 669, 5, 107, 0, 0, 669, 670, 5, 101, 0, 0, 670, 671, 5, 100, 0, 0, 671, 54, 1, 0, 0, 0, 672, 673, 5, 99, 0, 0, 673, 674, 5, 108, 0, 0, 674, 675, 5, 97, 0, 0, 675, 676, 5, 115, 0, 0, 676, 677, 5, 115, 0, 0, 677, 56, 1, 0, 0, 0, 678, 679, 5, 99, 0, 0, 679, 680, 5, 111, 0, 0, 680, 681, 5, 110, 0, 0, 681, 682, 5, 115, 0, 0, 682, 683, 5, 116, 0, 0, 683, 58, 1, 0, 0, 0, 684, 685, 5, 99, 0, 0, 685, 686, 5, 111, 0, 0, 686, 687, 5, 110, 0, 0, 687, 688, 5, 116, 0, 0, 688, 689, 5, 105, 0, 0, 689, 690, 5, 110, 0, 0, 690, 691, 5, 117, 0, 0, 691, 692, 5, 101, 0, 0, 692, 60, 1, 0, 0, 0, 693, 694, 5, 100, 0, 0, 694, 695, 5, 101, 0, 0, 695, 696, 5, 99, 0, 0, 696, 697, 5, 105, 0, 0, 697, 698, 5, 109, 0, 0, 698, 699, 5, 97, 0, 0, 699, 700, 5, 108, 0, 0, 700, 62, 1, 0, 0, 0, 701, 702, 5, 100, 0, 0, 702, 703, 5, 101, 0, 0, 703, 704, 5, 102, 0, 0, 704, 705, 5, 97, 0, 0, 705, 706, 5, 117, 0, 0, 706, 707, 5, 108, 0, 0, 707, 708, 5, 116, 0, 0, 708, 64, 1, 0, 0, 0, 709, 710, 5, 100, 0, 0, 710, 711, 5, 101, 0, 0, 711, 712, 5, 108, 0, 0, 712, 713, 5, 101, 0, 0, 713, 714, 5, 103, 0, 0, 714, 715, 5, 97, 0, 0, 715, 716, 5, 116, 0, 0, 716, 717, 5, 101, 0, 0, 717, 66, 1, 0, 0, 0, 718, 719, 5, 100, 0, 0, 719, 720, 5, 101, 0, 0, 720, 721, 5, 115, 0, 0, 721, 722, 5, 99, 0, 0, 722, 723, 5, 101, 0, 0, 723, 724, 5, 110, 0, 0, 724, 725, 5, 100, 0, 0, 725, 726, 5, 105, 0, 0, 726, 727, 5, 110, 0, 0, 727, 728, 5, 103, 0, 0, 728, 68, 1, 0, 0, 0, 729, 730, 5, 100, 0, 0, 730, 731, 5, 111, 0, 0, 731, 70, 1, 0, 0, 0, 732, 733, 5, 100, 0, 0, 733, 734, 5, 111, 0, 0, 734, 735, 5, 117, 0, 0, 735, 736, 5, 98, 0, 0, 736, 737, 5, 108, 0, 0, 737, 738, 5, 101, 0, 0, 738, 72, 1, 0, 0, 0, 739, 740, 5, 100, 0, 0, 740, 741, 5, 121, 0, 0, 741, 742, 5, 110, 0, 0, 742, 743, 5, 97, 0, 0, 743, 744, 5, 109, 0, 0, 744, 745, 5, 105, 0, 0, 745, 746, 5, 99, 0, 0, 746, 74, 1, 0, 0, 0, 747, 748, 5, 101, 0, 0, 748, 749, 5, 108, 0, 0, 749, 750, 5, 115, 0, 0, 750, 751, 5, 101, 0, 0, 751, 76, 1, 0, 0, 0, 752, 753, 5, 101, 0, 0, 753, 754, 5, 110, 0, 0, 754, 755, 5, 117, 0, 0, 755, 756, 5, 109, 0, 0, 756, 78, 1, 0, 0, 0, 757, 758, 5, 101, 0, 0, 758, 759, 5, 113, 0, 0, 759, 760, 5, 117, 0, 0, 760, 761, 5, 97, 0, 0, 761, 762, 5, 108, 0, 0, 762, 763, 5, 115, 0, 0, 763, 80, 1, 0, 0, 0, 764, 765, 5, 101, 0, 0, 765, 766, 5, 118, 0, 0, 766, 767, 5, 101, 0, 0, 767, 768, 5, 110, 0, 0, 768, 769, 5, 116, 0, 0, 769, 82, 1, 0, 0, 0, 770, 771, 5, 101, 0, 0, 771, 772, 5, 120, 0, 0, 772, 773, 5, 112, 0, 0, 773, 774, 5, 108, 0, 0, 774, 775, 5, 105, 0, 0, 775, 776, 5, 99, 0, 0, 776, 777, 5, 105, 0, 0, 777, 778, 5, 116, 0, 0, 778, 84, 1, 0, 0, 0, 779, 780, 5, 101, 0, 0, 780, 781, 5, 120, 0, 0, 781, 782, 5, 116, 0, 0, 782, 783, 5, 101, 0, 0, 783, 784, 5, 114, 0, 0, 784, 785, 5, 110, 0, 0, 785, 86, 1, 0, 0, 0, 786, 787, 5, 102, 0, 0, 787, 788, 5, 97, 0, 0, 788, 789, 5, 108, 0, 0, 789, 790, 5, 115, 0, 0, 790, 791, 5, 101, 0, 0, 791, 88, 1, 0, 0, 0, 792, 793, 5, 102, 0, 0, 793, 794, 5, 105, 0, 0, 794, 795, 5, 110, 0, 0, 795, 796, 5, 97, 0, 0, 796, 797, 5, 108, 0, 0, 797, 798, 5, 108, 0, 0, 798, 799, 5, 121, 0, 0, 799, 90, 1, 0, 0, 0, 800, 801, 5, 102, 0, 0, 801, 802, 5, 105, 0, 0, 802, 803, 5, 120, 0, 0, 803, 804, 5, 101, 0, 0, 804, 805, 5, 100, 0, 0, 805, 92, 1, 0, 0, 0, 806, 807, 5, 102, 0, 0, 807, 808, 5, 108, 0, 0, 808, 809, 5, 111, 0, 0, 809, 810, 5, 97, 0, 0, 810, 811, 5, 116, 0, 0, 811, 94, 1, 0, 0, 0, 812, 813, 5, 102, 0, 0, 813, 814, 5, 111, 0, 0, 814, 815, 5, 114, 0, 0, 815, 96, 1, 0, 0, 0, 816, 817, 5, 102, 0, 0, 817, 818, 5, 111, 0, 0, 818, 819, 5, 114, 0, 0, 819, 820, 5, 101, 0, 0, 820, 821, 5, 97, 0, 0, 821, 822, 5, 99, 0, 0, 822, 823, 5, 104, 0, 0, 823, 98, 1, 0, 0, 0, 824, 825, 5, 102, 0, 0, 825, 826, 5, 114, 0, 0, 826, 827, 5, 111, 0, 0, 827, 828, 5, 109, 0, 0, 828, 100, 1, 0, 0, 0, 829, 830, 5, 103, 0, 0, 830, 831, 5, 101, 0, 0, 831, 832, 5, 116, 0, 0, 832, 102, 1, 0, 0, 0, 833, 834, 5, 103, 0, 0, 834, 835, 5, 111, 0, 0, 835, 836, 5, 116, 0, 0, 836, 837, 5, 111, 0, 0, 837, 104, 1, 0, 0, 0, 838, 839, 5, 103, 0, 0, 839, 840, 5, 114, 0, 0, 840, 841, 5, 111, 0, 0, 841, 842, 5, 117, 0, 0, 842, 843, 5, 112, 0, 0, 843, 106, 1, 0, 0, 0, 844, 845, 5, 105, 0, 0, 845, 846, 5, 102, 0, 0, 846, 108, 1, 0, 0, 0, 847, 848, 5, 105, 0, 0, 848, 849, 5, 109, 0, 0, 849, 850, 5, 112, 0, 0, 850, 851, 5, 108, 0, 0, 851, 852, 5, 105, 0, 0, 852, 853, 5, 99, 0, 0, 853, 854, 5, 105, 0, 0, 854, 855, 5, 116, 0, 0, 855, 110, 1, 0, 0, 0, 856, 857, 5, 105, 0, 0, 857, 858, 5, 110, 0, 0, 858, 112, 1, 0, 0, 0, 859, 860, 5, 105, 0, 0, 860, 861, 5, 110, 0, 0, 861, 862, 5, 116, 0, 0, 862, 114, 1, 0, 0, 0, 863, 864, 5, 105, 0, 0, 864, 865, 5, 110, 0, 0, 865, 866, 5, 116, 0, 0, 866, 867, 5, 101, 0, 0, 867, 868, 5, 114, 0, 0, 868, 869, 5, 102, 0, 0, 869, 870, 5, 97, 0, 0, 870, 871, 5, 99, 0, 0, 871, 872, 5, 101, 0, 0, 872, 116, 1, 0, 0, 0, 873, 874, 5, 105, 0, 0, 874, 875, 5, 110, 0, 0, 875, 876, 5, 116, 0, 0, 876, 877, 5, 101, 0, 0, 877, 878, 5, 114, 0, 0, 878, 879, 5, 110, 0, 0, 879, 880, 5, 97, 0, 0, 880, 881, 5, 108, 0, 0, 881, 118, 1, 0, 0, 0, 882, 883, 5, 105, 0, 0, 883, 884, 5, 110, 0, 0, 884, 885, 5, 116, 0, 0, 885, 886, 5, 111, 0, 0, 886, 120, 1, 0, 0, 0, 887, 888, 5, 105, 0, 0, 888, 889, 5, 115, 0, 0, 889, 122, 1, 0, 0, 0, 890, 891, 5, 106, 0, 0, 891, 892, 5, 111, 0, 0, 892, 893, 5, 105, 0, 0, 893, 894, 5, 110, 0, 0, 894, 124, 1, 0, 0, 0, 895, 896, 5, 108, 0, 0, 896, 897, 5, 101, 0, 0, 897, 898, 5, 116, 0, 0, 898, 126, 1, 0, 0, 0, 899, 900, 5, 108, 0, 0, 900, 901, 5, 111, 0, 0, 901, 902, 5, 99, 0, 0, 902, 903, 5, 107, 0, 0, 903, 128, 1, 0, 0, 0, 904, 905, 5, 108, 0, 0, 905, 906, 5, 111, 0, 0, 906, 907, 5, 110, 0, 0, 907, 908, 5, 103, 0, 0, 908, 130, 1, 0, 0, 0, 909, 910, 5, 110, 0, 0, 910, 911, 5, 97, 0, 0, 911, 912, 5, 109, 0, 0, 912, 913, 5, 101, 0, 0, 913, 914, 5, 111, 0, 0, 914, 915, 5, 102, 0, 0, 915, 132, 1, 0, 0, 0, 916, 917, 5, 110, 0, 0, 917, 918, 5, 97, 0, 0, 918, 919, 5, 109, 0, 0, 919, 920, 5, 101, 0, 0, 920, 921, 5, 115, 0, 0, 921, 922, 5, 112, 0, 0, 922, 923, 5, 97, 0, 0, 923, 924, 5, 99, 0, 0, 924, 925, 5, 101, 0, 0, 925, 134, 1, 0, 0, 0, 926, 927, 5, 110, 0, 0, 927, 928, 5, 101, 0, 0, 928, 929, 5, 119, 0, 0, 929, 136, 1, 0, 0, 0, 930, 931, 5, 110, 0, 0, 931, 932, 5, 117, 0, 0, 932, 933, 5, 108, 0, 0, 933, 934, 5, 108, 0, 0, 934, 138, 1, 0, 0, 0, 935, 936, 5, 111, 0, 0, 936, 937, 5, 98, 0, 0, 937, 938, 5, 106, 0, 0, 938, 939, 5, 101, 0, 0, 939, 940, 5, 99, 0, 0, 940, 941, 5, 116, 0, 0, 941, 140, 1, 0, 0, 0, 942, 943, 5, 111, 0, 0, 943, 944, 5, 110, 0, 0, 944, 142, 1, 0, 0, 0, 945, 946, 5, 111, 0, 0, 946, 947, 5, 112, 0, 0, 947, 948, 5, 101, 0, 0, 948, 949, 5, 114, 0, 0, 949, 950, 5, 97, 0, 0, 950, 951, 5, 116, 0, 0, 951, 952, 5, 111, 0, 0, 952, 953, 5, 114, 0, 0, 953, 144, 1, 0, 0, 0, 954, 955, 5, 111, 0, 0, 955, 956, 5, 114, 0, 0, 956, 957, 5, 100, 0, 0, 957, 958, 5, 101, 0, 0, 958, 959, 5, 114, 0, 0, 959, 960, 5, 98, 0, 0, 960, 961, 5, 121, 0, 0, 961, 146, 1, 0, 0, 0, 962, 963, 5, 111, 0, 0, 963, 964, 5, 117, 0, 0, 964, 965, 5, 116, 0, 0, 965, 148, 1, 0, 0, 0, 966, 967, 5, 111, 0, 0, 967, 968, 5, 118, 0, 0, 968, 969, 5, 101, 0, 0, 969, 970, 5, 114, 0, 0, 970, 971, 5, 114, 0, 0, 971, 972, 5, 105, 0, 0, 972, 973, 5, 100, 0, 0, 973, 974, 5, 101, 0, 0, 974, 150, 1, 0, 0, 0, 975, 976, 5, 112, 0, 0, 976, 977, 5, 97, 0, 0, 977, 978, 5, 114, 0, 0, 978, 979, 5, 97, 0, 0, 979, 980, 5, 109, 0, 0, 980, 981, 5, 115, 0, 0, 981, 152, 1, 0, 0, 0, 982, 983, 5, 112, 0, 0, 983, 984, 5, 97, 0, 0, 984, 985, 5, 114, 0, 0, 985, 986, 5, 116, 0, 0, 986, 987, 5, 105, 0, 0, 987, 988, 5, 97, 0, 0, 988, 989, 5, 108, 0, 0, 989, 154, 1, 0, 0, 0, 990, 991, 5, 112, 0, 0, 991, 992, 5, 114, 0, 0, 992, 993, 5, 105, 0, 0, 993, 994, 5, 118, 0, 0, 994, 995, 5, 97, 0, 0, 995, 996, 5, 116, 0, 0, 996, 997, 5, 101, 0, 0, 997, 156, 1, 0, 0, 0, 998, 999, 5, 112, 0, 0, 999, 1000, 5, 114, 0, 0, 1000, 1001, 5, 111, 0, 0, 1001, 1002, 5, 116, 0, 0, 1002, 1003, 5, 101, 0, 0, 1003, 1004, 5, 99, 0, 0, 1004, 1005, 5, 116, 0, 0, 1005, 1006, 5, 101, 0, 0, 1006, 1007, 5, 100, 0, 0, 1007, 158, 1, 0, 0, 0, 1008, 1009, 5, 112, 0, 0, 1009, 1010, 5, 117, 0, 0, 1010, 1011, 5, 98, 0, 0, 1011, 1012, 5, 108, 0, 0, 1012, 1013, 5, 105, 0, 0, 1013, 1014, 5, 99, 0, 0, 1014, 160, 1, 0, 0, 0, 1015, 1016, 5, 114, 0, 0, 1016, 1017, 5, 101, 0, 0, 1017, 1018, 5, 97, 0, 0, 1018, 1019, 5, 100, 0, 0, 1019, 1020, 5, 111, 0, 0, 1020, 1021, 5, 110, 0, 0, 1021, 1022, 5, 108, 0, 0, 1022, 1023, 5, 121, 0, 0, 1023, 162, 1, 0, 0, 0, 1024, 1025, 5, 114, 0, 0, 1025, 1026, 5, 101, 0, 0, 1026, 1027, 5, 102, 0, 0, 1027, 164, 1, 0, 0, 0, 1028, 1029, 5, 114, 0, 0, 1029, 1030, 5, 101, 0, 0, 1030, 1031, 5, 109, 0, 0, 1031, 1032, 5, 111, 0, 0, 1032, 1033, 5, 118, 0, 0, 1033, 1034, 5, 101, 0, 0, 1034, 166, 1, 0, 0, 0, 1035, 1036, 5, 114, 0, 0, 1036, 1037, 5, 101, 0, 0, 1037, 1038, 5, 116, 0, 0, 1038, 1039, 5, 117, 0, 0, 1039, 1040, 5, 114, 0, 0, 1040, 1041, 5, 110, 0, 0, 1041, 168, 1, 0, 0, 0, 1042, 1043, 5, 115, 0, 0, 1043, 1044, 5, 98, 0, 0, 1044, 1045, 5, 121, 0, 0, 1045, 1046, 5, 116, 0, 0, 1046, 1047, 5, 101, 0, 0, 1047, 170, 1, 0, 0, 0, 1048, 1049, 5, 115, 0, 0, 1049, 1050, 5, 101, 0, 0, 1050, 1051, 5, 97, 0, 0, 1051, 1052, 5, 108, 0, 0, 1052, 1053, 5, 101, 0, 0, 1053, 1054, 5, 100, 0, 0, 1054, 172, 1, 0, 0, 0, 1055, 1056, 5, 115, 0, 0, 1056, 1057, 5, 101, 0, 0, 1057, 1058, 5, 108, 0, 0, 1058, 1059, 5, 101, 0, 0, 1059, 1060, 5, 99, 0, 0, 1060, 1061, 5, 116, 0, 0, 1061, 174, 1, 0, 0, 0, 1062, 1063, 5, 115, 0, 0, 1063, 1064, 5, 101, 0, 0, 1064, 1065, 5, 116, 0, 0, 1065, 176, 1, 0, 0, 0, 1066, 1067, 5, 115, 0, 0, 1067, 1068, 5, 104, 0, 0, 1068, 1069, 5, 111, 0, 0, 1069, 1070, 5, 114, 0, 0, 1070, 1071, 5, 116, 0, 0, 1071, 178, 1, 0, 0, 0, 1072, 1073, 5, 115, 0, 0, 1073, 1074, 5, 105, 0, 0, 1074, 1075, 5, 122, 0, 0, 1075, 1076, 5, 101, 0, 0, 1076, 1077, 5, 111, 0, 0, 1077, 1078, 5, 102, 0, 0, 1078, 180, 1, 0, 0, 0, 1079, 1080, 5, 115, 0, 0, 1080, 1081, 5, 116, 0, 0, 1081, 1082, 5, 97, 0, 0, 1082, 1083, 5, 99, 0, 0, 1083, 1084, 5, 107, 0, 0, 1084, 1085, 5, 97, 0, 0, 1085, 1086, 5, 108, 0, 0, 1086, 1087, 5, 108, 0, 0, 1087, 1088, 5, 111, 0, 0, 1088, 1089, 5, 99, 0, 0, 1089, 182, 1, 0, 0, 0, 1090, 1091, 5, 115, 0, 0, 1091, 1092, 5, 116, 0, 0, 1092, 1093, 5, 97, 0, 0, 1093, 1094, 5, 116, 0, 0, 1094, 1095, 5, 105, 0, 0, 1095, 1096, 5, 99, 0, 0, 1096, 184, 1, 0, 0, 0, 1097, 1098, 5, 115, 0, 0, 1098, 1099, 5, 116, 0, 0, 1099, 1100, 5, 114, 0, 0, 1100, 1101, 5, 105, 0, 0, 1101, 1102, 5, 110, 0, 0, 1102, 1103, 5, 103, 0, 0, 1103, 186, 1, 0, 0, 0, 1104, 1105, 5, 115, 0, 0, 1105, 1106, 5, 116, 0, 0, 1106, 1107, 5, 114, 0, 0, 1107, 1108, 5, 117, 0, 0, 1108, 1109, 5, 99, 0, 0, 1109, 1110, 5, 116, 0, 0, 1110, 188, 1, 0, 0, 0, 1111, 1112, 5, 115, 0, 0, 1112, 1113, 5, 119, 0, 0, 1113, 1114, 5, 105, 0, 0, 1114, 1115, 5, 116, 0, 0, 1115, 1116, 5, 99, 0, 0, 1116, 1117, 5, 104, 0, 0, 1117, 190, 1, 0, 0, 0, 1118, 1119, 5, 116, 0, 0, 1119, 1120, 5, 104, 0, 0, 1120, 1121, 5, 105, 0, 0, 1121, 1122, 5, 115, 0, 0, 1122, 192, 1, 0, 0, 0, 1123, 1124, 5, 116, 0, 0, 1124, 1125, 5, 104, 0, 0, 1125, 1126, 5, 114, 0, 0, 1126, 1127, 5, 111, 0, 0, 1127, 1128, 5, 119, 0, 0, 1128, 194, 1, 0, 0, 0, 1129, 1130, 5, 116, 0, 0, 1130, 1131, 5, 114, 0, 0, 1131, 1132, 5, 117, 0, 0, 1132, 1133, 5, 101, 0, 0, 1133, 196, 1, 0, 0, 0, 1134, 1135, 5, 116, 0, 0, 1135, 1136, 5, 114, 0, 0, 1136, 1137, 5, 121, 0, 0, 1137, 198, 1, 0, 0, 0, 1138, 1139, 5, 116, 0, 0, 1139, 1140, 5, 121, 0, 0, 1140, 1141, 5, 112, 0, 0, 1141, 1142, 5, 101, 0, 0, 1142, 1143, 5, 111, 0, 0, 1143, 1144, 5, 102, 0, 0, 1144, 200, 1, 0, 0, 0, 1145, 1146, 5, 117, 0, 0, 1146, 1147, 5, 105, 0, 0, 1147, 1148, 5, 110, 0, 0, 1148, 1149, 5, 116, 0, 0, 1149, 202, 1, 0, 0, 0, 1150, 1151, 5, 117, 0, 0, 1151, 1152, 5, 108, 0, 0, 1152, 1153, 5, 111, 0, 0, 1153, 1154, 5, 110, 0, 0, 1154, 1155, 5, 103, 0, 0, 1155, 204, 1, 0, 0, 0, 1156, 1157, 5, 117, 0, 0, 1157, 1158, 5, 110, 0, 0, 1158, 1159, 5, 99, 0, 0, 1159, 1160, 5, 104, 0, 0, 1160, 1161, 5, 101, 0, 0, 1161, 1162, 5, 99, 0, 0, 1162, 1163, 5, 107, 0, 0, 1163, 1164, 5, 101, 0, 0, 1164, 1165, 5, 100, 0, 0, 1165, 206, 1, 0, 0, 0, 1166, 1167, 5, 117, 0, 0, 1167, 1168, 5, 110, 0, 0, 1168, 1169, 5, 109, 0, 0, 1169, 1170, 5, 97, 0, 0, 1170, 1171, 5, 110, 0, 0, 1171, 1172, 5, 97, 0, 0, 1172, 1173, 5, 103, 0, 0, 1173, 1174, 5, 101, 0, 0, 1174, 1175, 5, 100, 0, 0, 1175, 208, 1, 0, 0, 0, 1176, 1177, 5, 117, 0, 0, 1177, 1178, 5, 110, 0, 0, 1178, 1179, 5, 115, 0, 0, 1179, 1180, 5, 97, 0, 0, 1180, 1181, 5, 102, 0, 0, 1181, 1182, 5, 101, 0, 0, 1182, 210, 1, 0, 0, 0, 1183, 1184, 5, 117, 0, 0, 1184, 1185, 5, 115, 0, 0, 1185, 1186, 5, 104, 0, 0, 1186, 1187, 5, 111, 0, 0, 1187, 1188, 5, 114, 0, 0, 1188, 1189, 5, 116, 0, 0, 1189, 212, 1, 0, 0, 0, 1190, 1191, 5, 117, 0, 0, 1191, 1192, 5, 115, 0, 0, 1192, 1193, 5, 105, 0, 0, 1193, 1194, 5, 110, 0, 0, 1194, 1195, 5, 103, 0, 0, 1195, 214, 1, 0, 0, 0, 1196, 1197, 5, 118, 0, 0, 1197, 1198, 5, 97, 0, 0, 1198, 1199, 5, 114, 0, 0, 1199, 216, 1, 0, 0, 0, 1200, 1201, 5, 118, 0, 0, 1201, 1202, 5, 105, 0, 0, 1202, 1203, 5, 114, 0, 0, 1203, 1204, 5, 116, 0, 0, 1204, 1205, 5, 117, 0, 0, 1205, 1206, 5, 97, 0, 0, 1206, 1207, 5, 108, 0, 0, 1207, 218, 1, 0, 0, 0, 1208, 1209, 5, 118, 0, 0, 1209, 1210, 5, 111, 0, 0, 1210, 1211, 5, 105, 0, 0, 1211, 1212, 5, 100, 0, 0, 1212, 220, 1, 0, 0, 0, 1213, 1214, 5, 118, 0, 0, 1214, 1215, 5, 111, 0, 0, 1215, 1216, 5, 108, 0, 0, 1216, 1217, 5, 97, 0, 0, 1217, 1218, 5, 116, 0, 0, 1218, 1219, 5, 105, 0, 0, 1219, 1220, 5, 108, 0, 0, 1220, 1221, 5, 101, 0, 0, 1221, 222, 1, 0, 0, 0, 1222, 1223, 5, 119, 0, 0, 1223, 1224, 5, 104, 0, 0, 1224, 1225, 5, 101, 0, 0, 1225, 1226, 5, 110, 0, 0, 1226, 224, 1, 0, 0, 0, 1227, 1228, 5, 119, 0, 0, 1228, 1229, 5, 104, 0, 0, 1229, 1230, 5, 101, 0, 0, 1230, 1231, 5, 114, 0, 0, 1231, 1232, 5, 101, 0, 0, 1232, 226, 1, 0, 0, 0, 1233, 1234, 5, 119, 0, 0, 1234, 1235, 5, 104, 0, 0, 1235, 1236, 5, 105, 0, 0, 1236, 1237, 5, 108, 0, 0, 1237, 1238, 5, 101, 0, 0, 1238, 228, 1, 0, 0, 0, 1239, 1240, 5, 121, 0, 0, 1240, 1241, 5, 105, 0, 0, 1241, 1242, 5, 101, 0, 0, 1242, 1243, 5, 108, 0, 0, 1243, 1244, 5, 100, 0, 0, 1244, 230, 1, 0, 0, 0, 1245, 1247, 5, 64, 0, 0, 1246, 1245, 1, 0, 0, 0, 1246, 1247, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1249, 3, 451, 223, 0, 1249, 232, 1, 0, 0, 0, 1250, 1260, 7, 1, 0, 0, 1251, 1253, 5, 95, 0, 0, 1252, 1251, 1, 0, 0, 0, 1253, 1256, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 1257, 1, 0, 0, 0, 1256, 1254, 1, 0, 0, 0, 1257, 1259, 7, 1, 0, 0, 1258, 1254, 1, 0, 0, 0, 1259, 1262, 1, 0, 0, 0, 1260, 1258, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1264, 1, 0, 0, 0, 1262, 1260, 1, 0, 0, 0, 1263, 1265, 3, 435, 215, 0, 1264, 1263, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, 1268, 5, 46, 0, 0, 1267, 1269, 5, 64, 0, 0, 1268, 1267, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1271, 3, 451, 223, 0, 1271, 234, 1, 0, 0, 0, 1272, 1282, 7, 1, 0, 0, 1273, 1275, 5, 95, 0, 0, 1274, 1273, 1, 0, 0, 0, 1275, 1278, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 1279, 1, 0, 0, 0, 1278, 1276, 1, 0, 0, 0, 1279, 1281, 7, 1, 0, 0, 1280, 1276, 1, 0, 0, 0, 1281, 1284, 1, 0, 0, 0, 1282, 1280, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1282, 1, 0, 0, 0, 1285, 1287, 3, 435, 215, 0, 1286, 1285, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 236, 1, 0, 0, 0, 1288, 1289, 5, 48, 0, 0, 1289, 1297, 7, 2, 0, 0, 1290, 1292, 5, 95, 0, 0, 1291, 1290, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1296, 1, 0, 0, 0, 1295, 1293, 1, 0, 0, 0, 1296, 1298, 3, 469, 232, 0, 1297, 1293, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1297, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1302, 1, 0, 0, 0, 1301, 1303, 3, 435, 215, 0, 1302, 1301, 1, 0, 0, 0, 1302, 1303, 1, 0, 0, 0, 1303, 238, 1, 0, 0, 0, 1304, 1305, 5, 48, 0, 0, 1305, 1313, 7, 3, 0, 0, 1306, 1308, 5, 95, 0, 0, 1307, 1306, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1312, 1314, 7, 4, 0, 0, 1313, 1309, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 1313, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1318, 1, 0, 0, 0, 1317, 1319, 3, 435, 215, 0, 1318, 1317, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 240, 1, 0, 0, 0, 1320, 1330, 7, 1, 0, 0, 1321, 1323, 5, 95, 0, 0, 1322, 1321, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1327, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1329, 7, 1, 0, 0, 1328, 1324, 1, 0, 0, 0, 1329, 1332, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1333, 1320, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 5, 46, 0, 0, 1336, 1346, 7, 1, 0, 0, 1337, 1339, 5, 95, 0, 0, 1338, 1337, 1, 0, 0, 0, 1339, 1342, 1, 0, 0, 0, 1340, 1338, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1343, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1343, 1345, 7, 1, 0, 0, 1344, 1340, 1, 0, 0, 0, 1345, 1348, 1, 0, 0, 0, 1346, 1344, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1350, 1, 0, 0, 0, 1348, 1346, 1, 0, 0, 0, 1349, 1351, 3, 437, 216, 0, 1350, 1349, 1, 0, 0, 0, 1350, 1351, 1, 0, 0, 0, 1351, 1353, 1, 0, 0, 0, 1352, 1354, 7, 5, 0, 0, 1353, 1352, 1, 0, 0, 0, 1353, 1354, 1, 0, 0, 0, 1354, 1376, 1, 0, 0, 0, 1355, 1365, 7, 1, 0, 0, 1356, 1358, 5, 95, 0, 0, 1357, 1356, 1, 0, 0, 0, 1358, 1361, 1, 0, 0, 0, 1359, 1357, 1, 0, 0, 0, 1359, 1360, 1, 0, 0, 0, 1360, 1362, 1, 0, 0, 0, 1361, 1359, 1, 0, 0, 0, 1362, 1364, 7, 1, 0, 0, 1363, 1359, 1, 0, 0, 0, 1364, 1367, 1, 0, 0, 0, 1365, 1363, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1373, 1, 0, 0, 0, 1367, 1365, 1, 0, 0, 0, 1368, 1374, 7, 5, 0, 0, 1369, 1371, 3, 437, 216, 0, 1370, 1372, 7, 5, 0, 0, 1371, 1370, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, 0, 0, 0, 1373, 1368, 1, 0, 0, 0, 1373, 1369, 1, 0, 0, 0, 1374, 1376, 1, 0, 0, 0, 1375, 1333, 1, 0, 0, 0, 1375, 1355, 1, 0, 0, 0, 1376, 242, 1, 0, 0, 0, 1377, 1380, 5, 39, 0, 0, 1378, 1381, 8, 6, 0, 0, 1379, 1381, 3, 439, 217, 0, 1380, 1378, 1, 0, 0, 0, 1380, 1379, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 1383, 5, 39, 0, 0, 1383, 244, 1, 0, 0, 0, 1384, 1389, 5, 34, 0, 0, 1385, 1388, 8, 7, 0, 0, 1386, 1388, 3, 439, 217, 0, 1387, 1385, 1, 0, 0, 0, 1387, 1386, 1, 0, 0, 0, 1388, 1391, 1, 0, 0, 0, 1389, 1387, 1, 0, 0, 0, 1389, 1390, 1, 0, 0, 0, 1390, 1392, 1, 0, 0, 0, 1391, 1389, 1, 0, 0, 0, 1392, 1393, 5, 34, 0, 0, 1393, 246, 1, 0, 0, 0, 1394, 1395, 5, 64, 0, 0, 1395, 1396, 5, 34, 0, 0, 1396, 1402, 1, 0, 0, 0, 1397, 1401, 8, 8, 0, 0, 1398, 1399, 5, 34, 0, 0, 1399, 1401, 5, 34, 0, 0, 1400, 1397, 1, 0, 0, 0, 1400, 1398, 1, 0, 0, 0, 1401, 1404, 1, 0, 0, 0, 1402, 1400, 1, 0, 0, 0, 1402, 1403, 1, 0, 0, 0, 1403, 1405, 1, 0, 0, 0, 1404, 1402, 1, 0, 0, 0, 1405, 1406, 5, 34, 0, 0, 1406, 248, 1, 0, 0, 0, 1407, 1408, 5, 36, 0, 0, 1408, 1409, 5, 34, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1411, 6, 122, 3, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1413, 6, 122, 4, 0, 1413, 250, 1, 0, 0, 0, 1414, 1415, 5, 36, 0, 0, 1415, 1416, 5, 64, 0, 0, 1416, 1417, 5, 34, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1419, 6, 123, 5, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 6, 123, 4, 0, 1421, 252, 1, 0, 0, 0, 1422, 1423, 5, 123, 0, 0, 1423, 1424, 6, 124, 6, 0, 1424, 254, 1, 0, 0, 0, 1425, 1426, 5, 125, 0, 0, 1426, 1427, 6, 125, 7, 0, 1427, 256, 1, 0, 0, 0, 1428, 1429, 5, 91, 0, 0, 1429, 258, 1, 0, 0, 0, 1430, 1431, 5, 93, 0, 0, 1431, 260, 1, 0, 0, 0, 1432, 1433, 5, 40, 0, 0, 1433, 262, 1, 0, 0, 0, 1434, 1435, 5, 41, 0, 0, 1435, 264, 1, 0, 0, 0, 1436, 1437, 5, 46, 0, 0, 1437, 266, 1, 0, 0, 0, 1438, 1439, 5, 44, 0, 0, 1439, 268, 1, 0, 0, 0, 1440, 1441, 5, 58, 0, 0, 1441, 1442, 6, 132, 8, 0, 1442, 270, 1, 0, 0, 0, 1443, 1444, 5, 59, 0, 0, 1444, 272, 1, 0, 0, 0, 1445, 1446, 5, 43, 0, 0, 1446, 274, 1, 0, 0, 0, 1447, 1448, 5, 45, 0, 0, 1448, 276, 1, 0, 0, 0, 1449, 1450, 5, 42, 0, 0, 1450, 278, 1, 0, 0, 0, 1451, 1452, 5, 47, 0, 0, 1452, 280, 1, 0, 0, 0, 1453, 1454, 5, 37, 0, 0, 1454, 282, 1, 0, 0, 0, 1455, 1456, 5, 38, 0, 0, 1456, 284, 1, 0, 0, 0, 1457, 1458, 5, 124, 0, 0, 1458, 286, 1, 0, 0, 0, 1459, 1460, 5, 94, 0, 0, 1460, 288, 1, 0, 0, 0, 1461, 1462, 5, 33, 0, 0, 1462, 290, 1, 0, 0, 0, 1463, 1464, 5, 126, 0, 0, 1464, 292, 1, 0, 0, 0, 1465, 1466, 5, 61, 0, 0, 1466, 294, 1, 0, 0, 0, 1467, 1468, 5, 60, 0, 0, 1468, 296, 1, 0, 0, 0, 1469, 1470, 5, 62, 0, 0, 1470, 298, 1, 0, 0, 0, 1471, 1472, 5, 63, 0, 0, 1472, 300, 1, 0, 0, 0, 1473, 1474, 5, 58, 0, 0, 1474, 1475, 5, 58, 0, 0, 1475, 302, 1, 0, 0, 0, 1476, 1477, 5, 63, 0, 0, 1477, 1478, 5, 63, 0, 0, 1478, 304, 1, 0, 0, 0, 1479, 1480, 5, 43, 0, 0, 1480, 1481, 5, 43, 0, 0, 1481, 306, 1, 0, 0, 0, 1482, 1483, 5, 45, 0, 0, 1483, 1484, 5, 45, 0, 0, 1484, 308, 1, 0, 0, 0, 1485, 1486, 5, 38, 0, 0, 1486, 1487, 5, 38, 0, 0, 1487, 310, 1, 0, 0, 0, 1488, 1489, 5, 124, 0, 0, 1489, 1490, 5, 124, 0, 0, 1490, 312, 1, 0, 0, 0, 1491, 1492, 5, 45, 0, 0, 1492, 1493, 5, 62, 0, 0, 1493, 314, 1, 0, 0, 0, 1494, 1495, 5, 61, 0, 0, 1495, 1496, 5, 61, 0, 0, 1496, 316, 1, 0, 0, 0, 1497, 1498, 5, 33, 0, 0, 1498, 1499, 5, 61, 0, 0, 1499, 318, 1, 0, 0, 0, 1500, 1501, 5, 60, 0, 0, 1501, 1502, 5, 61, 0, 0, 1502, 320, 1, 0, 0, 0, 1503, 1504, 5, 62, 0, 0, 1504, 1505, 5, 61, 0, 0, 1505, 322, 1, 0, 0, 0, 1506, 1507, 5, 43, 0, 0, 1507, 1508, 5, 61, 0, 0, 1508, 324, 1, 0, 0, 0, 1509, 1510, 5, 45, 0, 0, 1510, 1511, 5, 61, 0, 0, 1511, 326, 1, 0, 0, 0, 1512, 1513, 5, 42, 0, 0, 1513, 1514, 5, 61, 0, 0, 1514, 328, 1, 0, 0, 0, 1515, 1516, 5, 47, 0, 0, 1516, 1517, 5, 61, 0, 0, 1517, 330, 1, 0, 0, 0, 1518, 1519, 5, 37, 0, 0, 1519, 1520, 5, 61, 0, 0, 1520, 332, 1, 0, 0, 0, 1521, 1522, 5, 38, 0, 0, 1522, 1523, 5, 61, 0, 0, 1523, 334, 1, 0, 0, 0, 1524, 1525, 5, 124, 0, 0, 1525, 1526, 5, 61, 0, 0, 1526, 336, 1, 0, 0, 0, 1527, 1528, 5, 94, 0, 0, 1528, 1529, 5, 61, 0, 0, 1529, 338, 1, 0, 0, 0, 1530, 1531, 5, 60, 0, 0, 1531, 1532, 5, 60, 0, 0, 1532, 340, 1, 0, 0, 0, 1533, 1534, 5, 60, 0, 0, 1534, 1535, 5, 60, 0, 0, 1535, 1536, 5, 61, 0, 0, 1536, 342, 1, 0, 0, 0, 1537, 1538, 5, 63, 0, 0, 1538, 1539, 5, 63, 0, 0, 1539, 1540, 5, 61, 0, 0, 1540, 344, 1, 0, 0, 0, 1541, 1542, 5, 46, 0, 0, 1542, 1543, 5, 46, 0, 0, 1543, 346, 1, 0, 0, 0, 1544, 1545, 5, 123, 0, 0, 1545, 1546, 5, 123, 0, 0, 1546, 348, 1, 0, 0, 0, 1547, 1548, 5, 123, 0, 0, 1548, 1549, 6, 172, 9, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 6, 172, 10, 0, 1551, 1552, 6, 172, 11, 0, 1552, 350, 1, 0, 0, 0, 1553, 1554, 4, 173, 0, 0, 1554, 1555, 3, 441, 218, 0, 1555, 352, 1, 0, 0, 0, 1556, 1557, 4, 174, 1, 0, 1557, 1558, 5, 34, 0, 0, 1558, 1559, 5, 34, 0, 0, 1559, 354, 1, 0, 0, 0, 1560, 1561, 5, 34, 0, 0, 1561, 1562, 6, 175, 12, 0, 1562, 1563, 1, 0, 0, 0, 1563, 1564, 6, 175, 13, 0, 1564, 356, 1, 0, 0, 0, 1565, 1567, 4, 176, 2, 0, 1566, 1568, 8, 9, 0, 0, 1567, 1566, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1567, 1, 0, 0, 0, 1569, 1570, 1, 0, 0, 0, 1570, 358, 1, 0, 0, 0, 1571, 1573, 4, 177, 3, 0, 1572, 1574, 8, 10, 0, 0, 1573, 1572, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 360, 1, 0, 0, 0, 1577, 1578, 5, 125, 0, 0, 1578, 1579, 5, 125, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1581, 6, 178, 14, 0, 1581, 362, 1, 0, 0, 0, 1582, 1583, 5, 125, 0, 0, 1583, 1584, 6, 179, 15, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 6, 179, 10, 0, 1586, 1587, 6, 179, 13, 0, 1587, 364, 1, 0, 0, 0, 1588, 1590, 8, 11, 0, 0, 1589, 1588, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1591, 1592, 1, 0, 0, 0, 1592, 366, 1, 0, 0, 0, 1593, 1595, 3, 447, 221, 0, 1594, 1593, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1599, 6, 181, 1, 0, 1599, 368, 1, 0, 0, 0, 1600, 1602, 7, 1, 0, 0, 1601, 1600, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1603, 1604, 1, 0, 0, 0, 1604, 1605, 1, 0, 0, 0, 1605, 1606, 6, 182, 16, 0, 1606, 370, 1, 0, 0, 0, 1607, 1608, 5, 116, 0, 0, 1608, 1609, 5, 114, 0, 0, 1609, 1610, 5, 117, 0, 0, 1610, 1611, 5, 101, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612, 1613, 6, 183, 16, 0, 1613, 1614, 6, 183, 17, 0, 1614, 372, 1, 0, 0, 0, 1615, 1616, 5, 102, 0, 0, 1616, 1617, 5, 97, 0, 0, 1617, 1618, 5, 108, 0, 0, 1618, 1619, 5, 115, 0, 0, 1619, 1620, 5, 101, 0, 0, 1620, 1621, 1, 0, 0, 0, 1621, 1622, 6, 184, 16, 0, 1622, 1623, 6, 184, 18, 0, 1623, 374, 1, 0, 0, 0, 1624, 1625, 5, 100, 0, 0, 1625, 1626, 5, 101, 0, 0, 1626, 1627, 5, 102, 0, 0, 1627, 1628, 5, 105, 0, 0, 1628, 1629, 5, 110, 0, 0, 1629, 1630, 5, 101, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1632, 6, 185, 16, 0, 1632, 376, 1, 0, 0, 0, 1633, 1634, 5, 117, 0, 0, 1634, 1635, 5, 110, 0, 0, 1635, 1636, 5, 100, 0, 0, 1636, 1637, 5, 101, 0, 0, 1637, 1638, 5, 102, 0, 0, 1638, 1639, 1, 0, 0, 0, 1639, 1640, 6, 186, 16, 0, 1640, 378, 1, 0, 0, 0, 1641, 1642, 5, 105, 0, 0, 1642, 1643, 5, 102, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, 6, 187, 16, 0, 1645, 1646, 6, 187, 19, 0, 1646, 380, 1, 0, 0, 0, 1647, 1648, 5, 101, 0, 0, 1648, 1649, 5, 108, 0, 0, 1649, 1650, 5, 105, 0, 0, 1650, 1651, 5, 102, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1653, 6, 188, 16, 0, 1653, 382, 1, 0, 0, 0, 1654, 1655, 5, 101, 0, 0, 1655, 1656, 5, 108, 0, 0, 1656, 1657, 5, 115, 0, 0, 1657, 1658, 5, 101, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1660, 6, 189, 16, 0, 1660, 1661, 6, 189, 20, 0, 1661, 384, 1, 0, 0, 0, 1662, 1663, 5, 101, 0, 0, 1663, 1664, 5, 110, 0, 0, 1664, 1665, 5, 100, 0, 0, 1665, 1666, 5, 105, 0, 0, 1666, 1667, 5, 102, 0, 0, 1667, 1668, 1, 0, 0, 0, 1668, 1669, 6, 190, 16, 0, 1669, 386, 1, 0, 0, 0, 1670, 1671, 5, 108, 0, 0, 1671, 1672, 5, 105, 0, 0, 1672, 1673, 5, 110, 0, 0, 1673, 1674, 5, 101, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 6, 191, 16, 0, 1676, 388, 1, 0, 0, 0, 1677, 1678, 5, 101, 0, 0, 1678, 1679, 5, 114, 0, 0, 1679, 1680, 5, 114, 0, 0, 1680, 1681, 5, 111, 0, 0, 1681, 1682, 5, 114, 0, 0, 1682, 1684, 1, 0, 0, 0, 1683, 1685, 3, 447, 221, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1684, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 1689, 6, 192, 16, 0, 1689, 1690, 6, 192, 21, 0, 1690, 390, 1, 0, 0, 0, 1691, 1692, 5, 119, 0, 0, 1692, 1693, 5, 97, 0, 0, 1693, 1694, 5, 114, 0, 0, 1694, 1695, 5, 110, 0, 0, 1695, 1696, 5, 105, 0, 0, 1696, 1697, 5, 110, 0, 0, 1697, 1698, 5, 103, 0, 0, 1698, 1700, 1, 0, 0, 0, 1699, 1701, 3, 447, 221, 0, 1700, 1699, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0, 1702, 1700, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1704, 1, 0, 0, 0, 1704, 1705, 6, 193, 16, 0, 1705, 1706, 6, 193, 21, 0, 1706, 392, 1, 0, 0, 0, 1707, 1708, 5, 114, 0, 0, 1708, 1709, 5, 101, 0, 0, 1709, 1710, 5, 103, 0, 0, 1710, 1711, 5, 105, 0, 0, 1711, 1712, 5, 111, 0, 0, 1712, 1713, 5, 110, 0, 0, 1713, 1717, 1, 0, 0, 0, 1714, 1716, 3, 447, 221, 0, 1715, 1714, 1, 0, 0, 0, 1716, 1719, 1, 0, 0, 0, 1717, 1715, 1, 0, 0, 0, 1717, 1718, 1, 0, 0, 0, 1718, 1720, 1, 0, 0, 0, 1719, 1717, 1, 0, 0, 0, 1720, 1721, 6, 194, 16, 0, 1721, 1722, 6, 194, 21, 0, 1722, 394, 1, 0, 0, 0, 1723, 1724, 5, 101, 0, 0, 1724, 1725, 5, 110, 0, 0, 1725, 1726, 5, 100, 0, 0, 1726, 1727, 5, 114, 0, 0, 1727, 1728, 5, 101, 0, 0, 1728, 1729, 5, 103, 0, 0, 1729, 1730, 5, 105, 0, 0, 1730, 1731, 5, 111, 0, 0, 1731, 1732, 5, 110, 0, 0, 1732, 1736, 1, 0, 0, 0, 1733, 1735, 3, 447, 221, 0, 1734, 1733, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1734, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1739, 1, 0, 0, 0, 1738, 1736, 1, 0, 0, 0, 1739, 1740, 6, 195, 16, 0, 1740, 1741, 6, 195, 21, 0, 1741, 396, 1, 0, 0, 0, 1742, 1743, 5, 112, 0, 0, 1743, 1744, 5, 114, 0, 0, 1744, 1745, 5, 97, 0, 0, 1745, 1746, 5, 103, 0, 0, 1746, 1747, 5, 109, 0, 0, 1747, 1748, 5, 97, 0, 0, 1748, 1750, 1, 0, 0, 0, 1749, 1751, 3, 447, 221, 0, 1750, 1749, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1754, 1, 0, 0, 0, 1754, 1755, 6, 196, 16, 0, 1755, 1756, 6, 196, 21, 0, 1756, 398, 1, 0, 0, 0, 1757, 1758, 5, 110, 0, 0, 1758, 1759, 5, 117, 0, 0, 1759, 1760, 5, 108, 0, 0, 1760, 1761, 5, 108, 0, 0, 1761, 1762, 5, 97, 0, 0, 1762, 1763, 5, 98, 0, 0, 1763, 1764, 5, 108, 0, 0, 1764, 1765, 5, 101, 0, 0, 1765, 1767, 1, 0, 0, 0, 1766, 1768, 3, 447, 221, 0, 1767, 1766, 1, 0, 0, 0, 1768, 1769, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 1772, 6, 197, 16, 0, 1772, 1773, 6, 197, 21, 0, 1773, 400, 1, 0, 0, 0, 1774, 1775, 5, 100, 0, 0, 1775, 1776, 5, 101, 0, 0, 1776, 1777, 5, 102, 0, 0, 1777, 1778, 5, 97, 0, 0, 1778, 1779, 5, 117, 0, 0, 1779, 1780, 5, 108, 0, 0, 1780, 1781, 5, 116, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 1783, 6, 198, 16, 0, 1783, 1784, 6, 198, 22, 0, 1784, 402, 1, 0, 0, 0, 1785, 1786, 5, 104, 0, 0, 1786, 1787, 5, 105, 0, 0, 1787, 1788, 5, 100, 0, 0, 1788, 1789, 5, 100, 0, 0, 1789, 1790, 5, 101, 0, 0, 1790, 1791, 5, 110, 0, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1793, 6, 199, 16, 0, 1793, 404, 1, 0, 0, 0, 1794, 1795, 5, 40, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 6, 200, 16, 0, 1797, 1798, 6, 200, 23, 0, 1798, 406, 1, 0, 0, 0, 1799, 1800, 5, 41, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 1802, 6, 201, 16, 0, 1802, 1803, 6, 201, 24, 0, 1803, 408, 1, 0, 0, 0, 1804, 1805, 5, 33, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1807, 6, 202, 16, 0, 1807, 1808, 6, 202, 25, 0, 1808, 410, 1, 0, 0, 0, 1809, 1810, 5, 61, 0, 0, 1810, 1811, 5, 61, 0, 0, 1811, 1812, 1, 0, 0, 0, 1812, 1813, 6, 203, 16, 0, 1813, 1814, 6, 203, 26, 0, 1814, 412, 1, 0, 0, 0, 1815, 1816, 5, 33, 0, 0, 1816, 1817, 5, 61, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1819, 6, 204, 16, 0, 1819, 1820, 6, 204, 27, 0, 1820, 414, 1, 0, 0, 0, 1821, 1822, 5, 38, 0, 0, 1822, 1823, 5, 38, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 6, 205, 16, 0, 1825, 1826, 6, 205, 28, 0, 1826, 416, 1, 0, 0, 0, 1827, 1828, 5, 124, 0, 0, 1828, 1829, 5, 124, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1831, 6, 206, 16, 0, 1831, 1832, 6, 206, 29, 0, 1832, 418, 1, 0, 0, 0, 1833, 1837, 5, 34, 0, 0, 1834, 1836, 8, 12, 0, 0, 1835, 1834, 1, 0, 0, 0, 1836, 1839, 1, 0, 0, 0, 1837, 1835, 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838, 1840, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1841, 5, 34, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1843, 6, 207, 16, 0, 1843, 1844, 6, 207, 30, 0, 1844, 420, 1, 0, 0, 0, 1845, 1846, 3, 451, 223, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1848, 6, 208, 16, 0, 1848, 422, 1, 0, 0, 0, 1849, 1850, 5, 47, 0, 0, 1850, 1851, 5, 47, 0, 0, 1851, 1855, 1, 0, 0, 0, 1852, 1854, 8, 13, 0, 0, 1853, 1852, 1, 0, 0, 0, 1854, 1857, 1, 0, 0, 0, 1855, 1853, 1, 0, 0, 0, 1855, 1856, 1, 0, 0, 0, 1856, 1858, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1858, 1859, 6, 209, 0, 0, 1859, 1860, 6, 209, 31, 0, 1860, 424, 1, 0, 0, 0, 1861, 1862, 3, 445, 220, 0, 1862, 1863, 1, 0, 0, 0, 1863, 1864, 6, 210, 16, 0, 1864, 1865, 6, 210, 32, 0, 1865, 426, 1, 0, 0, 0, 1866, 1868, 8, 13, 0, 0, 1867, 1866, 1, 0, 0, 0, 1868, 1869, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1872, 6, 211, 16, 0, 1872, 428, 1, 0, 0, 0, 1873, 1874, 3, 445, 220, 0, 1874, 1875, 1, 0, 0, 0, 1875, 1876, 6, 212, 16, 0, 1876, 1877, 6, 212, 33, 0, 1877, 1878, 6, 212, 32, 0, 1878, 430, 1, 0, 0, 0, 1879, 1880, 8, 13, 0, 0, 1880, 432, 1, 0, 0, 0, 1881, 1882, 7, 13, 0, 0, 1882, 434, 1, 0, 0, 0, 1883, 1885, 7, 14, 0, 0, 1884, 1883, 1, 0, 0, 0, 1884, 1885, 1, 0, 0, 0, 1885, 1886, 1, 0, 0, 0, 1886, 1892, 7, 15, 0, 0, 1887, 1889, 7, 15, 0, 0, 1888, 1887, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1892, 7, 14, 0, 0, 1891, 1884, 1, 0, 0, 0, 1891, 1888, 1, 0, 0, 0, 1892, 436, 1, 0, 0, 0, 1893, 1895, 7, 16, 0, 0, 1894, 1896, 7, 17, 0, 0, 1895, 1894, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1897, 1, 0, 0, 0, 1897, 1907, 7, 1, 0, 0, 1898, 1900, 5, 95, 0, 0, 1899, 1898, 1, 0, 0, 0, 1900, 1903, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1904, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1904, 1906, 7, 1, 0, 0, 1905, 1901, 1, 0, 0, 0, 1906, 1909, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1907, 1908, 1, 0, 0, 0, 1908, 438, 1, 0, 0, 0, 1909, 1907, 1, 0, 0, 0, 1910, 1914, 3, 441, 218, 0, 1911, 1914, 3, 443, 219, 0, 1912, 1914, 3, 467, 231, 0, 1913, 1910, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1912, 1, 0, 0, 0, 1914, 440, 1, 0, 0, 0, 1915, 1916, 5, 92, 0, 0, 1916, 1938, 5, 39, 0, 0, 1917, 1918, 5, 92, 0, 0, 1918, 1938, 5, 34, 0, 0, 1919, 1920, 5, 92, 0, 0, 1920, 1938, 5, 92, 0, 0, 1921, 1922, 5, 92, 0, 0, 1922, 1938, 5, 48, 0, 0, 1923, 1924, 5, 92, 0, 0, 1924, 1938, 5, 97, 0, 0, 1925, 1926, 5, 92, 0, 0, 1926, 1938, 5, 98, 0, 0, 1927, 1928, 5, 92, 0, 0, 1928, 1938, 5, 102, 0, 0, 1929, 1930, 5, 92, 0, 0, 1930, 1938, 5, 110, 0, 0, 1931, 1932, 5, 92, 0, 0, 1932, 1938, 5, 114, 0, 0, 1933, 1934, 5, 92, 0, 0, 1934, 1938, 5, 116, 0, 0, 1935, 1936, 5, 92, 0, 0, 1936, 1938, 5, 118, 0, 0, 1937, 1915, 1, 0, 0, 0, 1937, 1917, 1, 0, 0, 0, 1937, 1919, 1, 0, 0, 0, 1937, 1921, 1, 0, 0, 0, 1937, 1923, 1, 0, 0, 0, 1937, 1925, 1, 0, 0, 0, 1937, 1927, 1, 0, 0, 0, 1937, 1929, 1, 0, 0, 0, 1937, 1931, 1, 0, 0, 0, 1937, 1933, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1938, 442, 1, 0, 0, 0, 1939, 1940, 5, 92, 0, 0, 1940, 1941, 5, 120, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1965, 3, 469, 232, 0, 1943, 1944, 5, 92, 0, 0, 1944, 1945, 5, 120, 0, 0, 1945, 1946, 1, 0, 0, 0, 1946, 1947, 3, 469, 232, 0, 1947, 1948, 3, 469, 232, 0, 1948, 1965, 1, 0, 0, 0, 1949, 1950, 5, 92, 0, 0, 1950, 1951, 5, 120, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1953, 3, 469, 232, 0, 1953, 1954, 3, 469, 232, 0, 1954, 1955, 3, 469, 232, 0, 1955, 1965, 1, 0, 0, 0, 1956, 1957, 5, 92, 0, 0, 1957, 1958, 5, 120, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 3, 469, 232, 0, 1960, 1961, 3, 469, 232, 0, 1961, 1962, 3, 469, 232, 0, 1962, 1963, 3, 469, 232, 0, 1963, 1965, 1, 0, 0, 0, 1964, 1939, 1, 0, 0, 0, 1964, 1943, 1, 0, 0, 0, 1964, 1949, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1965, 444, 1, 0, 0, 0, 1966, 1967, 5, 13, 0, 0, 1967, 1970, 5, 10, 0, 0, 1968, 1970, 7, 13, 0, 0, 1969, 1966, 1, 0, 0, 0, 1969, 1968, 1, 0, 0, 0, 1970, 446, 1, 0, 0, 0, 1971, 1974, 3, 449, 222, 0, 1972, 1974, 7, 18, 0, 0, 1973, 1971, 1, 0, 0, 0, 1973, 1972, 1, 0, 0, 0, 1974, 448, 1, 0, 0, 0, 1975, 1976, 7, 19, 0, 0, 1976, 450, 1, 0, 0, 0, 1977, 1981, 3, 453, 224, 0, 1978, 1980, 3, 455, 225, 0, 1979, 1978, 1, 0, 0, 0, 1980, 1983, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982, 452, 1, 0, 0, 0, 1983, 1981, 1, 0, 0, 0, 1984, 1987, 3, 457, 226, 0, 1985, 1987, 5, 95, 0, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1985, 1, 0, 0, 0, 1987, 454, 1, 0, 0, 0, 1988, 1994, 3, 457, 226, 0, 1989, 1994, 3, 459, 227, 0, 1990, 1994, 3, 461, 228, 0, 1991, 1994, 3, 463, 229, 0, 1992, 1994, 3, 465, 230, 0, 1993, 1988, 1, 0, 0, 0, 1993, 1989, 1, 0, 0, 0, 1993, 1990, 1, 0, 0, 0, 1993, 1991, 1, 0, 0, 0, 1993, 1992, 1, 0, 0, 0, 1994, 456, 1, 0, 0, 0, 1995, 2003, 3, 471, 233, 0, 1996, 2003, 3, 473, 234, 0, 1997, 2003, 3, 475, 235, 0, 1998, 2003, 3, 477, 236, 0, 1999, 2003, 3, 479, 237, 0, 2000, 2003, 3, 481, 238, 0, 2001, 2003, 3, 467, 231, 0, 2002, 1995, 1, 0, 0, 0, 2002, 1996, 1, 0, 0, 0, 2002, 1997, 1, 0, 0, 0, 2002, 1998, 1, 0, 0, 0, 2002, 1999, 1, 0, 0, 0, 2002, 2000, 1, 0, 0, 0, 2002, 2001, 1, 0, 0, 0, 2003, 458, 1, 0, 0, 0, 2004, 2007, 3, 491, 243, 0, 2005, 2007, 3, 467, 231, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2005, 1, 0, 0, 0, 2007, 460, 1, 0, 0, 0, 2008, 2011, 3, 489, 242, 0, 2009, 2011, 3, 467, 231, 0, 2010, 2008, 1, 0, 0, 0, 2010, 2009, 1, 0, 0, 0, 2011, 462, 1, 0, 0, 0, 2012, 2016, 3, 483, 239, 0, 2013, 2016, 3, 485, 240, 0, 2014, 2016, 3, 467, 231, 0, 2015, 2012, 1, 0, 0, 0, 2015, 2013, 1, 0, 0, 0, 2015, 2014, 1, 0, 0, 0, 2016, 464, 1, 0, 0, 0, 2017, 2020, 3, 487, 241, 0, 2018, 2020, 3, 467, 231, 0, 2019, 2017, 1, 0, 0, 0, 2019, 2018, 1, 0, 0, 0, 2020, 466, 1, 0, 0, 0, 2021, 2022, 5, 92, 0, 0, 2022, 2023, 5, 117, 0, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2025, 3, 469, 232, 0, 2025, 2026, 3, 469, 232, 0, 2026, 2027, 3, 469, 232, 0, 2027, 2028, 3, 469, 232, 0, 2028, 2042, 1, 0, 0, 0, 2029, 2030, 5, 92, 0, 0, 2030, 2031, 5, 85, 0, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2033, 3, 469, 232, 0, 2033, 2034, 3, 469, 232, 0, 2034, 2035, 3, 469, 232, 0, 2035, 2036, 3, 469, 232, 0, 2036, 2037, 3, 469, 232, 0, 2037, 2038, 3, 469, 232, 0, 2038, 2039, 3, 469, 232, 0, 2039, 2040, 3, 469, 232, 0, 2040, 2042, 1, 0, 0, 0, 2041, 2021, 1, 0, 0, 0, 2041, 2029, 1, 0, 0, 0, 2042, 468, 1, 0, 0, 0, 2043, 2045, 7, 20, 0, 0, 2044, 2043, 1, 0, 0, 0, 2045, 470, 1, 0, 0, 0, 2046, 2047, 7, 21, 0, 0, 2047, 472, 1, 0, 0, 0, 2048, 2049, 7, 22, 0, 0, 2049, 474, 1, 0, 0, 0, 2050, 2051, 7, 23, 0, 0, 2051, 476, 1, 0, 0, 0, 2052, 2053, 7, 24, 0, 0, 2053, 478, 1, 0, 0, 0, 2054, 2055, 7, 25, 0, 0, 2055, 480, 1, 0, 0, 0, 2056, 2057, 7, 26, 0, 0, 2057, 482, 1, 0, 0, 0, 2058, 2059, 2, 768, 784, 0, 2059, 484, 1, 0, 0, 0, 2060, 2061, 7, 27, 0, 0, 2061, 486, 1, 0, 0, 0, 2062, 2063, 7, 28, 0, 0, 2063, 488, 1, 0, 0, 0, 2064, 2065, 7, 29, 0, 0, 2065, 490, 1, 0, 0, 0, 2066, 2067, 7, 30, 0, 0, 2067, 492, 1, 0, 0, 0, 77, 0, 1, 2, 3, 4, 504, 525, 539, 550, 560, 562, 1246, 1254, 1260, 1264, 1268, 1276, 1282, 1286, 1293, 1299, 1302, 1309, 1315, 1318, 1324, 1330, 1333, 1340, 1346, 1350, 1353, 1359, 1365, 1371, 1373, 1375, 1380, 1387, 1389, 1400, 1402, 1569, 1575, 1591, 1596, 1603, 1686, 1702, 1717, 1736, 1752, 1769, 1837, 1855, 1869, 1884, 1888, 1891, 1895, 1901, 1907, 1913, 1937, 1964, 1969, 1973, 1981, 1986, 1993, 2002, 2006, 2010, 2015, 2019, 2041, 2044, 34, 0, 2, 0, 0, 1, 0, 2, 3, 0, 1, 122, 0, 5, 1, 0, 1, 123, 1, 1, 124, 2, 1, 125, 3, 1, 132, 4, 1, 172, 5, 6, 0, 0, 5, 0, 0, 1, 175, 6, 4, 0, 0, 7, 180, 0, 1, 179, 7, 0, 3, 0, 7, 96, 0, 7, 42, 0, 7, 52, 0, 7, 36, 0, 2, 4, 0, 7, 30, 0, 7, 129, 0, 7, 130, 0, 7, 143, 0, 7, 156, 0, 7, 157, 0, 7, 153, 0, 7, 154, 0, 7, 91, 0, 7, 5, 0, 2, 0, 0, 7, 196, 0] \ No newline at end of file diff --git a/src/main/java/CSharpLexer.java b/src/main/java/CSharpLexer.java new file mode 100644 index 0000000..add9731 --- /dev/null +++ b/src/main/java/CSharpLexer.java @@ -0,0 +1,1884 @@ +// Generated from CSharpLexer.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; + +import java.util.Stack; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class CSharpLexer extends Lexer { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + BYTE_ORDER_MARK = 1, SINGLE_LINE_DOC_COMMENT = 2, EMPTY_DELIMITED_DOC_COMMENT = 3, + DELIMITED_DOC_COMMENT = 4, SINGLE_LINE_COMMENT = 5, DELIMITED_COMMENT = 6, WHITESPACES = 7, + SHARP = 8, ABSTRACT = 9, ADD = 10, ALIAS = 11, ARGLIST = 12, AS = 13, ASCENDING = 14, + ASYNC = 15, AWAIT = 16, BASE = 17, BOOL = 18, BREAK = 19, BY = 20, BYTE = 21, CASE = 22, + CATCH = 23, CHAR = 24, CHECKED = 25, CLASS = 26, CONST = 27, CONTINUE = 28, DECIMAL = 29, + DEFAULT = 30, DELEGATE = 31, DESCENDING = 32, DO = 33, DOUBLE = 34, DYNAMIC = 35, + ELSE = 36, ENUM = 37, EQUALS = 38, EVENT = 39, EXPLICIT = 40, EXTERN = 41, FALSE = 42, + FINALLY = 43, FIXED = 44, FLOAT = 45, FOR = 46, FOREACH = 47, FROM = 48, GET = 49, GOTO = 50, + GROUP = 51, IF = 52, IMPLICIT = 53, IN = 54, INT = 55, INTERFACE = 56, INTERNAL = 57, + INTO = 58, IS = 59, JOIN = 60, LET = 61, LOCK = 62, LONG = 63, NAMEOF = 64, NAMESPACE = 65, + NEW = 66, NULL = 67, OBJECT = 68, ON = 69, OPERATOR = 70, ORDERBY = 71, OUT = 72, OVERRIDE = 73, + PARAMS = 74, PARTIAL = 75, PRIVATE = 76, PROTECTED = 77, PUBLIC = 78, READONLY = 79, + REF = 80, REMOVE = 81, RETURN = 82, SBYTE = 83, SEALED = 84, SELECT = 85, SET = 86, + SHORT = 87, SIZEOF = 88, STACKALLOC = 89, STATIC = 90, STRING = 91, STRUCT = 92, SWITCH = 93, + THIS = 94, THROW = 95, TRUE = 96, TRY = 97, TYPEOF = 98, UINT = 99, ULONG = 100, UNCHECKED = 101, + UNMANAGED = 102, UNSAFE = 103, USHORT = 104, USING = 105, VAR = 106, VIRTUAL = 107, + VOID = 108, VOLATILE = 109, WHEN = 110, WHERE = 111, WHILE = 112, YIELD = 113, IDENTIFIER = 114, + LITERAL_ACCESS = 115, INTEGER_LITERAL = 116, HEX_INTEGER_LITERAL = 117, BIN_INTEGER_LITERAL = 118, + REAL_LITERAL = 119, CHARACTER_LITERAL = 120, REGULAR_STRING = 121, VERBATIUM_STRING = 122, + INTERPOLATED_REGULAR_STRING_START = 123, INTERPOLATED_VERBATIUM_STRING_START = 124, + OPEN_BRACE = 125, CLOSE_BRACE = 126, OPEN_BRACKET = 127, CLOSE_BRACKET = 128, + OPEN_PARENS = 129, CLOSE_PARENS = 130, DOT = 131, COMMA = 132, COLON = 133, SEMICOLON = 134, + PLUS = 135, MINUS = 136, STAR = 137, DIV = 138, PERCENT = 139, AMP = 140, BITWISE_OR = 141, + CARET = 142, BANG = 143, TILDE = 144, ASSIGNMENT = 145, LT = 146, GT = 147, INTERR = 148, + DOUBLE_COLON = 149, OP_COALESCING = 150, OP_INC = 151, OP_DEC = 152, OP_AND = 153, + OP_OR = 154, OP_PTR = 155, OP_EQ = 156, OP_NE = 157, OP_LE = 158, OP_GE = 159, OP_ADD_ASSIGNMENT = 160, + OP_SUB_ASSIGNMENT = 161, OP_MULT_ASSIGNMENT = 162, OP_DIV_ASSIGNMENT = 163, + OP_MOD_ASSIGNMENT = 164, OP_AND_ASSIGNMENT = 165, OP_OR_ASSIGNMENT = 166, OP_XOR_ASSIGNMENT = 167, + OP_LEFT_SHIFT = 168, OP_LEFT_SHIFT_ASSIGNMENT = 169, OP_COALESCING_ASSIGNMENT = 170, + OP_RANGE = 171, DOUBLE_CURLY_INSIDE = 172, OPEN_BRACE_INSIDE = 173, REGULAR_CHAR_INSIDE = 174, + VERBATIUM_DOUBLE_QUOTE_INSIDE = 175, DOUBLE_QUOTE_INSIDE = 176, REGULAR_STRING_INSIDE = 177, + VERBATIUM_INSIDE_STRING = 178, CLOSE_BRACE_INSIDE = 179, FORMAT_STRING = 180, + DIRECTIVE_WHITESPACES = 181, DIGITS = 182, DEFINE = 183, UNDEF = 184, ELIF = 185, + ENDIF = 186, LINE = 187, ERROR = 188, WARNING = 189, REGION = 190, ENDREGION = 191, + PRAGMA = 192, NULLABLE = 193, DIRECTIVE_HIDDEN = 194, CONDITIONAL_SYMBOL = 195, + DIRECTIVE_NEW_LINE = 196, TEXT = 197, DOUBLE_CURLY_CLOSE_INSIDE = 198; + public static final int + COMMENTS_CHANNEL = 2, DIRECTIVE = 3; + public static final int + INTERPOLATION_STRING = 1, INTERPOLATION_FORMAT = 2, DIRECTIVE_MODE = 3, DIRECTIVE_TEXT = 4; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "COMMENTS_CHANNEL", "DIRECTIVE" + }; + + public static String[] modeNames = { + "DEFAULT_MODE", "INTERPOLATION_STRING", "INTERPOLATION_FORMAT", "DIRECTIVE_MODE", + "DIRECTIVE_TEXT" + }; + + private static String[] makeRuleNames() { + return new String[]{ + "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "DOUBLE_CURLY_CLOSE_INSIDE", "CLOSE_BRACE_INSIDE", + "FORMAT_STRING", "DIRECTIVE_WHITESPACES", "DIGITS", "DIRECTIVE_TRUE", + "DIRECTIVE_FALSE", "DEFINE", "UNDEF", "DIRECTIVE_IF", "ELIF", "DIRECTIVE_ELSE", + "ENDIF", "LINE", "ERROR", "WARNING", "REGION", "ENDREGION", "PRAGMA", + "NULLABLE", "DIRECTIVE_DEFAULT", "DIRECTIVE_HIDDEN", "DIRECTIVE_OPEN_PARENS", + "DIRECTIVE_CLOSE_PARENS", "DIRECTIVE_BANG", "DIRECTIVE_OP_EQ", "DIRECTIVE_OP_NE", + "DIRECTIVE_OP_AND", "DIRECTIVE_OP_OR", "DIRECTIVE_STRING", "CONDITIONAL_SYMBOL", + "DIRECTIVE_SINGLE_LINE_COMMENT", "DIRECTIVE_NEW_LINE", "TEXT", "TEXT_NEW_LINE", + "InputCharacter", "NewLineCharacter", "IntegerTypeSuffix", "ExponentPart", + "CommonCharacter", "SimpleEscapeSequence", "HexEscapeSequence", "NewLine", + "Whitespace", "UnicodeClassZS", "IdentifierOrKeyword", "IdentifierStartCharacter", + "IdentifierPartCharacter", "LetterCharacter", "DecimalDigitCharacter", + "ConnectingCharacter", "CombiningCharacter", "FormattingCharacter", "UnicodeEscapeSequence", + "HexDigit", "UnicodeClassLU", "UnicodeClassLL", "UnicodeClassLT", "UnicodeClassLM", + "UnicodeClassLO", "UnicodeClassNL", "UnicodeClassMN", "UnicodeClassMC", + "UnicodeClassCF", "UnicodeClassPC", "UnicodeClassND" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, "'\\u00EF\\u00BB\\u00BF'", null, "'/***/'", null, null, null, null, + "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", + "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", + "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", + "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", + "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", + "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", + "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", + "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", + "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", + "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", + "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", + "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", + "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", + "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", + "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", + "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", + "'yield'", null, null, null, null, null, null, null, null, null, null, + null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", + "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", + "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", + "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", + "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", + "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, + null, "'hidden'", null, null, null, "'}}'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", + "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", + "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", + "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + private int interpolatedStringLevel; + private Stack interpolatedVerbatiums = new Stack(); + private Stack curlyLevels = new Stack(); + private boolean verbatium; + + + public CSharpLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @Override + public String getGrammarFileName() { + return "CSharpLexer.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + public ATN getATN() { + return _ATN; + } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 122: + INTERPOLATED_REGULAR_STRING_START_action((RuleContext) _localctx, actionIndex); + break; + case 123: + INTERPOLATED_VERBATIUM_STRING_START_action((RuleContext) _localctx, actionIndex); + break; + case 124: + OPEN_BRACE_action((RuleContext) _localctx, actionIndex); + break; + case 125: + CLOSE_BRACE_action((RuleContext) _localctx, actionIndex); + break; + case 132: + COLON_action((RuleContext) _localctx, actionIndex); + break; + case 172: + OPEN_BRACE_INSIDE_action((RuleContext) _localctx, actionIndex); + break; + case 175: + DOUBLE_QUOTE_INSIDE_action((RuleContext) _localctx, actionIndex); + break; + case 179: + CLOSE_BRACE_INSIDE_action((RuleContext) _localctx, actionIndex); + break; + } + } + + private void INTERPOLATED_REGULAR_STRING_START_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + interpolatedStringLevel++; + interpolatedVerbatiums.push(false); + verbatium = false; + break; + } + } + + private void INTERPOLATED_VERBATIUM_STRING_START_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + interpolatedStringLevel++; + interpolatedVerbatiums.push(true); + verbatium = true; + break; + } + } + + private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + + if (interpolatedStringLevel > 0) { + curlyLevels.push(curlyLevels.pop() + 1); + } + break; + } + } + + private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + + if (interpolatedStringLevel > 0) { + curlyLevels.push(curlyLevels.pop() - 1); + if (curlyLevels.peek() == 0) { + curlyLevels.pop(); + skip(); + popMode(); + } + } + + break; + } + } + + private void COLON_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + + if (interpolatedStringLevel > 0) { + int ind = 1; + boolean switchToFormatString = true; + while ((char) _input.LA(ind) != '}') { + if (_input.LA(ind) == ':' || _input.LA(ind) == ')') { + switchToFormatString = false; + break; + } + ind++; + } + if (switchToFormatString) { + mode(INTERPOLATION_FORMAT); + } + } + + break; + } + } + + private void OPEN_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 5: + curlyLevels.push(1); + break; + } + } + + private void DOUBLE_QUOTE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 6: + interpolatedStringLevel--; + interpolatedVerbatiums.pop(); + verbatium = (interpolatedVerbatiums.size() > 0 ? interpolatedVerbatiums.peek() : false); + break; + } + } + + private void CLOSE_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 7: + curlyLevels.pop(); + break; + } + } + + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 173: + return REGULAR_CHAR_INSIDE_sempred((RuleContext) _localctx, predIndex); + case 174: + return VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred((RuleContext) _localctx, predIndex); + case 176: + return REGULAR_STRING_INSIDE_sempred((RuleContext) _localctx, predIndex); + case 177: + return VERBATIUM_INSIDE_STRING_sempred((RuleContext) _localctx, predIndex); + } + return true; + } + + private boolean REGULAR_CHAR_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return !verbatium; + } + return true; + } + + private boolean VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return verbatium; + } + return true; + } + + private boolean REGULAR_STRING_INSIDE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return !verbatium; + } + return true; + } + + private boolean VERBATIUM_INSIDE_STRING_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return verbatium; + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0000\u00c6\u0814\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff" + + "\uffff\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002" + + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002" + + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002" + + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002" + + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e" + + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011" + + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014" + + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017" + + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a" + + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d" + + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!" + + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002" + + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002" + + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002" + + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002" + + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002" + + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002" + + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002" + + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002" + + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002" + + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002" + + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002" + + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002" + + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002" + + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002" + + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002" + + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002" + + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002" + + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002" + + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f" + + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082" + + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085" + + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088" + + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b" + + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e" + + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091" + + "\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094" + + "\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097" + + "\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a" + + "\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d" + + "\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0" + + "\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3" + + "\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6" + + "\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9" + + "\u0002\u00aa\u0007\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac" + + "\u0002\u00ad\u0007\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af" + + "\u0002\u00b0\u0007\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2" + + "\u0002\u00b3\u0007\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5" + + "\u0002\u00b6\u0007\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8" + + "\u0002\u00b9\u0007\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb" + + "\u0002\u00bc\u0007\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be" + + "\u0002\u00bf\u0007\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1" + + "\u0002\u00c2\u0007\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4" + + "\u0002\u00c5\u0007\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7" + + "\u0002\u00c8\u0007\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca" + + "\u0002\u00cb\u0007\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd" + + "\u0002\u00ce\u0007\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0" + + "\u0002\u00d1\u0007\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3" + + "\u0002\u00d4\u0007\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6" + + "\u0002\u00d7\u0007\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9" + + "\u0002\u00da\u0007\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc" + + "\u0002\u00dd\u0007\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df" + + "\u0002\u00e0\u0007\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2" + + "\u0002\u00e3\u0007\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5" + + "\u0002\u00e6\u0007\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8" + + "\u0002\u00e9\u0007\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb" + + "\u0002\u00ec\u0007\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee" + + "\u0002\u00ef\u0007\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1" + + "\u0002\u00f2\u0007\u00f2\u0002\u00f3\u0007\u00f3\u0001\u0000\u0001\u0000" + + "\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001" + + "\u0001\u0001\u0005\u0001\u01f7\b\u0001\n\u0001\f\u0001\u01fa\t\u0001\u0001" + + "\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001" + + "\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003\u020c\b\u0003\n" + + "\u0003\f\u0003\u020f\t\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0005" + + "\u0004\u021a\b\u0004\n\u0004\f\u0004\u021d\t\u0004\u0001\u0004\u0001\u0004" + + "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u0225\b\u0005" + + "\n\u0005\f\u0005\u0228\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001" + + "\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0004\u0006\u0231\b\u0006\u000b" + + "\u0006\f\u0006\u0232\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001" + + "\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001" + + "\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001" + + "\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b" + + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b" + + "\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001" + + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e" + + "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f" + + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010" + + "\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011" + + "\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012" + + "\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014" + + "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015" + + "\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016" + + "\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017" + + "\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018" + + "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019" + + "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a" + + "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b" + + "\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b" + + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c" + + "\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d" + + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e" + + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e" + + "\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f" + + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f" + + "\u0001 \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001" + + "!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001" + + "%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001" + + "&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001" + + "\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001" + + ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001" + + "*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001" + + ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001" + + ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u0001" + + "/\u0001/\u0001/\u00010\u00010\u00010\u00010\u00011\u00011\u00011\u0001" + + "1\u00011\u00012\u00012\u00012\u00012\u00012\u00012\u00013\u00013\u0001" + + "3\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001" + + "5\u00015\u00015\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u0001" + + "7\u00017\u00017\u00017\u00017\u00017\u00017\u00018\u00018\u00018\u0001" + + "8\u00018\u00018\u00018\u00018\u00018\u00019\u00019\u00019\u00019\u0001" + + "9\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001<\u0001" + + "<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001" + + ">\u0001>\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001" + + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001" + + "A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001" + + "C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001E\u0001" + + "E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001" + + "F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001" + + "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001" + + "I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001" + + "J\u0001J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001" + + "K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001" + + "L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001N\u0001" + + "N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001" + + "O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001" + + "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001" + + "R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001" + + "V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0001" + + "W\u0001W\u0001W\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001" + + "X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001" + + "Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001" + + "[\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\" + + "\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001" + + "^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001_\u0001_\u0001`\u0001" + + "`\u0001`\u0001`\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001" + + "b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001c\u0001" + + "c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001" + + "d\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001" + + "e\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001" + + "g\u0001g\u0001g\u0001g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001" + + "h\u0001i\u0001i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001" + + "j\u0001j\u0001j\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001l\u0001" + + "l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001" + + "m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001" + + "o\u0001o\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001" + + "q\u0003q\u04df\bq\u0001q\u0001q\u0001r\u0001r\u0005r\u04e5\br\nr\fr\u04e8" + + "\tr\u0001r\u0005r\u04eb\br\nr\fr\u04ee\tr\u0001r\u0003r\u04f1\br\u0001" + + "r\u0001r\u0003r\u04f5\br\u0001r\u0001r\u0001s\u0001s\u0005s\u04fb\bs\n" + + "s\fs\u04fe\ts\u0001s\u0005s\u0501\bs\ns\fs\u0504\ts\u0001s\u0003s\u0507" + + "\bs\u0001t\u0001t\u0001t\u0005t\u050c\bt\nt\ft\u050f\tt\u0001t\u0004t" + + "\u0512\bt\u000bt\ft\u0513\u0001t\u0003t\u0517\bt\u0001u\u0001u\u0001u" + + "\u0005u\u051c\bu\nu\fu\u051f\tu\u0001u\u0004u\u0522\bu\u000bu\fu\u0523" + + "\u0001u\u0003u\u0527\bu\u0001v\u0001v\u0005v\u052b\bv\nv\fv\u052e\tv\u0001" + + "v\u0005v\u0531\bv\nv\fv\u0534\tv\u0003v\u0536\bv\u0001v\u0001v\u0001v" + + "\u0005v\u053b\bv\nv\fv\u053e\tv\u0001v\u0005v\u0541\bv\nv\fv\u0544\tv" + + "\u0001v\u0003v\u0547\bv\u0001v\u0003v\u054a\bv\u0001v\u0001v\u0005v\u054e" + + "\bv\nv\fv\u0551\tv\u0001v\u0005v\u0554\bv\nv\fv\u0557\tv\u0001v\u0001" + + "v\u0001v\u0003v\u055c\bv\u0003v\u055e\bv\u0003v\u0560\bv\u0001w\u0001" + + "w\u0001w\u0003w\u0565\bw\u0001w\u0001w\u0001x\u0001x\u0001x\u0005x\u056c" + + "\bx\nx\fx\u056f\tx\u0001x\u0001x\u0001y\u0001y\u0001y\u0001y\u0001y\u0001" + + "y\u0005y\u0579\by\ny\fy\u057c\ty\u0001y\u0001y\u0001z\u0001z\u0001z\u0001" + + "z\u0001z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001" + + "{\u0001{\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001~\u0001~\u0001" + + "\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0001" + + "\u0082\u0001\u0082\u0001\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0001" + + "\u0084\u0001\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0087\u0001" + + "\u0087\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089\u0001\u008a\u0001" + + "\u008a\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008d\u0001" + + "\u008d\u0001\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u0090\u0001" + + "\u0090\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0093\u0001" + + "\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0095\u0001\u0095\u0001" + + "\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0001" + + "\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009b\u0001\u009b\u0001" + + "\u009b\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009d\u0001\u009d\u0001" + + "\u009d\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001" + + "\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0001" + + "\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001" + + "\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001" + + "\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a7\u0001\u00a7\u0001" + + "\u00a7\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001" + + "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001" + + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001" + + "\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001" + + "\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00af\u0001\u00af\u0001" + + "\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0004\u00b0\u0620" + + "\b\u00b0\u000b\u00b0\f\u00b0\u0621\u0001\u00b1\u0001\u00b1\u0004\u00b1" + + "\u0626\b\u00b1\u000b\u00b1\f\u00b1\u0627\u0001\u00b2\u0001\u00b2\u0001" + + "\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001" + + "\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b4\u0004\u00b4\u0636\b\u00b4\u000b" + + "\u00b4\f\u00b4\u0637\u0001\u00b5\u0004\u00b5\u063b\b\u00b5\u000b\u00b5" + + "\f\u00b5\u063c\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0004\u00b6\u0642\b" + + "\u00b6\u000b\u00b6\f\u00b6\u0643\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001" + + "\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001" + + "\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001" + + "\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001" + + "\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001" + + "\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001" + + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001" + + "\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bd\u0001\u00bd\u0001" + + "\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001" + + "\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001" + + "\u00be\u0001\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001" + + "\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001" + + "\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0004\u00c0\u0695\b\u00c0\u000b" + + "\u00c0\f\u00c0\u0696\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c1\u0001" + + "\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001" + + "\u00c1\u0001\u00c1\u0004\u00c1\u06a5\b\u00c1\u000b\u00c1\f\u00c1\u06a6" + + "\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2" + + "\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0005\u00c2" + + "\u06b4\b\u00c2\n\u00c2\f\u00c2\u06b7\t\u00c2\u0001\u00c2\u0001\u00c2\u0001" + + "\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001" + + "\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0005" + + "\u00c3\u06c7\b\u00c3\n\u00c3\f\u00c3\u06ca\t\u00c3\u0001\u00c3\u0001\u00c3" + + "\u0001\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4" + + "\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0004\u00c4\u06d7\b\u00c4\u000b\u00c4" + + "\f\u00c4\u06d8\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5" + + "\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5" + + "\u0001\u00c5\u0001\u00c5\u0004\u00c5\u06e8\b\u00c5\u000b\u00c5\f\u00c5" + + "\u06e9\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6\u0001\u00c6\u0001" + + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001" + + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001" + + "\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001" + + "\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c9\u0001" + + "\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00ca\u0001\u00ca\u0001" + + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001" + + "\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001" + + "\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001" + + "\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001" + + "\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00cf\u0001\u00cf\u0005\u00cf\u072c" + + "\b\u00cf\n\u00cf\f\u00cf\u072f\t\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf" + + "\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0" + + "\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0005\u00d1\u073e\b\u00d1" + + "\n\u00d1\f\u00d1\u0741\t\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001" + + "\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0004" + + "\u00d3\u074c\b\u00d3\u000b\u00d3\f\u00d3\u074d\u0001\u00d3\u0001\u00d3" + + "\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4" + + "\u0001\u00d5\u0001\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d7\u0003\u00d7" + + "\u075d\b\u00d7\u0001\u00d7\u0001\u00d7\u0003\u00d7\u0761\b\u00d7\u0001" + + "\u00d7\u0003\u00d7\u0764\b\u00d7\u0001\u00d8\u0001\u00d8\u0003\u00d8\u0768" + + "\b\u00d8\u0001\u00d8\u0001\u00d8\u0005\u00d8\u076c\b\u00d8\n\u00d8\f\u00d8" + + "\u076f\t\u00d8\u0001\u00d8\u0005\u00d8\u0772\b\u00d8\n\u00d8\f\u00d8\u0775" + + "\t\u00d8\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0003\u00d9\u077a\b\u00d9" + + "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da" + + "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da" + + "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da" + + "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0003\u00da\u0792\b\u00da" + + "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db" + + "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db" + + "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db" + + "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db" + + "\u0001\u00db\u0003\u00db\u07ad\b\u00db\u0001\u00dc\u0001\u00dc\u0001\u00dc" + + "\u0003\u00dc\u07b2\b\u00dc\u0001\u00dd\u0001\u00dd\u0003\u00dd\u07b6\b" + + "\u00dd\u0001\u00de\u0001\u00de\u0001\u00df\u0001\u00df\u0005\u00df\u07bc" + + "\b\u00df\n\u00df\f\u00df\u07bf\t\u00df\u0001\u00e0\u0001\u00e0\u0003\u00e0" + + "\u07c3\b\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1" + + "\u0003\u00e1\u07ca\b\u00e1\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2" + + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u07d3\b\u00e2\u0001\u00e3" + + "\u0001\u00e3\u0003\u00e3\u07d7\b\u00e3\u0001\u00e4\u0001\u00e4\u0003\u00e4" + + "\u07db\b\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0003\u00e5\u07e0\b" + + "\u00e5\u0001\u00e6\u0001\u00e6\u0003\u00e6\u07e4\b\u00e6\u0001\u00e7\u0001" + + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001" + + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001" + + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001" + + "\u00e7\u0003\u00e7\u07fa\b\u00e7\u0001\u00e8\u0003\u00e8\u07fd\b\u00e8" + + "\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00eb\u0001\u00eb" + + "\u0001\u00ec\u0001\u00ec\u0001\u00ed\u0001\u00ed\u0001\u00ee\u0001\u00ee" + + "\u0001\u00ef\u0001\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001\u00f1" + + "\u0001\u00f2\u0001\u00f2\u0001\u00f3\u0001\u00f3\u0002\u020d\u0226\u0000" + + "\u00f4\u0005\u0001\u0007\u0002\t\u0003\u000b\u0004\r\u0005\u000f\u0006" + + "\u0011\u0007\u0013\b\u0015\t\u0017\n\u0019\u000b\u001b\f\u001d\r\u001f" + + "\u000e!\u000f#\u0010%\u0011\'\u0012)\u0013+\u0014-\u0015/\u00161\u0017" + + "3\u00185\u00197\u001a9\u001b;\u001c=\u001d?\u001eA\u001fC E!G\"I#K$M%" + + "O&Q\'S(U)W*Y+[,]-_.a/c0e1g2i3k4m5o6q7s8u9w:y;{<}=\u007f>\u0081?\u0083" + + "@\u0085A\u0087B\u0089C\u008bD\u008dE\u008fF\u0091G\u0093H\u0095I\u0097" + + "J\u0099K\u009bL\u009dM\u009fN\u00a1O\u00a3P\u00a5Q\u00a7R\u00a9S\u00ab" + + "T\u00adU\u00afV\u00b1W\u00b3X\u00b5Y\u00b7Z\u00b9[\u00bb\\\u00bd]\u00bf" + + "^\u00c1_\u00c3`\u00c5a\u00c7b\u00c9c\u00cbd\u00cde\u00cff\u00d1g\u00d3" + + "h\u00d5i\u00d7j\u00d9k\u00dbl\u00ddm\u00dfn\u00e1o\u00e3p\u00e5q\u00e7" + + "r\u00e9s\u00ebt\u00edu\u00efv\u00f1w\u00f3x\u00f5y\u00f7z\u00f9{\u00fb" + + "|\u00fd}\u00ff~\u0101\u007f\u0103\u0080\u0105\u0081\u0107\u0082\u0109" + + "\u0083\u010b\u0084\u010d\u0085\u010f\u0086\u0111\u0087\u0113\u0088\u0115" + + "\u0089\u0117\u008a\u0119\u008b\u011b\u008c\u011d\u008d\u011f\u008e\u0121" + + "\u008f\u0123\u0090\u0125\u0091\u0127\u0092\u0129\u0093\u012b\u0094\u012d" + + "\u0095\u012f\u0096\u0131\u0097\u0133\u0098\u0135\u0099\u0137\u009a\u0139" + + "\u009b\u013b\u009c\u013d\u009d\u013f\u009e\u0141\u009f\u0143\u00a0\u0145" + + "\u00a1\u0147\u00a2\u0149\u00a3\u014b\u00a4\u014d\u00a5\u014f\u00a6\u0151" + + "\u00a7\u0153\u00a8\u0155\u00a9\u0157\u00aa\u0159\u00ab\u015b\u00ac\u015d" + + "\u00ad\u015f\u00ae\u0161\u00af\u0163\u00b0\u0165\u00b1\u0167\u00b2\u0169" + + "\u00c6\u016b\u00b3\u016d\u00b4\u016f\u00b5\u0171\u00b6\u0173\u0000\u0175" + + "\u0000\u0177\u00b7\u0179\u00b8\u017b\u0000\u017d\u00b9\u017f\u0000\u0181" + + "\u00ba\u0183\u00bb\u0185\u00bc\u0187\u00bd\u0189\u00be\u018b\u00bf\u018d" + + "\u00c0\u018f\u00c1\u0191\u0000\u0193\u00c2\u0195\u0000\u0197\u0000\u0199" + + "\u0000\u019b\u0000\u019d\u0000\u019f\u0000\u01a1\u0000\u01a3\u0000\u01a5" + + "\u00c3\u01a7\u0000\u01a9\u00c4\u01ab\u00c5\u01ad\u0000\u01af\u0000\u01b1" + + "\u0000\u01b3\u0000\u01b5\u0000\u01b7\u0000\u01b9\u0000\u01bb\u0000\u01bd" + + "\u0000\u01bf\u0000\u01c1\u0000\u01c3\u0000\u01c5\u0000\u01c7\u0000\u01c9" + + "\u0000\u01cb\u0000\u01cd\u0000\u01cf\u0000\u01d1\u0000\u01d3\u0000\u01d5" + + "\u0000\u01d7\u0000\u01d9\u0000\u01db\u0000\u01dd\u0000\u01df\u0000\u01e1" + + "\u0000\u01e3\u0000\u01e5\u0000\u01e7\u0000\u01e9\u0000\u01eb\u0000\u0005" + + "\u0000\u0001\u0002\u0003\u0004\u001f\u0001\u0000//\u0001\u000009\u0002" + + "\u0000XXxx\u0002\u0000BBbb\u0001\u000001\u0006\u0000DDFFMMddffmm\u0006" + + "\u0000\n\n\r\r\'\'\\\\\u0085\u0085\u2028\u2029\u0006\u0000\n\n\r\r\"\"" + + "\\\\\u0085\u0085\u2028\u2029\u0001\u0000\"\"\u0003\u0000\"\"\\\\{{\u0002" + + "\u0000\"\"{{\u0001\u0000}}\u0005\u0000\n\n\r\r\"\"\u0085\u0085\u2028\u2029" + + "\u0004\u0000\n\n\r\r\u0085\u0085\u2028\u2029\u0002\u0000LLll\u0002\u0000" + + "UUuu\u0002\u0000EEee\u0002\u0000++--\u0002\u0000\t\t\u000b\f\t\u0000 " + + " \u00a0\u00a0\u1680\u1680\u180e\u180e\u2000\u2006\u2008\u200a\u202f\u202f" + + "\u205f\u205f\u3000\u3000\u0003\u000009AFafR\u0000AZ\u00c0\u00d6\u00d8" + + "\u00de\u0100\u0136\u0139\u0147\u014a\u017d\u0181\u0182\u0184\u018b\u018e" + + "\u0191\u0193\u0194\u0196\u0198\u019c\u019d\u019f\u01a0\u01a2\u01a9\u01ac" + + "\u01b3\u01b5\u01bc\u01c4\u01cd\u01cf\u01db\u01de\u01ee\u01f1\u01f4\u01f6" + + "\u01f8\u01fa\u0232\u023a\u023b\u023d\u023e\u0241\u0246\u0248\u024e\u0370" + + "\u0372\u0376\u037f\u0386\u038a\u038c\u03a1\u03a3\u03ab\u03cf\u03d4\u03d8" + + "\u03ee\u03f4\u03f7\u03f9\u03fa\u03fd\u042f\u0460\u0480\u048a\u04cd\u04d0" + + "\u052e\u0531\u0556\u10a0\u10c5\u10c7\u10cd\u1e00\u1e94\u1e9e\u1efe\u1f08" + + "\u1f0f\u1f18\u1f1d\u1f28\u1f2f\u1f38\u1f3f\u1f48\u1f4d\u1f59\u1f5f\u1f68" + + "\u1f6f\u1fb8\u1fbb\u1fc8\u1fcb\u1fd8\u1fdb\u1fe8\u1fec\u1ff8\u1ffb\u2102" + + "\u2107\u210b\u210d\u2110\u2112\u2115\u211d\u2124\u212d\u2130\u2133\u213e" + + "\u213f\u2145\u2183\u2c00\u2c2e\u2c60\u2c64\u2c67\u2c70\u2c72\u2c75\u2c7e" + + "\u2c80\u2c82\u2ce2\u2ceb\u2ced\u2cf2\u8000\ua640\u8000\ua642\u8000\ua66c" + + "\u8000\ua680\u8000\ua69a\u8000\ua722\u8000\ua72e\u8000\ua732\u8000\ua76e" + + "\u8000\ua779\u8000\ua786\u8000\ua78b\u8000\ua78d\u8000\ua790\u8000\ua792" + + "\u8000\ua796\u8000\ua7ad\u8000\ua7b0\u8000\ua7b1\u8000\uff21\u8000\uff3a" + + "Q\u0000az\u00b5\u00f6\u00f8\u00ff\u0101\u0177\u017a\u0180\u0183\u0185" + + "\u0188\u0192\u0195\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01ad\u01b0\u01b4" + + "\u01b6\u01bf\u01c6\u01cc\u01ce\u01f3\u01f5\u01f9\u01fb\u0239\u023c\u0242" + + "\u0247\u0293\u0295\u02af\u0371\u0373\u0377\u037d\u0390\u03ce\u03d0\u03d1" + + "\u03d5\u03d7\u03d9\u03f3\u03f5\u045f\u0461\u0481\u048b\u04bf\u04c2\u052f" + + "\u0561\u0587\u1d00\u1d2b\u1d6b\u1d77\u1d79\u1d9a\u1e01\u1e9d\u1e9f\u1f07" + + "\u1f10\u1f15\u1f20\u1f27\u1f30\u1f37\u1f40\u1f45\u1f50\u1f57\u1f60\u1f67" + + "\u1f70\u1f7d\u1f80\u1f87\u1f90\u1f97\u1fa0\u1fa7\u1fb0\u1fb4\u1fb6\u1fb7" + + "\u1fbe\u1fc4\u1fc6\u1fc7\u1fd0\u1fd3\u1fd6\u1fd7\u1fe0\u1fe7\u1ff2\u1ff4" + + "\u1ff6\u1ff7\u210a\u2113\u212f\u2139\u213c\u213d\u2146\u2149\u214e\u2184" + + "\u2c30\u2c5e\u2c61\u2c6c\u2c71\u2c7b\u2c81\u2cec\u2cee\u2cf3\u2d00\u2d25" + + "\u2d27\u2d2d\u8000\ua641\u8000\ua66d\u8000\ua681\u8000\ua69b\u8000\ua723" + + "\u8000\ua731\u8000\ua733\u8000\ua778\u8000\ua77a\u8000\ua77c\u8000\ua77f" + + "\u8000\ua787\u8000\ua78c\u8000\ua78e\u8000\ua791\u8000\ua795\u8000\ua797" + + "\u8000\ua7a9\u8000\ua7fa\u8000\uab5a\u8000\uab64\u8000\uab65\u8000\ufb00" + + "\u8000\ufb06\u8000\ufb13\u8000\ufb17\u8000\uff41\u8000\uff5a\u0006\u0000" + + "\u01c5\u01cb\u01f2\u1f8f\u1f98\u1f9f\u1fa8\u1faf\u1fbc\u1fcc\u1ffc\u1ffc" + + "!\u0000\u02b0\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ee\u0374\u037a\u0559" + + "\u0640\u06e5\u06e6\u07f4\u07f5\u07fa\u081a\u0824\u0828\u0971\u0e46\u0ec6" + + "\u10fc\u17d7\u1843\u1aa7\u1c7d\u1d2c\u1d6a\u1d78\u1dbf\u2071\u207f\u2090" + + "\u209c\u2c7c\u2c7d\u2d6f\u2e2f\u3005\u3035\u303b\u30fe\u8000\ua015\u8000" + + "\ua4fd\u8000\ua60c\u8000\ua67f\u8000\ua69c\u8000\ua69d\u8000\ua717\u8000" + + "\ua71f\u8000\ua770\u8000\ua788\u8000\ua7f8\u8000\ua7f9\u8000\ua9cf\u8000" + + "\ua9e6\u8000\uaa70\u8000\uaadd\u8000\uaaf3\u8000\uaaf4\u8000\uab5c\u8000" + + "\uab5f\u8000\uff70\u8000\uff9f\u00ea\u0000\u00aa\u00ba\u01bb\u01c3\u0294" + + "\u05ea\u05f0\u05f2\u0620\u063f\u0641\u064a\u066e\u066f\u0671\u06d3\u06d5" + + "\u06fc\u06ff\u0710\u0712\u072f\u074d\u07a5\u07b1\u07ea\u0800\u0815\u0840" + + "\u0858\u08a0\u08b2\u0904\u0939\u093d\u0950\u0958\u0961\u0972\u0980\u0985" + + "\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b9\u09bd\u09ce\u09dc" + + "\u09dd\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a" + + "\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a74\u0a85" + + "\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd" + + "\u0ad0\u0ae0\u0ae1\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32" + + "\u0b33\u0b35\u0b39\u0b3d\u0b61\u0b71\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92" + + "\u0b95\u0b99\u0b9a\u0b9c\u0baa\u0bae\u0bb9\u0bd0\u0c0c\u0c0e\u0c10\u0c12" + + "\u0c28\u0c2a\u0c39\u0c3d\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5" + + "\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05\u0d0c\u0d0e\u0d10\u0d12" + + "\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3" + + "\u0dbb\u0dbd\u0dc6\u0e01\u0e30\u0e32\u0e33\u0e40\u0e45\u0e81\u0e82\u0e84" + + "\u0e8a\u0e8d\u0e97\u0e99\u0e9f\u0ea1\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead" + + "\u0eb0\u0eb2\u0eb3\u0ebd\u0ec4\u0edc\u0edf\u0f00\u0f47\u0f49\u0f6c\u0f88" + + "\u0f8c\u1000\u102a\u103f\u1055\u105a\u105d\u1061\u1070\u1075\u1081\u108e" + + "\u10fa\u10fd\u1248\u124a\u124d\u1250\u1256\u1258\u125d\u1260\u1288\u128a" + + "\u128d\u1290\u12b0\u12b2\u12b5\u12b8\u12be\u12c0\u12c5\u12c8\u12d6\u12d8" + + "\u1310\u1312\u1315\u1318\u135a\u1380\u138f\u13a0\u13f4\u1401\u166c\u166f" + + "\u167f\u1681\u169a\u16a0\u16ea\u16f1\u16f8\u1700\u170c\u170e\u1711\u1720" + + "\u1731\u1740\u1751\u1760\u176c\u176e\u1770\u1780\u17b3\u17dc\u1842\u1844" + + "\u1877\u1880\u18a8\u18aa\u18f5\u1900\u191e\u1950\u196d\u1970\u1974\u1980" + + "\u19ab\u19c1\u19c7\u1a00\u1a16\u1a20\u1a54\u1b05\u1b33\u1b45\u1b4b\u1b83" + + "\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d\u1c4f\u1c5a\u1c77\u1ce9" + + "\u1cec\u1cee\u1cf1\u1cf5\u1cf6\u2135\u2138\u2d30\u2d67\u2d80\u2d96\u2da0" + + "\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0" + + "\u2dd6\u2dd8\u2dde\u3006\u303c\u3041\u3096\u309f\u30fa\u30ff\u312d\u3131" + + "\u318e\u31a0\u31ba\u31f0\u31ff\u3400\u4db5\u4e00\u8000\u9fcc\u8000\ua000" + + "\u8000\ua014\u8000\ua016\u8000\ua48c\u8000\ua4d0\u8000\ua4f7\u8000\ua500" + + "\u8000\ua60b\u8000\ua610\u8000\ua61f\u8000\ua62a\u8000\ua62b\u8000\ua66e" + + "\u8000\ua6e5\u8000\ua7f7\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807" + + "\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882" + + "\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua925\u8000\ua930" + + "\u8000\ua946\u8000\ua960\u8000\ua97c\u8000\ua984\u8000\ua9b2\u8000\ua9e0" + + "\u8000\ua9e4\u8000\ua9e7\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00" + + "\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60" + + "\u8000\uaa6f\u8000\uaa71\u8000\uaa76\u8000\uaa7a\u8000\uaaaf\u8000\uaab1" + + "\u8000\uaabd\u8000\uaac0\u8000\uaac2\u8000\uaadb\u8000\uaadc\u8000\uaae0" + + "\u8000\uaaea\u8000\uaaf2\u8000\uab06\u8000\uab09\u8000\uab0e\u8000\uab11" + + "\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28\u8000\uab2e\u8000\uabc0" + + "\u8000\uabe2\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb" + + "\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb1d" + + "\u8000\ufb28\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e" + + "\u8000\ufbb1\u8000\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92" + + "\u8000\ufdc7\u8000\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76" + + "\u8000\ufefc\u8000\uff66\u8000\uff6f\u8000\uff71\u8000\uff9d\u8000\uffa0" + + "\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2" + + "\u8000\uffd7\u8000\uffda\u8000\uffdc\u0002\u0000\u16ee\u16f0\u2160\u216f" + + "\u0003\u0000\u0903\u0903\u093e\u0940\u0949\u094c\u0003\u0000\u00ad\u00ad" + + "\u0600\u0603\u06dd\u06dd\u0006\u0000__\u203f\u2040\u2054\u2054\u8000\ufe33" + + "\u8000\ufe34\u8000\ufe4d\u8000\ufe4f\u8000\uff3f\u8000\uff3f%\u000009" + + "\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f\u09e6\u09ef\u0a66\u0a6f" + + "\u0ae6\u0aef\u0b66\u0b6f\u0be6\u0bef\u0c66\u0c6f\u0ce6\u0cef\u0d66\u0d6f" + + "\u0de6\u0def\u0e50\u0e59\u0ed0\u0ed9\u0f20\u0f29\u1040\u1049\u1090\u1099" + + "\u17e0\u17e9\u1810\u1819\u1946\u194f\u19d0\u19d9\u1a80\u1a89\u1a90\u1a99" + + "\u1b50\u1b59\u1bb0\u1bb9\u1c40\u1c49\u1c50\u1c59\u8000\ua620\u8000\ua629" + + "\u8000\ua8d0\u8000\ua8d9\u8000\ua900\u8000\ua909\u8000\ua9d0\u8000\ua9d9" + + "\u8000\ua9f0\u8000\ua9f9\u8000\uaa50\u8000\uaa59\u8000\uabf0\u8000\uabf9" + + "\u8000\uff10\u8000\uff19\u084c\u0000\u0005\u0001\u0000\u0000\u0000\u0000" + + "\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b" + + "\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001" + + "\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001" + + "\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001" + + "\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001" + + "\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001" + + "\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000" + + "\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000" + + "\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-" + + "\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000" + + "\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000" + + "\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;" + + "\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000" + + "\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000" + + "\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I" + + "\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000" + + "\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000" + + "\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W" + + "\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000" + + "\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000" + + "\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e" + + "\u0001\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000" + + "\u0000\u0000\u0000k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000" + + "\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s" + + "\u0001\u0000\u0000\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000" + + "\u0000\u0000\u0000y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000" + + "\u0000}\u0001\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000" + + "\u0081\u0001\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000" + + "\u0085\u0001\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000" + + "\u0089\u0001\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000" + + "\u008d\u0001\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000" + + "\u0091\u0001\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000" + + "\u0095\u0001\u0000\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000" + + "\u0099\u0001\u0000\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000" + + "\u009d\u0001\u0000\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000" + + "\u00a1\u0001\u0000\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000" + + "\u00a5\u0001\u0000\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000" + + "\u00a9\u0001\u0000\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000" + + "\u00ad\u0001\u0000\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000" + + "\u00b1\u0001\u0000\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000" + + "\u00b5\u0001\u0000\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000" + + "\u00b9\u0001\u0000\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000" + + "\u00bd\u0001\u0000\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000" + + "\u00c1\u0001\u0000\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000" + + "\u00c5\u0001\u0000\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000" + + "\u00c9\u0001\u0000\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000" + + "\u00cd\u0001\u0000\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000" + + "\u00d1\u0001\u0000\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000" + + "\u00d5\u0001\u0000\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000" + + "\u00d9\u0001\u0000\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000" + + "\u00dd\u0001\u0000\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0000" + + "\u00e1\u0001\u0000\u0000\u0000\u0000\u00e3\u0001\u0000\u0000\u0000\u0000" + + "\u00e5\u0001\u0000\u0000\u0000\u0000\u00e7\u0001\u0000\u0000\u0000\u0000" + + "\u00e9\u0001\u0000\u0000\u0000\u0000\u00eb\u0001\u0000\u0000\u0000\u0000" + + "\u00ed\u0001\u0000\u0000\u0000\u0000\u00ef\u0001\u0000\u0000\u0000\u0000" + + "\u00f1\u0001\u0000\u0000\u0000\u0000\u00f3\u0001\u0000\u0000\u0000\u0000" + + "\u00f5\u0001\u0000\u0000\u0000\u0000\u00f7\u0001\u0000\u0000\u0000\u0000" + + "\u00f9\u0001\u0000\u0000\u0000\u0000\u00fb\u0001\u0000\u0000\u0000\u0000" + + "\u00fd\u0001\u0000\u0000\u0000\u0000\u00ff\u0001\u0000\u0000\u0000\u0000" + + "\u0101\u0001\u0000\u0000\u0000\u0000\u0103\u0001\u0000\u0000\u0000\u0000" + + "\u0105\u0001\u0000\u0000\u0000\u0000\u0107\u0001\u0000\u0000\u0000\u0000" + + "\u0109\u0001\u0000\u0000\u0000\u0000\u010b\u0001\u0000\u0000\u0000\u0000" + + "\u010d\u0001\u0000\u0000\u0000\u0000\u010f\u0001\u0000\u0000\u0000\u0000" + + "\u0111\u0001\u0000\u0000\u0000\u0000\u0113\u0001\u0000\u0000\u0000\u0000" + + "\u0115\u0001\u0000\u0000\u0000\u0000\u0117\u0001\u0000\u0000\u0000\u0000" + + "\u0119\u0001\u0000\u0000\u0000\u0000\u011b\u0001\u0000\u0000\u0000\u0000" + + "\u011d\u0001\u0000\u0000\u0000\u0000\u011f\u0001\u0000\u0000\u0000\u0000" + + "\u0121\u0001\u0000\u0000\u0000\u0000\u0123\u0001\u0000\u0000\u0000\u0000" + + "\u0125\u0001\u0000\u0000\u0000\u0000\u0127\u0001\u0000\u0000\u0000\u0000" + + "\u0129\u0001\u0000\u0000\u0000\u0000\u012b\u0001\u0000\u0000\u0000\u0000" + + "\u012d\u0001\u0000\u0000\u0000\u0000\u012f\u0001\u0000\u0000\u0000\u0000" + + "\u0131\u0001\u0000\u0000\u0000\u0000\u0133\u0001\u0000\u0000\u0000\u0000" + + "\u0135\u0001\u0000\u0000\u0000\u0000\u0137\u0001\u0000\u0000\u0000\u0000" + + "\u0139\u0001\u0000\u0000\u0000\u0000\u013b\u0001\u0000\u0000\u0000\u0000" + + "\u013d\u0001\u0000\u0000\u0000\u0000\u013f\u0001\u0000\u0000\u0000\u0000" + + "\u0141\u0001\u0000\u0000\u0000\u0000\u0143\u0001\u0000\u0000\u0000\u0000" + + "\u0145\u0001\u0000\u0000\u0000\u0000\u0147\u0001\u0000\u0000\u0000\u0000" + + "\u0149\u0001\u0000\u0000\u0000\u0000\u014b\u0001\u0000\u0000\u0000\u0000" + + "\u014d\u0001\u0000\u0000\u0000\u0000\u014f\u0001\u0000\u0000\u0000\u0000" + + "\u0151\u0001\u0000\u0000\u0000\u0000\u0153\u0001\u0000\u0000\u0000\u0000" + + "\u0155\u0001\u0000\u0000\u0000\u0000\u0157\u0001\u0000\u0000\u0000\u0000" + + "\u0159\u0001\u0000\u0000\u0000\u0001\u015b\u0001\u0000\u0000\u0000\u0001" + + "\u015d\u0001\u0000\u0000\u0000\u0001\u015f\u0001\u0000\u0000\u0000\u0001" + + "\u0161\u0001\u0000\u0000\u0000\u0001\u0163\u0001\u0000\u0000\u0000\u0001" + + "\u0165\u0001\u0000\u0000\u0000\u0001\u0167\u0001\u0000\u0000\u0000\u0002" + + "\u0169\u0001\u0000\u0000\u0000\u0002\u016b\u0001\u0000\u0000\u0000\u0002" + + "\u016d\u0001\u0000\u0000\u0000\u0003\u016f\u0001\u0000\u0000\u0000\u0003" + + "\u0171\u0001\u0000\u0000\u0000\u0003\u0173\u0001\u0000\u0000\u0000\u0003" + + "\u0175\u0001\u0000\u0000\u0000\u0003\u0177\u0001\u0000\u0000\u0000\u0003" + + "\u0179\u0001\u0000\u0000\u0000\u0003\u017b\u0001\u0000\u0000\u0000\u0003" + + "\u017d\u0001\u0000\u0000\u0000\u0003\u017f\u0001\u0000\u0000\u0000\u0003" + + "\u0181\u0001\u0000\u0000\u0000\u0003\u0183\u0001\u0000\u0000\u0000\u0003" + + "\u0185\u0001\u0000\u0000\u0000\u0003\u0187\u0001\u0000\u0000\u0000\u0003" + + "\u0189\u0001\u0000\u0000\u0000\u0003\u018b\u0001\u0000\u0000\u0000\u0003" + + "\u018d\u0001\u0000\u0000\u0000\u0003\u018f\u0001\u0000\u0000\u0000\u0003" + + "\u0191\u0001\u0000\u0000\u0000\u0003\u0193\u0001\u0000\u0000\u0000\u0003" + + "\u0195\u0001\u0000\u0000\u0000\u0003\u0197\u0001\u0000\u0000\u0000\u0003" + + "\u0199\u0001\u0000\u0000\u0000\u0003\u019b\u0001\u0000\u0000\u0000\u0003" + + "\u019d\u0001\u0000\u0000\u0000\u0003\u019f\u0001\u0000\u0000\u0000\u0003" + + "\u01a1\u0001\u0000\u0000\u0000\u0003\u01a3\u0001\u0000\u0000\u0000\u0003" + + "\u01a5\u0001\u0000\u0000\u0000\u0003\u01a7\u0001\u0000\u0000\u0000\u0003" + + "\u01a9\u0001\u0000\u0000\u0000\u0004\u01ab\u0001\u0000\u0000\u0000\u0004" + + "\u01ad\u0001\u0000\u0000\u0000\u0005\u01ed\u0001\u0000\u0000\u0000\u0007" + + "\u01f1\u0001\u0000\u0000\u0000\t\u01fd\u0001\u0000\u0000\u0000\u000b\u0205" + + "\u0001\u0000\u0000\u0000\r\u0215\u0001\u0000\u0000\u0000\u000f\u0220\u0001" + + "\u0000\u0000\u0000\u0011\u0230\u0001\u0000\u0000\u0000\u0013\u0236\u0001" + + "\u0000\u0000\u0000\u0015\u023a\u0001\u0000\u0000\u0000\u0017\u0243\u0001" + + "\u0000\u0000\u0000\u0019\u0247\u0001\u0000\u0000\u0000\u001b\u024d\u0001" + + "\u0000\u0000\u0000\u001d\u0257\u0001\u0000\u0000\u0000\u001f\u025a\u0001" + + "\u0000\u0000\u0000!\u0264\u0001\u0000\u0000\u0000#\u026a\u0001\u0000\u0000" + + "\u0000%\u0270\u0001\u0000\u0000\u0000\'\u0275\u0001\u0000\u0000\u0000" + + ")\u027a\u0001\u0000\u0000\u0000+\u0280\u0001\u0000\u0000\u0000-\u0283" + + "\u0001\u0000\u0000\u0000/\u0288\u0001\u0000\u0000\u00001\u028d\u0001\u0000" + + "\u0000\u00003\u0293\u0001\u0000\u0000\u00005\u0298\u0001\u0000\u0000\u0000" + + "7\u02a0\u0001\u0000\u0000\u00009\u02a6\u0001\u0000\u0000\u0000;\u02ac" + + "\u0001\u0000\u0000\u0000=\u02b5\u0001\u0000\u0000\u0000?\u02bd\u0001\u0000" + + "\u0000\u0000A\u02c5\u0001\u0000\u0000\u0000C\u02ce\u0001\u0000\u0000\u0000" + + "E\u02d9\u0001\u0000\u0000\u0000G\u02dc\u0001\u0000\u0000\u0000I\u02e3" + + "\u0001\u0000\u0000\u0000K\u02eb\u0001\u0000\u0000\u0000M\u02f0\u0001\u0000" + + "\u0000\u0000O\u02f5\u0001\u0000\u0000\u0000Q\u02fc\u0001\u0000\u0000\u0000" + + "S\u0302\u0001\u0000\u0000\u0000U\u030b\u0001\u0000\u0000\u0000W\u0312" + + "\u0001\u0000\u0000\u0000Y\u0318\u0001\u0000\u0000\u0000[\u0320\u0001\u0000" + + "\u0000\u0000]\u0326\u0001\u0000\u0000\u0000_\u032c\u0001\u0000\u0000\u0000" + + "a\u0330\u0001\u0000\u0000\u0000c\u0338\u0001\u0000\u0000\u0000e\u033d" + + "\u0001\u0000\u0000\u0000g\u0341\u0001\u0000\u0000\u0000i\u0346\u0001\u0000" + + "\u0000\u0000k\u034c\u0001\u0000\u0000\u0000m\u034f\u0001\u0000\u0000\u0000" + + "o\u0358\u0001\u0000\u0000\u0000q\u035b\u0001\u0000\u0000\u0000s\u035f" + + "\u0001\u0000\u0000\u0000u\u0369\u0001\u0000\u0000\u0000w\u0372\u0001\u0000" + + "\u0000\u0000y\u0377\u0001\u0000\u0000\u0000{\u037a\u0001\u0000\u0000\u0000" + + "}\u037f\u0001\u0000\u0000\u0000\u007f\u0383\u0001\u0000\u0000\u0000\u0081" + + "\u0388\u0001\u0000\u0000\u0000\u0083\u038d\u0001\u0000\u0000\u0000\u0085" + + "\u0394\u0001\u0000\u0000\u0000\u0087\u039e\u0001\u0000\u0000\u0000\u0089" + + "\u03a2\u0001\u0000\u0000\u0000\u008b\u03a7\u0001\u0000\u0000\u0000\u008d" + + "\u03ae\u0001\u0000\u0000\u0000\u008f\u03b1\u0001\u0000\u0000\u0000\u0091" + + "\u03ba\u0001\u0000\u0000\u0000\u0093\u03c2\u0001\u0000\u0000\u0000\u0095" + + "\u03c6\u0001\u0000\u0000\u0000\u0097\u03cf\u0001\u0000\u0000\u0000\u0099" + + "\u03d6\u0001\u0000\u0000\u0000\u009b\u03de\u0001\u0000\u0000\u0000\u009d" + + "\u03e6\u0001\u0000\u0000\u0000\u009f\u03f0\u0001\u0000\u0000\u0000\u00a1" + + "\u03f7\u0001\u0000\u0000\u0000\u00a3\u0400\u0001\u0000\u0000\u0000\u00a5" + + "\u0404\u0001\u0000\u0000\u0000\u00a7\u040b\u0001\u0000\u0000\u0000\u00a9" + + "\u0412\u0001\u0000\u0000\u0000\u00ab\u0418\u0001\u0000\u0000\u0000\u00ad" + + "\u041f\u0001\u0000\u0000\u0000\u00af\u0426\u0001\u0000\u0000\u0000\u00b1" + + "\u042a\u0001\u0000\u0000\u0000\u00b3\u0430\u0001\u0000\u0000\u0000\u00b5" + + "\u0437\u0001\u0000\u0000\u0000\u00b7\u0442\u0001\u0000\u0000\u0000\u00b9" + + "\u0449\u0001\u0000\u0000\u0000\u00bb\u0450\u0001\u0000\u0000\u0000\u00bd" + + "\u0457\u0001\u0000\u0000\u0000\u00bf\u045e\u0001\u0000\u0000\u0000\u00c1" + + "\u0463\u0001\u0000\u0000\u0000\u00c3\u0469\u0001\u0000\u0000\u0000\u00c5" + + "\u046e\u0001\u0000\u0000\u0000\u00c7\u0472\u0001\u0000\u0000\u0000\u00c9" + + "\u0479\u0001\u0000\u0000\u0000\u00cb\u047e\u0001\u0000\u0000\u0000\u00cd" + + "\u0484\u0001\u0000\u0000\u0000\u00cf\u048e\u0001\u0000\u0000\u0000\u00d1" + + "\u0498\u0001\u0000\u0000\u0000\u00d3\u049f\u0001\u0000\u0000\u0000\u00d5" + + "\u04a6\u0001\u0000\u0000\u0000\u00d7\u04ac\u0001\u0000\u0000\u0000\u00d9" + + "\u04b0\u0001\u0000\u0000\u0000\u00db\u04b8\u0001\u0000\u0000\u0000\u00dd" + + "\u04bd\u0001\u0000\u0000\u0000\u00df\u04c6\u0001\u0000\u0000\u0000\u00e1" + + "\u04cb\u0001\u0000\u0000\u0000\u00e3\u04d1\u0001\u0000\u0000\u0000\u00e5" + + "\u04d7\u0001\u0000\u0000\u0000\u00e7\u04de\u0001\u0000\u0000\u0000\u00e9" + + "\u04e2\u0001\u0000\u0000\u0000\u00eb\u04f8\u0001\u0000\u0000\u0000\u00ed" + + "\u0508\u0001\u0000\u0000\u0000\u00ef\u0518\u0001\u0000\u0000\u0000\u00f1" + + "\u055f\u0001\u0000\u0000\u0000\u00f3\u0561\u0001\u0000\u0000\u0000\u00f5" + + "\u0568\u0001\u0000\u0000\u0000\u00f7\u0572\u0001\u0000\u0000\u0000\u00f9" + + "\u057f\u0001\u0000\u0000\u0000\u00fb\u0586\u0001\u0000\u0000\u0000\u00fd" + + "\u058e\u0001\u0000\u0000\u0000\u00ff\u0591\u0001\u0000\u0000\u0000\u0101" + + "\u0594\u0001\u0000\u0000\u0000\u0103\u0596\u0001\u0000\u0000\u0000\u0105" + + "\u0598\u0001\u0000\u0000\u0000\u0107\u059a\u0001\u0000\u0000\u0000\u0109" + + "\u059c\u0001\u0000\u0000\u0000\u010b\u059e\u0001\u0000\u0000\u0000\u010d" + + "\u05a0\u0001\u0000\u0000\u0000\u010f\u05a3\u0001\u0000\u0000\u0000\u0111" + + "\u05a5\u0001\u0000\u0000\u0000\u0113\u05a7\u0001\u0000\u0000\u0000\u0115" + + "\u05a9\u0001\u0000\u0000\u0000\u0117\u05ab\u0001\u0000\u0000\u0000\u0119" + + "\u05ad\u0001\u0000\u0000\u0000\u011b\u05af\u0001\u0000\u0000\u0000\u011d" + + "\u05b1\u0001\u0000\u0000\u0000\u011f\u05b3\u0001\u0000\u0000\u0000\u0121" + + "\u05b5\u0001\u0000\u0000\u0000\u0123\u05b7\u0001\u0000\u0000\u0000\u0125" + + "\u05b9\u0001\u0000\u0000\u0000\u0127\u05bb\u0001\u0000\u0000\u0000\u0129" + + "\u05bd\u0001\u0000\u0000\u0000\u012b\u05bf\u0001\u0000\u0000\u0000\u012d" + + "\u05c1\u0001\u0000\u0000\u0000\u012f\u05c4\u0001\u0000\u0000\u0000\u0131" + + "\u05c7\u0001\u0000\u0000\u0000\u0133\u05ca\u0001\u0000\u0000\u0000\u0135" + + "\u05cd\u0001\u0000\u0000\u0000\u0137\u05d0\u0001\u0000\u0000\u0000\u0139" + + "\u05d3\u0001\u0000\u0000\u0000\u013b\u05d6\u0001\u0000\u0000\u0000\u013d" + + "\u05d9\u0001\u0000\u0000\u0000\u013f\u05dc\u0001\u0000\u0000\u0000\u0141" + + "\u05df\u0001\u0000\u0000\u0000\u0143\u05e2\u0001\u0000\u0000\u0000\u0145" + + "\u05e5\u0001\u0000\u0000\u0000\u0147\u05e8\u0001\u0000\u0000\u0000\u0149" + + "\u05eb\u0001\u0000\u0000\u0000\u014b\u05ee\u0001\u0000\u0000\u0000\u014d" + + "\u05f1\u0001\u0000\u0000\u0000\u014f\u05f4\u0001\u0000\u0000\u0000\u0151" + + "\u05f7\u0001\u0000\u0000\u0000\u0153\u05fa\u0001\u0000\u0000\u0000\u0155" + + "\u05fd\u0001\u0000\u0000\u0000\u0157\u0601\u0001\u0000\u0000\u0000\u0159" + + "\u0605\u0001\u0000\u0000\u0000\u015b\u0608\u0001\u0000\u0000\u0000\u015d" + + "\u060b\u0001\u0000\u0000\u0000\u015f\u0611\u0001\u0000\u0000\u0000\u0161" + + "\u0614\u0001\u0000\u0000\u0000\u0163\u0618\u0001\u0000\u0000\u0000\u0165" + + "\u061d\u0001\u0000\u0000\u0000\u0167\u0623\u0001\u0000\u0000\u0000\u0169" + + "\u0629\u0001\u0000\u0000\u0000\u016b\u062e\u0001\u0000\u0000\u0000\u016d" + + "\u0635\u0001\u0000\u0000\u0000\u016f\u063a\u0001\u0000\u0000\u0000\u0171" + + "\u0641\u0001\u0000\u0000\u0000\u0173\u0647\u0001\u0000\u0000\u0000\u0175" + + "\u064f\u0001\u0000\u0000\u0000\u0177\u0658\u0001\u0000\u0000\u0000\u0179" + + "\u0661\u0001\u0000\u0000\u0000\u017b\u0669\u0001\u0000\u0000\u0000\u017d" + + "\u066f\u0001\u0000\u0000\u0000\u017f\u0676\u0001\u0000\u0000\u0000\u0181" + + "\u067e\u0001\u0000\u0000\u0000\u0183\u0686\u0001\u0000\u0000\u0000\u0185" + + "\u068d\u0001\u0000\u0000\u0000\u0187\u069b\u0001\u0000\u0000\u0000\u0189" + + "\u06ab\u0001\u0000\u0000\u0000\u018b\u06bb\u0001\u0000\u0000\u0000\u018d" + + "\u06ce\u0001\u0000\u0000\u0000\u018f\u06dd\u0001\u0000\u0000\u0000\u0191" + + "\u06ee\u0001\u0000\u0000\u0000\u0193\u06f9\u0001\u0000\u0000\u0000\u0195" + + "\u0702\u0001\u0000\u0000\u0000\u0197\u0707\u0001\u0000\u0000\u0000\u0199" + + "\u070c\u0001\u0000\u0000\u0000\u019b\u0711\u0001\u0000\u0000\u0000\u019d" + + "\u0717\u0001\u0000\u0000\u0000\u019f\u071d\u0001\u0000\u0000\u0000\u01a1" + + "\u0723\u0001\u0000\u0000\u0000\u01a3\u0729\u0001\u0000\u0000\u0000\u01a5" + + "\u0735\u0001\u0000\u0000\u0000\u01a7\u0739\u0001\u0000\u0000\u0000\u01a9" + + "\u0745\u0001\u0000\u0000\u0000\u01ab\u074b\u0001\u0000\u0000\u0000\u01ad" + + "\u0751\u0001\u0000\u0000\u0000\u01af\u0757\u0001\u0000\u0000\u0000\u01b1" + + "\u0759\u0001\u0000\u0000\u0000\u01b3\u0763\u0001\u0000\u0000\u0000\u01b5" + + "\u0765\u0001\u0000\u0000\u0000\u01b7\u0779\u0001\u0000\u0000\u0000\u01b9" + + "\u0791\u0001\u0000\u0000\u0000\u01bb\u07ac\u0001\u0000\u0000\u0000\u01bd" + + "\u07b1\u0001\u0000\u0000\u0000\u01bf\u07b5\u0001\u0000\u0000\u0000\u01c1" + + "\u07b7\u0001\u0000\u0000\u0000\u01c3\u07b9\u0001\u0000\u0000\u0000\u01c5" + + "\u07c2\u0001\u0000\u0000\u0000\u01c7\u07c9\u0001\u0000\u0000\u0000\u01c9" + + "\u07d2\u0001\u0000\u0000\u0000\u01cb\u07d6\u0001\u0000\u0000\u0000\u01cd" + + "\u07da\u0001\u0000\u0000\u0000\u01cf\u07df\u0001\u0000\u0000\u0000\u01d1" + + "\u07e3\u0001\u0000\u0000\u0000\u01d3\u07f9\u0001\u0000\u0000\u0000\u01d5" + + "\u07fc\u0001\u0000\u0000\u0000\u01d7\u07fe\u0001\u0000\u0000\u0000\u01d9" + + "\u0800\u0001\u0000\u0000\u0000\u01db\u0802\u0001\u0000\u0000\u0000\u01dd" + + "\u0804\u0001\u0000\u0000\u0000\u01df\u0806\u0001\u0000\u0000\u0000\u01e1" + + "\u0808\u0001\u0000\u0000\u0000\u01e3\u080a\u0001\u0000\u0000\u0000\u01e5" + + "\u080c\u0001\u0000\u0000\u0000\u01e7\u080e\u0001\u0000\u0000\u0000\u01e9" + + "\u0810\u0001\u0000\u0000\u0000\u01eb\u0812\u0001\u0000\u0000\u0000\u01ed" + + "\u01ee\u0005\u00ef\u0000\u0000\u01ee\u01ef\u0005\u00bb\u0000\u0000\u01ef" + + "\u01f0\u0005\u00bf\u0000\u0000\u01f0\u0006\u0001\u0000\u0000\u0000\u01f1" + + "\u01f2\u0005/\u0000\u0000\u01f2\u01f3\u0005/\u0000\u0000\u01f3\u01f4\u0005" + + "/\u0000\u0000\u01f4\u01f8\u0001\u0000\u0000\u0000\u01f5\u01f7\u0003\u01af" + + "\u00d5\u0000\u01f6\u01f5\u0001\u0000\u0000\u0000\u01f7\u01fa\u0001\u0000" + + "\u0000\u0000\u01f8\u01f6\u0001\u0000\u0000\u0000\u01f8\u01f9\u0001\u0000" + + "\u0000\u0000\u01f9\u01fb\u0001\u0000\u0000\u0000\u01fa\u01f8\u0001\u0000" + + "\u0000\u0000\u01fb\u01fc\u0006\u0001\u0000\u0000\u01fc\b\u0001\u0000\u0000" + + "\u0000\u01fd\u01fe\u0005/\u0000\u0000\u01fe\u01ff\u0005*\u0000\u0000\u01ff" + + "\u0200\u0005*\u0000\u0000\u0200\u0201\u0005*\u0000\u0000\u0201\u0202\u0005" + + "/\u0000\u0000\u0202\u0203\u0001\u0000\u0000\u0000\u0203\u0204\u0006\u0002" + + "\u0000\u0000\u0204\n\u0001\u0000\u0000\u0000\u0205\u0206\u0005/\u0000" + + "\u0000\u0206\u0207\u0005*\u0000\u0000\u0207\u0208\u0005*\u0000\u0000\u0208" + + "\u0209\u0001\u0000\u0000\u0000\u0209\u020d\b\u0000\u0000\u0000\u020a\u020c" + + "\t\u0000\u0000\u0000\u020b\u020a\u0001\u0000\u0000\u0000\u020c\u020f\u0001" + + "\u0000\u0000\u0000\u020d\u020e\u0001\u0000\u0000\u0000\u020d\u020b\u0001" + + "\u0000\u0000\u0000\u020e\u0210\u0001\u0000\u0000\u0000\u020f\u020d\u0001" + + "\u0000\u0000\u0000\u0210\u0211\u0005*\u0000\u0000\u0211\u0212\u0005/\u0000" + + "\u0000\u0212\u0213\u0001\u0000\u0000\u0000\u0213\u0214\u0006\u0003\u0000" + + "\u0000\u0214\f\u0001\u0000\u0000\u0000\u0215\u0216\u0005/\u0000\u0000" + + "\u0216\u0217\u0005/\u0000\u0000\u0217\u021b\u0001\u0000\u0000\u0000\u0218" + + "\u021a\u0003\u01af\u00d5\u0000\u0219\u0218\u0001\u0000\u0000\u0000\u021a" + + "\u021d\u0001\u0000\u0000\u0000\u021b\u0219\u0001\u0000\u0000\u0000\u021b" + + "\u021c\u0001\u0000\u0000\u0000\u021c\u021e\u0001\u0000\u0000\u0000\u021d" + + "\u021b\u0001\u0000\u0000\u0000\u021e\u021f\u0006\u0004\u0000\u0000\u021f" + + "\u000e\u0001\u0000\u0000\u0000\u0220\u0221\u0005/\u0000\u0000\u0221\u0222" + + "\u0005*\u0000\u0000\u0222\u0226\u0001\u0000\u0000\u0000\u0223\u0225\t" + + "\u0000\u0000\u0000\u0224\u0223\u0001\u0000\u0000\u0000\u0225\u0228\u0001" + + "\u0000\u0000\u0000\u0226\u0227\u0001\u0000\u0000\u0000\u0226\u0224\u0001" + + "\u0000\u0000\u0000\u0227\u0229\u0001\u0000\u0000\u0000\u0228\u0226\u0001" + + "\u0000\u0000\u0000\u0229\u022a\u0005*\u0000\u0000\u022a\u022b\u0005/\u0000" + + "\u0000\u022b\u022c\u0001\u0000\u0000\u0000\u022c\u022d\u0006\u0005\u0000" + + "\u0000\u022d\u0010\u0001\u0000\u0000\u0000\u022e\u0231\u0003\u01bf\u00dd" + + "\u0000\u022f\u0231\u0003\u01bd\u00dc\u0000\u0230\u022e\u0001\u0000\u0000" + + "\u0000\u0230\u022f\u0001\u0000\u0000\u0000\u0231\u0232\u0001\u0000\u0000" + + "\u0000\u0232\u0230\u0001\u0000\u0000\u0000\u0232\u0233\u0001\u0000\u0000" + + "\u0000\u0233\u0234\u0001\u0000\u0000\u0000\u0234\u0235\u0006\u0006\u0001" + + "\u0000\u0235\u0012\u0001\u0000\u0000\u0000\u0236\u0237\u0005#\u0000\u0000" + + "\u0237\u0238\u0001\u0000\u0000\u0000\u0238\u0239\u0006\u0007\u0002\u0000" + + "\u0239\u0014\u0001\u0000\u0000\u0000\u023a\u023b\u0005a\u0000\u0000\u023b" + + "\u023c\u0005b\u0000\u0000\u023c\u023d\u0005s\u0000\u0000\u023d\u023e\u0005" + + "t\u0000\u0000\u023e\u023f\u0005r\u0000\u0000\u023f\u0240\u0005a\u0000" + + "\u0000\u0240\u0241\u0005c\u0000\u0000\u0241\u0242\u0005t\u0000\u0000\u0242" + + "\u0016\u0001\u0000\u0000\u0000\u0243\u0244\u0005a\u0000\u0000\u0244\u0245" + + "\u0005d\u0000\u0000\u0245\u0246\u0005d\u0000\u0000\u0246\u0018\u0001\u0000" + + "\u0000\u0000\u0247\u0248\u0005a\u0000\u0000\u0248\u0249\u0005l\u0000\u0000" + + "\u0249\u024a\u0005i\u0000\u0000\u024a\u024b\u0005a\u0000\u0000\u024b\u024c" + + "\u0005s\u0000\u0000\u024c\u001a\u0001\u0000\u0000\u0000\u024d\u024e\u0005" + + "_\u0000\u0000\u024e\u024f\u0005_\u0000\u0000\u024f\u0250\u0005a\u0000" + + "\u0000\u0250\u0251\u0005r\u0000\u0000\u0251\u0252\u0005g\u0000\u0000\u0252" + + "\u0253\u0005l\u0000\u0000\u0253\u0254\u0005i\u0000\u0000\u0254\u0255\u0005" + + "s\u0000\u0000\u0255\u0256\u0005t\u0000\u0000\u0256\u001c\u0001\u0000\u0000" + + "\u0000\u0257\u0258\u0005a\u0000\u0000\u0258\u0259\u0005s\u0000\u0000\u0259" + + "\u001e\u0001\u0000\u0000\u0000\u025a\u025b\u0005a\u0000\u0000\u025b\u025c" + + "\u0005s\u0000\u0000\u025c\u025d\u0005c\u0000\u0000\u025d\u025e\u0005e" + + "\u0000\u0000\u025e\u025f\u0005n\u0000\u0000\u025f\u0260\u0005d\u0000\u0000" + + "\u0260\u0261\u0005i\u0000\u0000\u0261\u0262\u0005n\u0000\u0000\u0262\u0263" + + "\u0005g\u0000\u0000\u0263 \u0001\u0000\u0000\u0000\u0264\u0265\u0005a" + + "\u0000\u0000\u0265\u0266\u0005s\u0000\u0000\u0266\u0267\u0005y\u0000\u0000" + + "\u0267\u0268\u0005n\u0000\u0000\u0268\u0269\u0005c\u0000\u0000\u0269\"" + + "\u0001\u0000\u0000\u0000\u026a\u026b\u0005a\u0000\u0000\u026b\u026c\u0005" + + "w\u0000\u0000\u026c\u026d\u0005a\u0000\u0000\u026d\u026e\u0005i\u0000" + + "\u0000\u026e\u026f\u0005t\u0000\u0000\u026f$\u0001\u0000\u0000\u0000\u0270" + + "\u0271\u0005b\u0000\u0000\u0271\u0272\u0005a\u0000\u0000\u0272\u0273\u0005" + + "s\u0000\u0000\u0273\u0274\u0005e\u0000\u0000\u0274&\u0001\u0000\u0000" + + "\u0000\u0275\u0276\u0005b\u0000\u0000\u0276\u0277\u0005o\u0000\u0000\u0277" + + "\u0278\u0005o\u0000\u0000\u0278\u0279\u0005l\u0000\u0000\u0279(\u0001" + + "\u0000\u0000\u0000\u027a\u027b\u0005b\u0000\u0000\u027b\u027c\u0005r\u0000" + + "\u0000\u027c\u027d\u0005e\u0000\u0000\u027d\u027e\u0005a\u0000\u0000\u027e" + + "\u027f\u0005k\u0000\u0000\u027f*\u0001\u0000\u0000\u0000\u0280\u0281\u0005" + + "b\u0000\u0000\u0281\u0282\u0005y\u0000\u0000\u0282,\u0001\u0000\u0000" + + "\u0000\u0283\u0284\u0005b\u0000\u0000\u0284\u0285\u0005y\u0000\u0000\u0285" + + "\u0286\u0005t\u0000\u0000\u0286\u0287\u0005e\u0000\u0000\u0287.\u0001" + + "\u0000\u0000\u0000\u0288\u0289\u0005c\u0000\u0000\u0289\u028a\u0005a\u0000" + + "\u0000\u028a\u028b\u0005s\u0000\u0000\u028b\u028c\u0005e\u0000\u0000\u028c" + + "0\u0001\u0000\u0000\u0000\u028d\u028e\u0005c\u0000\u0000\u028e\u028f\u0005" + + "a\u0000\u0000\u028f\u0290\u0005t\u0000\u0000\u0290\u0291\u0005c\u0000" + + "\u0000\u0291\u0292\u0005h\u0000\u0000\u02922\u0001\u0000\u0000\u0000\u0293" + + "\u0294\u0005c\u0000\u0000\u0294\u0295\u0005h\u0000\u0000\u0295\u0296\u0005" + + "a\u0000\u0000\u0296\u0297\u0005r\u0000\u0000\u02974\u0001\u0000\u0000" + + "\u0000\u0298\u0299\u0005c\u0000\u0000\u0299\u029a\u0005h\u0000\u0000\u029a" + + "\u029b\u0005e\u0000\u0000\u029b\u029c\u0005c\u0000\u0000\u029c\u029d\u0005" + + "k\u0000\u0000\u029d\u029e\u0005e\u0000\u0000\u029e\u029f\u0005d\u0000" + + "\u0000\u029f6\u0001\u0000\u0000\u0000\u02a0\u02a1\u0005c\u0000\u0000\u02a1" + + "\u02a2\u0005l\u0000\u0000\u02a2\u02a3\u0005a\u0000\u0000\u02a3\u02a4\u0005" + + "s\u0000\u0000\u02a4\u02a5\u0005s\u0000\u0000\u02a58\u0001\u0000\u0000" + + "\u0000\u02a6\u02a7\u0005c\u0000\u0000\u02a7\u02a8\u0005o\u0000\u0000\u02a8" + + "\u02a9\u0005n\u0000\u0000\u02a9\u02aa\u0005s\u0000\u0000\u02aa\u02ab\u0005" + + "t\u0000\u0000\u02ab:\u0001\u0000\u0000\u0000\u02ac\u02ad\u0005c\u0000" + + "\u0000\u02ad\u02ae\u0005o\u0000\u0000\u02ae\u02af\u0005n\u0000\u0000\u02af" + + "\u02b0\u0005t\u0000\u0000\u02b0\u02b1\u0005i\u0000\u0000\u02b1\u02b2\u0005" + + "n\u0000\u0000\u02b2\u02b3\u0005u\u0000\u0000\u02b3\u02b4\u0005e\u0000" + + "\u0000\u02b4<\u0001\u0000\u0000\u0000\u02b5\u02b6\u0005d\u0000\u0000\u02b6" + + "\u02b7\u0005e\u0000\u0000\u02b7\u02b8\u0005c\u0000\u0000\u02b8\u02b9\u0005" + + "i\u0000\u0000\u02b9\u02ba\u0005m\u0000\u0000\u02ba\u02bb\u0005a\u0000" + + "\u0000\u02bb\u02bc\u0005l\u0000\u0000\u02bc>\u0001\u0000\u0000\u0000\u02bd" + + "\u02be\u0005d\u0000\u0000\u02be\u02bf\u0005e\u0000\u0000\u02bf\u02c0\u0005" + + "f\u0000\u0000\u02c0\u02c1\u0005a\u0000\u0000\u02c1\u02c2\u0005u\u0000" + + "\u0000\u02c2\u02c3\u0005l\u0000\u0000\u02c3\u02c4\u0005t\u0000\u0000\u02c4" + + "@\u0001\u0000\u0000\u0000\u02c5\u02c6\u0005d\u0000\u0000\u02c6\u02c7\u0005" + + "e\u0000\u0000\u02c7\u02c8\u0005l\u0000\u0000\u02c8\u02c9\u0005e\u0000" + + "\u0000\u02c9\u02ca\u0005g\u0000\u0000\u02ca\u02cb\u0005a\u0000\u0000\u02cb" + + "\u02cc\u0005t\u0000\u0000\u02cc\u02cd\u0005e\u0000\u0000\u02cdB\u0001" + + "\u0000\u0000\u0000\u02ce\u02cf\u0005d\u0000\u0000\u02cf\u02d0\u0005e\u0000" + + "\u0000\u02d0\u02d1\u0005s\u0000\u0000\u02d1\u02d2\u0005c\u0000\u0000\u02d2" + + "\u02d3\u0005e\u0000\u0000\u02d3\u02d4\u0005n\u0000\u0000\u02d4\u02d5\u0005" + + "d\u0000\u0000\u02d5\u02d6\u0005i\u0000\u0000\u02d6\u02d7\u0005n\u0000" + + "\u0000\u02d7\u02d8\u0005g\u0000\u0000\u02d8D\u0001\u0000\u0000\u0000\u02d9" + + "\u02da\u0005d\u0000\u0000\u02da\u02db\u0005o\u0000\u0000\u02dbF\u0001" + + "\u0000\u0000\u0000\u02dc\u02dd\u0005d\u0000\u0000\u02dd\u02de\u0005o\u0000" + + "\u0000\u02de\u02df\u0005u\u0000\u0000\u02df\u02e0\u0005b\u0000\u0000\u02e0" + + "\u02e1\u0005l\u0000\u0000\u02e1\u02e2\u0005e\u0000\u0000\u02e2H\u0001" + + "\u0000\u0000\u0000\u02e3\u02e4\u0005d\u0000\u0000\u02e4\u02e5\u0005y\u0000" + + "\u0000\u02e5\u02e6\u0005n\u0000\u0000\u02e6\u02e7\u0005a\u0000\u0000\u02e7" + + "\u02e8\u0005m\u0000\u0000\u02e8\u02e9\u0005i\u0000\u0000\u02e9\u02ea\u0005" + + "c\u0000\u0000\u02eaJ\u0001\u0000\u0000\u0000\u02eb\u02ec\u0005e\u0000" + + "\u0000\u02ec\u02ed\u0005l\u0000\u0000\u02ed\u02ee\u0005s\u0000\u0000\u02ee" + + "\u02ef\u0005e\u0000\u0000\u02efL\u0001\u0000\u0000\u0000\u02f0\u02f1\u0005" + + "e\u0000\u0000\u02f1\u02f2\u0005n\u0000\u0000\u02f2\u02f3\u0005u\u0000" + + "\u0000\u02f3\u02f4\u0005m\u0000\u0000\u02f4N\u0001\u0000\u0000\u0000\u02f5" + + "\u02f6\u0005e\u0000\u0000\u02f6\u02f7\u0005q\u0000\u0000\u02f7\u02f8\u0005" + + "u\u0000\u0000\u02f8\u02f9\u0005a\u0000\u0000\u02f9\u02fa\u0005l\u0000" + + "\u0000\u02fa\u02fb\u0005s\u0000\u0000\u02fbP\u0001\u0000\u0000\u0000\u02fc" + + "\u02fd\u0005e\u0000\u0000\u02fd\u02fe\u0005v\u0000\u0000\u02fe\u02ff\u0005" + + "e\u0000\u0000\u02ff\u0300\u0005n\u0000\u0000\u0300\u0301\u0005t\u0000" + + "\u0000\u0301R\u0001\u0000\u0000\u0000\u0302\u0303\u0005e\u0000\u0000\u0303" + + "\u0304\u0005x\u0000\u0000\u0304\u0305\u0005p\u0000\u0000\u0305\u0306\u0005" + + "l\u0000\u0000\u0306\u0307\u0005i\u0000\u0000\u0307\u0308\u0005c\u0000" + + "\u0000\u0308\u0309\u0005i\u0000\u0000\u0309\u030a\u0005t\u0000\u0000\u030a" + + "T\u0001\u0000\u0000\u0000\u030b\u030c\u0005e\u0000\u0000\u030c\u030d\u0005" + + "x\u0000\u0000\u030d\u030e\u0005t\u0000\u0000\u030e\u030f\u0005e\u0000" + + "\u0000\u030f\u0310\u0005r\u0000\u0000\u0310\u0311\u0005n\u0000\u0000\u0311" + + "V\u0001\u0000\u0000\u0000\u0312\u0313\u0005f\u0000\u0000\u0313\u0314\u0005" + + "a\u0000\u0000\u0314\u0315\u0005l\u0000\u0000\u0315\u0316\u0005s\u0000" + + "\u0000\u0316\u0317\u0005e\u0000\u0000\u0317X\u0001\u0000\u0000\u0000\u0318" + + "\u0319\u0005f\u0000\u0000\u0319\u031a\u0005i\u0000\u0000\u031a\u031b\u0005" + + "n\u0000\u0000\u031b\u031c\u0005a\u0000\u0000\u031c\u031d\u0005l\u0000" + + "\u0000\u031d\u031e\u0005l\u0000\u0000\u031e\u031f\u0005y\u0000\u0000\u031f" + + "Z\u0001\u0000\u0000\u0000\u0320\u0321\u0005f\u0000\u0000\u0321\u0322\u0005" + + "i\u0000\u0000\u0322\u0323\u0005x\u0000\u0000\u0323\u0324\u0005e\u0000" + + "\u0000\u0324\u0325\u0005d\u0000\u0000\u0325\\\u0001\u0000\u0000\u0000" + + "\u0326\u0327\u0005f\u0000\u0000\u0327\u0328\u0005l\u0000\u0000\u0328\u0329" + + "\u0005o\u0000\u0000\u0329\u032a\u0005a\u0000\u0000\u032a\u032b\u0005t" + + "\u0000\u0000\u032b^\u0001\u0000\u0000\u0000\u032c\u032d\u0005f\u0000\u0000" + + "\u032d\u032e\u0005o\u0000\u0000\u032e\u032f\u0005r\u0000\u0000\u032f`" + + "\u0001\u0000\u0000\u0000\u0330\u0331\u0005f\u0000\u0000\u0331\u0332\u0005" + + "o\u0000\u0000\u0332\u0333\u0005r\u0000\u0000\u0333\u0334\u0005e\u0000" + + "\u0000\u0334\u0335\u0005a\u0000\u0000\u0335\u0336\u0005c\u0000\u0000\u0336" + + "\u0337\u0005h\u0000\u0000\u0337b\u0001\u0000\u0000\u0000\u0338\u0339\u0005" + + "f\u0000\u0000\u0339\u033a\u0005r\u0000\u0000\u033a\u033b\u0005o\u0000" + + "\u0000\u033b\u033c\u0005m\u0000\u0000\u033cd\u0001\u0000\u0000\u0000\u033d" + + "\u033e\u0005g\u0000\u0000\u033e\u033f\u0005e\u0000\u0000\u033f\u0340\u0005" + + "t\u0000\u0000\u0340f\u0001\u0000\u0000\u0000\u0341\u0342\u0005g\u0000" + + "\u0000\u0342\u0343\u0005o\u0000\u0000\u0343\u0344\u0005t\u0000\u0000\u0344" + + "\u0345\u0005o\u0000\u0000\u0345h\u0001\u0000\u0000\u0000\u0346\u0347\u0005" + + "g\u0000\u0000\u0347\u0348\u0005r\u0000\u0000\u0348\u0349\u0005o\u0000" + + "\u0000\u0349\u034a\u0005u\u0000\u0000\u034a\u034b\u0005p\u0000\u0000\u034b" + + "j\u0001\u0000\u0000\u0000\u034c\u034d\u0005i\u0000\u0000\u034d\u034e\u0005" + + "f\u0000\u0000\u034el\u0001\u0000\u0000\u0000\u034f\u0350\u0005i\u0000" + + "\u0000\u0350\u0351\u0005m\u0000\u0000\u0351\u0352\u0005p\u0000\u0000\u0352" + + "\u0353\u0005l\u0000\u0000\u0353\u0354\u0005i\u0000\u0000\u0354\u0355\u0005" + + "c\u0000\u0000\u0355\u0356\u0005i\u0000\u0000\u0356\u0357\u0005t\u0000" + + "\u0000\u0357n\u0001\u0000\u0000\u0000\u0358\u0359\u0005i\u0000\u0000\u0359" + + "\u035a\u0005n\u0000\u0000\u035ap\u0001\u0000\u0000\u0000\u035b\u035c\u0005" + + "i\u0000\u0000\u035c\u035d\u0005n\u0000\u0000\u035d\u035e\u0005t\u0000" + + "\u0000\u035er\u0001\u0000\u0000\u0000\u035f\u0360\u0005i\u0000\u0000\u0360" + + "\u0361\u0005n\u0000\u0000\u0361\u0362\u0005t\u0000\u0000\u0362\u0363\u0005" + + "e\u0000\u0000\u0363\u0364\u0005r\u0000\u0000\u0364\u0365\u0005f\u0000" + + "\u0000\u0365\u0366\u0005a\u0000\u0000\u0366\u0367\u0005c\u0000\u0000\u0367" + + "\u0368\u0005e\u0000\u0000\u0368t\u0001\u0000\u0000\u0000\u0369\u036a\u0005" + + "i\u0000\u0000\u036a\u036b\u0005n\u0000\u0000\u036b\u036c\u0005t\u0000" + + "\u0000\u036c\u036d\u0005e\u0000\u0000\u036d\u036e\u0005r\u0000\u0000\u036e" + + "\u036f\u0005n\u0000\u0000\u036f\u0370\u0005a\u0000\u0000\u0370\u0371\u0005" + + "l\u0000\u0000\u0371v\u0001\u0000\u0000\u0000\u0372\u0373\u0005i\u0000" + + "\u0000\u0373\u0374\u0005n\u0000\u0000\u0374\u0375\u0005t\u0000\u0000\u0375" + + "\u0376\u0005o\u0000\u0000\u0376x\u0001\u0000\u0000\u0000\u0377\u0378\u0005" + + "i\u0000\u0000\u0378\u0379\u0005s\u0000\u0000\u0379z\u0001\u0000\u0000" + + "\u0000\u037a\u037b\u0005j\u0000\u0000\u037b\u037c\u0005o\u0000\u0000\u037c" + + "\u037d\u0005i\u0000\u0000\u037d\u037e\u0005n\u0000\u0000\u037e|\u0001" + + "\u0000\u0000\u0000\u037f\u0380\u0005l\u0000\u0000\u0380\u0381\u0005e\u0000" + + "\u0000\u0381\u0382\u0005t\u0000\u0000\u0382~\u0001\u0000\u0000\u0000\u0383" + + "\u0384\u0005l\u0000\u0000\u0384\u0385\u0005o\u0000\u0000\u0385\u0386\u0005" + + "c\u0000\u0000\u0386\u0387\u0005k\u0000\u0000\u0387\u0080\u0001\u0000\u0000" + + "\u0000\u0388\u0389\u0005l\u0000\u0000\u0389\u038a\u0005o\u0000\u0000\u038a" + + "\u038b\u0005n\u0000\u0000\u038b\u038c\u0005g\u0000\u0000\u038c\u0082\u0001" + + "\u0000\u0000\u0000\u038d\u038e\u0005n\u0000\u0000\u038e\u038f\u0005a\u0000" + + "\u0000\u038f\u0390\u0005m\u0000\u0000\u0390\u0391\u0005e\u0000\u0000\u0391" + + "\u0392\u0005o\u0000\u0000\u0392\u0393\u0005f\u0000\u0000\u0393\u0084\u0001" + + "\u0000\u0000\u0000\u0394\u0395\u0005n\u0000\u0000\u0395\u0396\u0005a\u0000" + + "\u0000\u0396\u0397\u0005m\u0000\u0000\u0397\u0398\u0005e\u0000\u0000\u0398" + + "\u0399\u0005s\u0000\u0000\u0399\u039a\u0005p\u0000\u0000\u039a\u039b\u0005" + + "a\u0000\u0000\u039b\u039c\u0005c\u0000\u0000\u039c\u039d\u0005e\u0000" + + "\u0000\u039d\u0086\u0001\u0000\u0000\u0000\u039e\u039f\u0005n\u0000\u0000" + + "\u039f\u03a0\u0005e\u0000\u0000\u03a0\u03a1\u0005w\u0000\u0000\u03a1\u0088" + + "\u0001\u0000\u0000\u0000\u03a2\u03a3\u0005n\u0000\u0000\u03a3\u03a4\u0005" + + "u\u0000\u0000\u03a4\u03a5\u0005l\u0000\u0000\u03a5\u03a6\u0005l\u0000" + + "\u0000\u03a6\u008a\u0001\u0000\u0000\u0000\u03a7\u03a8\u0005o\u0000\u0000" + + "\u03a8\u03a9\u0005b\u0000\u0000\u03a9\u03aa\u0005j\u0000\u0000\u03aa\u03ab" + + "\u0005e\u0000\u0000\u03ab\u03ac\u0005c\u0000\u0000\u03ac\u03ad\u0005t" + + "\u0000\u0000\u03ad\u008c\u0001\u0000\u0000\u0000\u03ae\u03af\u0005o\u0000" + + "\u0000\u03af\u03b0\u0005n\u0000\u0000\u03b0\u008e\u0001\u0000\u0000\u0000" + + "\u03b1\u03b2\u0005o\u0000\u0000\u03b2\u03b3\u0005p\u0000\u0000\u03b3\u03b4" + + "\u0005e\u0000\u0000\u03b4\u03b5\u0005r\u0000\u0000\u03b5\u03b6\u0005a" + + "\u0000\u0000\u03b6\u03b7\u0005t\u0000\u0000\u03b7\u03b8\u0005o\u0000\u0000" + + "\u03b8\u03b9\u0005r\u0000\u0000\u03b9\u0090\u0001\u0000\u0000\u0000\u03ba" + + "\u03bb\u0005o\u0000\u0000\u03bb\u03bc\u0005r\u0000\u0000\u03bc\u03bd\u0005" + + "d\u0000\u0000\u03bd\u03be\u0005e\u0000\u0000\u03be\u03bf\u0005r\u0000" + + "\u0000\u03bf\u03c0\u0005b\u0000\u0000\u03c0\u03c1\u0005y\u0000\u0000\u03c1" + + "\u0092\u0001\u0000\u0000\u0000\u03c2\u03c3\u0005o\u0000\u0000\u03c3\u03c4" + + "\u0005u\u0000\u0000\u03c4\u03c5\u0005t\u0000\u0000\u03c5\u0094\u0001\u0000" + + "\u0000\u0000\u03c6\u03c7\u0005o\u0000\u0000\u03c7\u03c8\u0005v\u0000\u0000" + + "\u03c8\u03c9\u0005e\u0000\u0000\u03c9\u03ca\u0005r\u0000\u0000\u03ca\u03cb" + + "\u0005r\u0000\u0000\u03cb\u03cc\u0005i\u0000\u0000\u03cc\u03cd\u0005d" + + "\u0000\u0000\u03cd\u03ce\u0005e\u0000\u0000\u03ce\u0096\u0001\u0000\u0000" + + "\u0000\u03cf\u03d0\u0005p\u0000\u0000\u03d0\u03d1\u0005a\u0000\u0000\u03d1" + + "\u03d2\u0005r\u0000\u0000\u03d2\u03d3\u0005a\u0000\u0000\u03d3\u03d4\u0005" + + "m\u0000\u0000\u03d4\u03d5\u0005s\u0000\u0000\u03d5\u0098\u0001\u0000\u0000" + + "\u0000\u03d6\u03d7\u0005p\u0000\u0000\u03d7\u03d8\u0005a\u0000\u0000\u03d8" + + "\u03d9\u0005r\u0000\u0000\u03d9\u03da\u0005t\u0000\u0000\u03da\u03db\u0005" + + "i\u0000\u0000\u03db\u03dc\u0005a\u0000\u0000\u03dc\u03dd\u0005l\u0000" + + "\u0000\u03dd\u009a\u0001\u0000\u0000\u0000\u03de\u03df\u0005p\u0000\u0000" + + "\u03df\u03e0\u0005r\u0000\u0000\u03e0\u03e1\u0005i\u0000\u0000\u03e1\u03e2" + + "\u0005v\u0000\u0000\u03e2\u03e3\u0005a\u0000\u0000\u03e3\u03e4\u0005t" + + "\u0000\u0000\u03e4\u03e5\u0005e\u0000\u0000\u03e5\u009c\u0001\u0000\u0000" + + "\u0000\u03e6\u03e7\u0005p\u0000\u0000\u03e7\u03e8\u0005r\u0000\u0000\u03e8" + + "\u03e9\u0005o\u0000\u0000\u03e9\u03ea\u0005t\u0000\u0000\u03ea\u03eb\u0005" + + "e\u0000\u0000\u03eb\u03ec\u0005c\u0000\u0000\u03ec\u03ed\u0005t\u0000" + + "\u0000\u03ed\u03ee\u0005e\u0000\u0000\u03ee\u03ef\u0005d\u0000\u0000\u03ef" + + "\u009e\u0001\u0000\u0000\u0000\u03f0\u03f1\u0005p\u0000\u0000\u03f1\u03f2" + + "\u0005u\u0000\u0000\u03f2\u03f3\u0005b\u0000\u0000\u03f3\u03f4\u0005l" + + "\u0000\u0000\u03f4\u03f5\u0005i\u0000\u0000\u03f5\u03f6\u0005c\u0000\u0000" + + "\u03f6\u00a0\u0001\u0000\u0000\u0000\u03f7\u03f8\u0005r\u0000\u0000\u03f8" + + "\u03f9\u0005e\u0000\u0000\u03f9\u03fa\u0005a\u0000\u0000\u03fa\u03fb\u0005" + + "d\u0000\u0000\u03fb\u03fc\u0005o\u0000\u0000\u03fc\u03fd\u0005n\u0000" + + "\u0000\u03fd\u03fe\u0005l\u0000\u0000\u03fe\u03ff\u0005y\u0000\u0000\u03ff" + + "\u00a2\u0001\u0000\u0000\u0000\u0400\u0401\u0005r\u0000\u0000\u0401\u0402" + + "\u0005e\u0000\u0000\u0402\u0403\u0005f\u0000\u0000\u0403\u00a4\u0001\u0000" + + "\u0000\u0000\u0404\u0405\u0005r\u0000\u0000\u0405\u0406\u0005e\u0000\u0000" + + "\u0406\u0407\u0005m\u0000\u0000\u0407\u0408\u0005o\u0000\u0000\u0408\u0409" + + "\u0005v\u0000\u0000\u0409\u040a\u0005e\u0000\u0000\u040a\u00a6\u0001\u0000" + + "\u0000\u0000\u040b\u040c\u0005r\u0000\u0000\u040c\u040d\u0005e\u0000\u0000" + + "\u040d\u040e\u0005t\u0000\u0000\u040e\u040f\u0005u\u0000\u0000\u040f\u0410" + + "\u0005r\u0000\u0000\u0410\u0411\u0005n\u0000\u0000\u0411\u00a8\u0001\u0000" + + "\u0000\u0000\u0412\u0413\u0005s\u0000\u0000\u0413\u0414\u0005b\u0000\u0000" + + "\u0414\u0415\u0005y\u0000\u0000\u0415\u0416\u0005t\u0000\u0000\u0416\u0417" + + "\u0005e\u0000\u0000\u0417\u00aa\u0001\u0000\u0000\u0000\u0418\u0419\u0005" + + "s\u0000\u0000\u0419\u041a\u0005e\u0000\u0000\u041a\u041b\u0005a\u0000" + + "\u0000\u041b\u041c\u0005l\u0000\u0000\u041c\u041d\u0005e\u0000\u0000\u041d" + + "\u041e\u0005d\u0000\u0000\u041e\u00ac\u0001\u0000\u0000\u0000\u041f\u0420" + + "\u0005s\u0000\u0000\u0420\u0421\u0005e\u0000\u0000\u0421\u0422\u0005l" + + "\u0000\u0000\u0422\u0423\u0005e\u0000\u0000\u0423\u0424\u0005c\u0000\u0000" + + "\u0424\u0425\u0005t\u0000\u0000\u0425\u00ae\u0001\u0000\u0000\u0000\u0426" + + "\u0427\u0005s\u0000\u0000\u0427\u0428\u0005e\u0000\u0000\u0428\u0429\u0005" + + "t\u0000\u0000\u0429\u00b0\u0001\u0000\u0000\u0000\u042a\u042b\u0005s\u0000" + + "\u0000\u042b\u042c\u0005h\u0000\u0000\u042c\u042d\u0005o\u0000\u0000\u042d" + + "\u042e\u0005r\u0000\u0000\u042e\u042f\u0005t\u0000\u0000\u042f\u00b2\u0001" + + "\u0000\u0000\u0000\u0430\u0431\u0005s\u0000\u0000\u0431\u0432\u0005i\u0000" + + "\u0000\u0432\u0433\u0005z\u0000\u0000\u0433\u0434\u0005e\u0000\u0000\u0434" + + "\u0435\u0005o\u0000\u0000\u0435\u0436\u0005f\u0000\u0000\u0436\u00b4\u0001" + + "\u0000\u0000\u0000\u0437\u0438\u0005s\u0000\u0000\u0438\u0439\u0005t\u0000" + + "\u0000\u0439\u043a\u0005a\u0000\u0000\u043a\u043b\u0005c\u0000\u0000\u043b" + + "\u043c\u0005k\u0000\u0000\u043c\u043d\u0005a\u0000\u0000\u043d\u043e\u0005" + + "l\u0000\u0000\u043e\u043f\u0005l\u0000\u0000\u043f\u0440\u0005o\u0000" + + "\u0000\u0440\u0441\u0005c\u0000\u0000\u0441\u00b6\u0001\u0000\u0000\u0000" + + "\u0442\u0443\u0005s\u0000\u0000\u0443\u0444\u0005t\u0000\u0000\u0444\u0445" + + "\u0005a\u0000\u0000\u0445\u0446\u0005t\u0000\u0000\u0446\u0447\u0005i" + + "\u0000\u0000\u0447\u0448\u0005c\u0000\u0000\u0448\u00b8\u0001\u0000\u0000" + + "\u0000\u0449\u044a\u0005s\u0000\u0000\u044a\u044b\u0005t\u0000\u0000\u044b" + + "\u044c\u0005r\u0000\u0000\u044c\u044d\u0005i\u0000\u0000\u044d\u044e\u0005" + + "n\u0000\u0000\u044e\u044f\u0005g\u0000\u0000\u044f\u00ba\u0001\u0000\u0000" + + "\u0000\u0450\u0451\u0005s\u0000\u0000\u0451\u0452\u0005t\u0000\u0000\u0452" + + "\u0453\u0005r\u0000\u0000\u0453\u0454\u0005u\u0000\u0000\u0454\u0455\u0005" + + "c\u0000\u0000\u0455\u0456\u0005t\u0000\u0000\u0456\u00bc\u0001\u0000\u0000" + + "\u0000\u0457\u0458\u0005s\u0000\u0000\u0458\u0459\u0005w\u0000\u0000\u0459" + + "\u045a\u0005i\u0000\u0000\u045a\u045b\u0005t\u0000\u0000\u045b\u045c\u0005" + + "c\u0000\u0000\u045c\u045d\u0005h\u0000\u0000\u045d\u00be\u0001\u0000\u0000" + + "\u0000\u045e\u045f\u0005t\u0000\u0000\u045f\u0460\u0005h\u0000\u0000\u0460" + + "\u0461\u0005i\u0000\u0000\u0461\u0462\u0005s\u0000\u0000\u0462\u00c0\u0001" + + "\u0000\u0000\u0000\u0463\u0464\u0005t\u0000\u0000\u0464\u0465\u0005h\u0000" + + "\u0000\u0465\u0466\u0005r\u0000\u0000\u0466\u0467\u0005o\u0000\u0000\u0467" + + "\u0468\u0005w\u0000\u0000\u0468\u00c2\u0001\u0000\u0000\u0000\u0469\u046a" + + "\u0005t\u0000\u0000\u046a\u046b\u0005r\u0000\u0000\u046b\u046c\u0005u" + + "\u0000\u0000\u046c\u046d\u0005e\u0000\u0000\u046d\u00c4\u0001\u0000\u0000" + + "\u0000\u046e\u046f\u0005t\u0000\u0000\u046f\u0470\u0005r\u0000\u0000\u0470" + + "\u0471\u0005y\u0000\u0000\u0471\u00c6\u0001\u0000\u0000\u0000\u0472\u0473" + + "\u0005t\u0000\u0000\u0473\u0474\u0005y\u0000\u0000\u0474\u0475\u0005p" + + "\u0000\u0000\u0475\u0476\u0005e\u0000\u0000\u0476\u0477\u0005o\u0000\u0000" + + "\u0477\u0478\u0005f\u0000\u0000\u0478\u00c8\u0001\u0000\u0000\u0000\u0479" + + "\u047a\u0005u\u0000\u0000\u047a\u047b\u0005i\u0000\u0000\u047b\u047c\u0005" + + "n\u0000\u0000\u047c\u047d\u0005t\u0000\u0000\u047d\u00ca\u0001\u0000\u0000" + + "\u0000\u047e\u047f\u0005u\u0000\u0000\u047f\u0480\u0005l\u0000\u0000\u0480" + + "\u0481\u0005o\u0000\u0000\u0481\u0482\u0005n\u0000\u0000\u0482\u0483\u0005" + + "g\u0000\u0000\u0483\u00cc\u0001\u0000\u0000\u0000\u0484\u0485\u0005u\u0000" + + "\u0000\u0485\u0486\u0005n\u0000\u0000\u0486\u0487\u0005c\u0000\u0000\u0487" + + "\u0488\u0005h\u0000\u0000\u0488\u0489\u0005e\u0000\u0000\u0489\u048a\u0005" + + "c\u0000\u0000\u048a\u048b\u0005k\u0000\u0000\u048b\u048c\u0005e\u0000" + + "\u0000\u048c\u048d\u0005d\u0000\u0000\u048d\u00ce\u0001\u0000\u0000\u0000" + + "\u048e\u048f\u0005u\u0000\u0000\u048f\u0490\u0005n\u0000\u0000\u0490\u0491" + + "\u0005m\u0000\u0000\u0491\u0492\u0005a\u0000\u0000\u0492\u0493\u0005n" + + "\u0000\u0000\u0493\u0494\u0005a\u0000\u0000\u0494\u0495\u0005g\u0000\u0000" + + "\u0495\u0496\u0005e\u0000\u0000\u0496\u0497\u0005d\u0000\u0000\u0497\u00d0" + + "\u0001\u0000\u0000\u0000\u0498\u0499\u0005u\u0000\u0000\u0499\u049a\u0005" + + "n\u0000\u0000\u049a\u049b\u0005s\u0000\u0000\u049b\u049c\u0005a\u0000" + + "\u0000\u049c\u049d\u0005f\u0000\u0000\u049d\u049e\u0005e\u0000\u0000\u049e" + + "\u00d2\u0001\u0000\u0000\u0000\u049f\u04a0\u0005u\u0000\u0000\u04a0\u04a1" + + "\u0005s\u0000\u0000\u04a1\u04a2\u0005h\u0000\u0000\u04a2\u04a3\u0005o" + + "\u0000\u0000\u04a3\u04a4\u0005r\u0000\u0000\u04a4\u04a5\u0005t\u0000\u0000" + + "\u04a5\u00d4\u0001\u0000\u0000\u0000\u04a6\u04a7\u0005u\u0000\u0000\u04a7" + + "\u04a8\u0005s\u0000\u0000\u04a8\u04a9\u0005i\u0000\u0000\u04a9\u04aa\u0005" + + "n\u0000\u0000\u04aa\u04ab\u0005g\u0000\u0000\u04ab\u00d6\u0001\u0000\u0000" + + "\u0000\u04ac\u04ad\u0005v\u0000\u0000\u04ad\u04ae\u0005a\u0000\u0000\u04ae" + + "\u04af\u0005r\u0000\u0000\u04af\u00d8\u0001\u0000\u0000\u0000\u04b0\u04b1" + + "\u0005v\u0000\u0000\u04b1\u04b2\u0005i\u0000\u0000\u04b2\u04b3\u0005r" + + "\u0000\u0000\u04b3\u04b4\u0005t\u0000\u0000\u04b4\u04b5\u0005u\u0000\u0000" + + "\u04b5\u04b6\u0005a\u0000\u0000\u04b6\u04b7\u0005l\u0000\u0000\u04b7\u00da" + + "\u0001\u0000\u0000\u0000\u04b8\u04b9\u0005v\u0000\u0000\u04b9\u04ba\u0005" + + "o\u0000\u0000\u04ba\u04bb\u0005i\u0000\u0000\u04bb\u04bc\u0005d\u0000" + + "\u0000\u04bc\u00dc\u0001\u0000\u0000\u0000\u04bd\u04be\u0005v\u0000\u0000" + + "\u04be\u04bf\u0005o\u0000\u0000\u04bf\u04c0\u0005l\u0000\u0000\u04c0\u04c1" + + "\u0005a\u0000\u0000\u04c1\u04c2\u0005t\u0000\u0000\u04c2\u04c3\u0005i" + + "\u0000\u0000\u04c3\u04c4\u0005l\u0000\u0000\u04c4\u04c5\u0005e\u0000\u0000" + + "\u04c5\u00de\u0001\u0000\u0000\u0000\u04c6\u04c7\u0005w\u0000\u0000\u04c7" + + "\u04c8\u0005h\u0000\u0000\u04c8\u04c9\u0005e\u0000\u0000\u04c9\u04ca\u0005" + + "n\u0000\u0000\u04ca\u00e0\u0001\u0000\u0000\u0000\u04cb\u04cc\u0005w\u0000" + + "\u0000\u04cc\u04cd\u0005h\u0000\u0000\u04cd\u04ce\u0005e\u0000\u0000\u04ce" + + "\u04cf\u0005r\u0000\u0000\u04cf\u04d0\u0005e\u0000\u0000\u04d0\u00e2\u0001" + + "\u0000\u0000\u0000\u04d1\u04d2\u0005w\u0000\u0000\u04d2\u04d3\u0005h\u0000" + + "\u0000\u04d3\u04d4\u0005i\u0000\u0000\u04d4\u04d5\u0005l\u0000\u0000\u04d5" + + "\u04d6\u0005e\u0000\u0000\u04d6\u00e4\u0001\u0000\u0000\u0000\u04d7\u04d8" + + "\u0005y\u0000\u0000\u04d8\u04d9\u0005i\u0000\u0000\u04d9\u04da\u0005e" + + "\u0000\u0000\u04da\u04db\u0005l\u0000\u0000\u04db\u04dc\u0005d\u0000\u0000" + + "\u04dc\u00e6\u0001\u0000\u0000\u0000\u04dd\u04df\u0005@\u0000\u0000\u04de" + + "\u04dd\u0001\u0000\u0000\u0000\u04de\u04df\u0001\u0000\u0000\u0000\u04df" + + "\u04e0\u0001\u0000\u0000\u0000\u04e0\u04e1\u0003\u01c3\u00df\u0000\u04e1" + + "\u00e8\u0001\u0000\u0000\u0000\u04e2\u04ec\u0007\u0001\u0000\u0000\u04e3" + + "\u04e5\u0005_\u0000\u0000\u04e4\u04e3\u0001\u0000\u0000\u0000\u04e5\u04e8" + + "\u0001\u0000\u0000\u0000\u04e6\u04e4\u0001\u0000\u0000\u0000\u04e6\u04e7" + + "\u0001\u0000\u0000\u0000\u04e7\u04e9\u0001\u0000\u0000\u0000\u04e8\u04e6" + + "\u0001\u0000\u0000\u0000\u04e9\u04eb\u0007\u0001\u0000\u0000\u04ea\u04e6" + + "\u0001\u0000\u0000\u0000\u04eb\u04ee\u0001\u0000\u0000\u0000\u04ec\u04ea" + + "\u0001\u0000\u0000\u0000\u04ec\u04ed\u0001\u0000\u0000\u0000\u04ed\u04f0" + + "\u0001\u0000\u0000\u0000\u04ee\u04ec\u0001\u0000\u0000\u0000\u04ef\u04f1" + + "\u0003\u01b3\u00d7\u0000\u04f0\u04ef\u0001\u0000\u0000\u0000\u04f0\u04f1" + + "\u0001\u0000\u0000\u0000\u04f1\u04f2\u0001\u0000\u0000\u0000\u04f2\u04f4" + + "\u0005.\u0000\u0000\u04f3\u04f5\u0005@\u0000\u0000\u04f4\u04f3\u0001\u0000" + + "\u0000\u0000\u04f4\u04f5\u0001\u0000\u0000\u0000\u04f5\u04f6\u0001\u0000" + + "\u0000\u0000\u04f6\u04f7\u0003\u01c3\u00df\u0000\u04f7\u00ea\u0001\u0000" + + "\u0000\u0000\u04f8\u0502\u0007\u0001\u0000\u0000\u04f9\u04fb\u0005_\u0000" + + "\u0000\u04fa\u04f9\u0001\u0000\u0000\u0000\u04fb\u04fe\u0001\u0000\u0000" + + "\u0000\u04fc\u04fa\u0001\u0000\u0000\u0000\u04fc\u04fd\u0001\u0000\u0000" + + "\u0000\u04fd\u04ff\u0001\u0000\u0000\u0000\u04fe\u04fc\u0001\u0000\u0000" + + "\u0000\u04ff\u0501\u0007\u0001\u0000\u0000\u0500\u04fc\u0001\u0000\u0000" + + "\u0000\u0501\u0504\u0001\u0000\u0000\u0000\u0502\u0500\u0001\u0000\u0000" + + "\u0000\u0502\u0503\u0001\u0000\u0000\u0000\u0503\u0506\u0001\u0000\u0000" + + "\u0000\u0504\u0502\u0001\u0000\u0000\u0000\u0505\u0507\u0003\u01b3\u00d7" + + "\u0000\u0506\u0505\u0001\u0000\u0000\u0000\u0506\u0507\u0001\u0000\u0000" + + "\u0000\u0507\u00ec\u0001\u0000\u0000\u0000\u0508\u0509\u00050\u0000\u0000" + + "\u0509\u0511\u0007\u0002\u0000\u0000\u050a\u050c\u0005_\u0000\u0000\u050b" + + "\u050a\u0001\u0000\u0000\u0000\u050c\u050f\u0001\u0000\u0000\u0000\u050d" + + "\u050b\u0001\u0000\u0000\u0000\u050d\u050e\u0001\u0000\u0000\u0000\u050e" + + "\u0510\u0001\u0000\u0000\u0000\u050f\u050d\u0001\u0000\u0000\u0000\u0510" + + "\u0512\u0003\u01d5\u00e8\u0000\u0511\u050d\u0001\u0000\u0000\u0000\u0512" + + "\u0513\u0001\u0000\u0000\u0000\u0513\u0511\u0001\u0000\u0000\u0000\u0513" + + "\u0514\u0001\u0000\u0000\u0000\u0514\u0516\u0001\u0000\u0000\u0000\u0515" + + "\u0517\u0003\u01b3\u00d7\u0000\u0516\u0515\u0001\u0000\u0000\u0000\u0516" + + "\u0517\u0001\u0000\u0000\u0000\u0517\u00ee\u0001\u0000\u0000\u0000\u0518" + + "\u0519\u00050\u0000\u0000\u0519\u0521\u0007\u0003\u0000\u0000\u051a\u051c" + + "\u0005_\u0000\u0000\u051b\u051a\u0001\u0000\u0000\u0000\u051c\u051f\u0001" + + "\u0000\u0000\u0000\u051d\u051b\u0001\u0000\u0000\u0000\u051d\u051e\u0001" + + "\u0000\u0000\u0000\u051e\u0520\u0001\u0000\u0000\u0000\u051f\u051d\u0001" + + "\u0000\u0000\u0000\u0520\u0522\u0007\u0004\u0000\u0000\u0521\u051d\u0001" + + "\u0000\u0000\u0000\u0522\u0523\u0001\u0000\u0000\u0000\u0523\u0521\u0001" + + "\u0000\u0000\u0000\u0523\u0524\u0001\u0000\u0000\u0000\u0524\u0526\u0001" + + "\u0000\u0000\u0000\u0525\u0527\u0003\u01b3\u00d7\u0000\u0526\u0525\u0001" + + "\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u00f0\u0001" + + "\u0000\u0000\u0000\u0528\u0532\u0007\u0001\u0000\u0000\u0529\u052b\u0005" + + "_\u0000\u0000\u052a\u0529\u0001\u0000\u0000\u0000\u052b\u052e\u0001\u0000" + + "\u0000\u0000\u052c\u052a\u0001\u0000\u0000\u0000\u052c\u052d\u0001\u0000" + + "\u0000\u0000\u052d\u052f\u0001\u0000\u0000\u0000\u052e\u052c\u0001\u0000" + + "\u0000\u0000\u052f\u0531\u0007\u0001\u0000\u0000\u0530\u052c\u0001\u0000" + + "\u0000\u0000\u0531\u0534\u0001\u0000\u0000\u0000\u0532\u0530\u0001\u0000" + + "\u0000\u0000\u0532\u0533\u0001\u0000\u0000\u0000\u0533\u0536\u0001\u0000" + + "\u0000\u0000\u0534\u0532\u0001\u0000\u0000\u0000\u0535\u0528\u0001\u0000" + + "\u0000\u0000\u0535\u0536\u0001\u0000\u0000\u0000\u0536\u0537\u0001\u0000" + + "\u0000\u0000\u0537\u0538\u0005.\u0000\u0000\u0538\u0542\u0007\u0001\u0000" + + "\u0000\u0539\u053b\u0005_\u0000\u0000\u053a\u0539\u0001\u0000\u0000\u0000" + + "\u053b\u053e\u0001\u0000\u0000\u0000\u053c\u053a\u0001\u0000\u0000\u0000" + + "\u053c\u053d\u0001\u0000\u0000\u0000\u053d\u053f\u0001\u0000\u0000\u0000" + + "\u053e\u053c\u0001\u0000\u0000\u0000\u053f\u0541\u0007\u0001\u0000\u0000" + + "\u0540\u053c\u0001\u0000\u0000\u0000\u0541\u0544\u0001\u0000\u0000\u0000" + + "\u0542\u0540\u0001\u0000\u0000\u0000\u0542\u0543\u0001\u0000\u0000\u0000" + + "\u0543\u0546\u0001\u0000\u0000\u0000\u0544\u0542\u0001\u0000\u0000\u0000" + + "\u0545\u0547\u0003\u01b5\u00d8\u0000\u0546\u0545\u0001\u0000\u0000\u0000" + + "\u0546\u0547\u0001\u0000\u0000\u0000\u0547\u0549\u0001\u0000\u0000\u0000" + + "\u0548\u054a\u0007\u0005\u0000\u0000\u0549\u0548\u0001\u0000\u0000\u0000" + + "\u0549\u054a\u0001\u0000\u0000\u0000\u054a\u0560\u0001\u0000\u0000\u0000" + + "\u054b\u0555\u0007\u0001\u0000\u0000\u054c\u054e\u0005_\u0000\u0000\u054d" + + "\u054c\u0001\u0000\u0000\u0000\u054e\u0551\u0001\u0000\u0000\u0000\u054f" + + "\u054d\u0001\u0000\u0000\u0000\u054f\u0550\u0001\u0000\u0000\u0000\u0550" + + "\u0552\u0001\u0000\u0000\u0000\u0551\u054f\u0001\u0000\u0000\u0000\u0552" + + "\u0554\u0007\u0001\u0000\u0000\u0553\u054f\u0001\u0000\u0000\u0000\u0554" + + "\u0557\u0001\u0000\u0000\u0000\u0555\u0553\u0001\u0000\u0000\u0000\u0555" + + "\u0556\u0001\u0000\u0000\u0000\u0556\u055d\u0001\u0000\u0000\u0000\u0557" + + "\u0555\u0001\u0000\u0000\u0000\u0558\u055e\u0007\u0005\u0000\u0000\u0559" + + "\u055b\u0003\u01b5\u00d8\u0000\u055a\u055c\u0007\u0005\u0000\u0000\u055b" + + "\u055a\u0001\u0000\u0000\u0000\u055b\u055c\u0001\u0000\u0000\u0000\u055c" + + "\u055e\u0001\u0000\u0000\u0000\u055d\u0558\u0001\u0000\u0000\u0000\u055d" + + "\u0559\u0001\u0000\u0000\u0000\u055e\u0560\u0001\u0000\u0000\u0000\u055f" + + "\u0535\u0001\u0000\u0000\u0000\u055f\u054b\u0001\u0000\u0000\u0000\u0560" + + "\u00f2\u0001\u0000\u0000\u0000\u0561\u0564\u0005\'\u0000\u0000\u0562\u0565" + + "\b\u0006\u0000\u0000\u0563\u0565\u0003\u01b7\u00d9\u0000\u0564\u0562\u0001" + + "\u0000\u0000\u0000\u0564\u0563\u0001\u0000\u0000\u0000\u0565\u0566\u0001" + + "\u0000\u0000\u0000\u0566\u0567\u0005\'\u0000\u0000\u0567\u00f4\u0001\u0000" + + "\u0000\u0000\u0568\u056d\u0005\"\u0000\u0000\u0569\u056c\b\u0007\u0000" + + "\u0000\u056a\u056c\u0003\u01b7\u00d9\u0000\u056b\u0569\u0001\u0000\u0000" + + "\u0000\u056b\u056a\u0001\u0000\u0000\u0000\u056c\u056f\u0001\u0000\u0000" + + "\u0000\u056d\u056b\u0001\u0000\u0000\u0000\u056d\u056e\u0001\u0000\u0000" + + "\u0000\u056e\u0570\u0001\u0000\u0000\u0000\u056f\u056d\u0001\u0000\u0000" + + "\u0000\u0570\u0571\u0005\"\u0000\u0000\u0571\u00f6\u0001\u0000\u0000\u0000" + + "\u0572\u0573\u0005@\u0000\u0000\u0573\u0574\u0005\"\u0000\u0000\u0574" + + "\u057a\u0001\u0000\u0000\u0000\u0575\u0579\b\b\u0000\u0000\u0576\u0577" + + "\u0005\"\u0000\u0000\u0577\u0579\u0005\"\u0000\u0000\u0578\u0575\u0001" + + "\u0000\u0000\u0000\u0578\u0576\u0001\u0000\u0000\u0000\u0579\u057c\u0001" + + "\u0000\u0000\u0000\u057a\u0578\u0001\u0000\u0000\u0000\u057a\u057b\u0001" + + "\u0000\u0000\u0000\u057b\u057d\u0001\u0000\u0000\u0000\u057c\u057a\u0001" + + "\u0000\u0000\u0000\u057d\u057e\u0005\"\u0000\u0000\u057e\u00f8\u0001\u0000" + + "\u0000\u0000\u057f\u0580\u0005$\u0000\u0000\u0580\u0581\u0005\"\u0000" + + "\u0000\u0581\u0582\u0001\u0000\u0000\u0000\u0582\u0583\u0006z\u0003\u0000" + + "\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0585\u0006z\u0004\u0000\u0585" + + "\u00fa\u0001\u0000\u0000\u0000\u0586\u0587\u0005$\u0000\u0000\u0587\u0588" + + "\u0005@\u0000\u0000\u0588\u0589\u0005\"\u0000\u0000\u0589\u058a\u0001" + + "\u0000\u0000\u0000\u058a\u058b\u0006{\u0005\u0000\u058b\u058c\u0001\u0000" + + "\u0000\u0000\u058c\u058d\u0006{\u0004\u0000\u058d\u00fc\u0001\u0000\u0000" + + "\u0000\u058e\u058f\u0005{\u0000\u0000\u058f\u0590\u0006|\u0006\u0000\u0590" + + "\u00fe\u0001\u0000\u0000\u0000\u0591\u0592\u0005}\u0000\u0000\u0592\u0593" + + "\u0006}\u0007\u0000\u0593\u0100\u0001\u0000\u0000\u0000\u0594\u0595\u0005" + + "[\u0000\u0000\u0595\u0102\u0001\u0000\u0000\u0000\u0596\u0597\u0005]\u0000" + + "\u0000\u0597\u0104\u0001\u0000\u0000\u0000\u0598\u0599\u0005(\u0000\u0000" + + "\u0599\u0106\u0001\u0000\u0000\u0000\u059a\u059b\u0005)\u0000\u0000\u059b" + + "\u0108\u0001\u0000\u0000\u0000\u059c\u059d\u0005.\u0000\u0000\u059d\u010a" + + "\u0001\u0000\u0000\u0000\u059e\u059f\u0005,\u0000\u0000\u059f\u010c\u0001" + + "\u0000\u0000\u0000\u05a0\u05a1\u0005:\u0000\u0000\u05a1\u05a2\u0006\u0084" + + "\b\u0000\u05a2\u010e\u0001\u0000\u0000\u0000\u05a3\u05a4\u0005;\u0000" + + "\u0000\u05a4\u0110\u0001\u0000\u0000\u0000\u05a5\u05a6\u0005+\u0000\u0000" + + "\u05a6\u0112\u0001\u0000\u0000\u0000\u05a7\u05a8\u0005-\u0000\u0000\u05a8" + + "\u0114\u0001\u0000\u0000\u0000\u05a9\u05aa\u0005*\u0000\u0000\u05aa\u0116" + + "\u0001\u0000\u0000\u0000\u05ab\u05ac\u0005/\u0000\u0000\u05ac\u0118\u0001" + + "\u0000\u0000\u0000\u05ad\u05ae\u0005%\u0000\u0000\u05ae\u011a\u0001\u0000" + + "\u0000\u0000\u05af\u05b0\u0005&\u0000\u0000\u05b0\u011c\u0001\u0000\u0000" + + "\u0000\u05b1\u05b2\u0005|\u0000\u0000\u05b2\u011e\u0001\u0000\u0000\u0000" + + "\u05b3\u05b4\u0005^\u0000\u0000\u05b4\u0120\u0001\u0000\u0000\u0000\u05b5" + + "\u05b6\u0005!\u0000\u0000\u05b6\u0122\u0001\u0000\u0000\u0000\u05b7\u05b8" + + "\u0005~\u0000\u0000\u05b8\u0124\u0001\u0000\u0000\u0000\u05b9\u05ba\u0005" + + "=\u0000\u0000\u05ba\u0126\u0001\u0000\u0000\u0000\u05bb\u05bc\u0005<\u0000" + + "\u0000\u05bc\u0128\u0001\u0000\u0000\u0000\u05bd\u05be\u0005>\u0000\u0000" + + "\u05be\u012a\u0001\u0000\u0000\u0000\u05bf\u05c0\u0005?\u0000\u0000\u05c0" + + "\u012c\u0001\u0000\u0000\u0000\u05c1\u05c2\u0005:\u0000\u0000\u05c2\u05c3" + + "\u0005:\u0000\u0000\u05c3\u012e\u0001\u0000\u0000\u0000\u05c4\u05c5\u0005" + + "?\u0000\u0000\u05c5\u05c6\u0005?\u0000\u0000\u05c6\u0130\u0001\u0000\u0000" + + "\u0000\u05c7\u05c8\u0005+\u0000\u0000\u05c8\u05c9\u0005+\u0000\u0000\u05c9" + + "\u0132\u0001\u0000\u0000\u0000\u05ca\u05cb\u0005-\u0000\u0000\u05cb\u05cc" + + "\u0005-\u0000\u0000\u05cc\u0134\u0001\u0000\u0000\u0000\u05cd\u05ce\u0005" + + "&\u0000\u0000\u05ce\u05cf\u0005&\u0000\u0000\u05cf\u0136\u0001\u0000\u0000" + + "\u0000\u05d0\u05d1\u0005|\u0000\u0000\u05d1\u05d2\u0005|\u0000\u0000\u05d2" + + "\u0138\u0001\u0000\u0000\u0000\u05d3\u05d4\u0005-\u0000\u0000\u05d4\u05d5" + + "\u0005>\u0000\u0000\u05d5\u013a\u0001\u0000\u0000\u0000\u05d6\u05d7\u0005" + + "=\u0000\u0000\u05d7\u05d8\u0005=\u0000\u0000\u05d8\u013c\u0001\u0000\u0000" + + "\u0000\u05d9\u05da\u0005!\u0000\u0000\u05da\u05db\u0005=\u0000\u0000\u05db" + + "\u013e\u0001\u0000\u0000\u0000\u05dc\u05dd\u0005<\u0000\u0000\u05dd\u05de" + + "\u0005=\u0000\u0000\u05de\u0140\u0001\u0000\u0000\u0000\u05df\u05e0\u0005" + + ">\u0000\u0000\u05e0\u05e1\u0005=\u0000\u0000\u05e1\u0142\u0001\u0000\u0000" + + "\u0000\u05e2\u05e3\u0005+\u0000\u0000\u05e3\u05e4\u0005=\u0000\u0000\u05e4" + + "\u0144\u0001\u0000\u0000\u0000\u05e5\u05e6\u0005-\u0000\u0000\u05e6\u05e7" + + "\u0005=\u0000\u0000\u05e7\u0146\u0001\u0000\u0000\u0000\u05e8\u05e9\u0005" + + "*\u0000\u0000\u05e9\u05ea\u0005=\u0000\u0000\u05ea\u0148\u0001\u0000\u0000" + + "\u0000\u05eb\u05ec\u0005/\u0000\u0000\u05ec\u05ed\u0005=\u0000\u0000\u05ed" + + "\u014a\u0001\u0000\u0000\u0000\u05ee\u05ef\u0005%\u0000\u0000\u05ef\u05f0" + + "\u0005=\u0000\u0000\u05f0\u014c\u0001\u0000\u0000\u0000\u05f1\u05f2\u0005" + + "&\u0000\u0000\u05f2\u05f3\u0005=\u0000\u0000\u05f3\u014e\u0001\u0000\u0000" + + "\u0000\u05f4\u05f5\u0005|\u0000\u0000\u05f5\u05f6\u0005=\u0000\u0000\u05f6" + + "\u0150\u0001\u0000\u0000\u0000\u05f7\u05f8\u0005^\u0000\u0000\u05f8\u05f9" + + "\u0005=\u0000\u0000\u05f9\u0152\u0001\u0000\u0000\u0000\u05fa\u05fb\u0005" + + "<\u0000\u0000\u05fb\u05fc\u0005<\u0000\u0000\u05fc\u0154\u0001\u0000\u0000" + + "\u0000\u05fd\u05fe\u0005<\u0000\u0000\u05fe\u05ff\u0005<\u0000\u0000\u05ff" + + "\u0600\u0005=\u0000\u0000\u0600\u0156\u0001\u0000\u0000\u0000\u0601\u0602" + + "\u0005?\u0000\u0000\u0602\u0603\u0005?\u0000\u0000\u0603\u0604\u0005=" + + "\u0000\u0000\u0604\u0158\u0001\u0000\u0000\u0000\u0605\u0606\u0005.\u0000" + + "\u0000\u0606\u0607\u0005.\u0000\u0000\u0607\u015a\u0001\u0000\u0000\u0000" + + "\u0608\u0609\u0005{\u0000\u0000\u0609\u060a\u0005{\u0000\u0000\u060a\u015c" + + "\u0001\u0000\u0000\u0000\u060b\u060c\u0005{\u0000\u0000\u060c\u060d\u0006" + + "\u00ac\t\u0000\u060d\u060e\u0001\u0000\u0000\u0000\u060e\u060f\u0006\u00ac" + + "\n\u0000\u060f\u0610\u0006\u00ac\u000b\u0000\u0610\u015e\u0001\u0000\u0000" + + "\u0000\u0611\u0612\u0004\u00ad\u0000\u0000\u0612\u0613\u0003\u01b9\u00da" + + "\u0000\u0613\u0160\u0001\u0000\u0000\u0000\u0614\u0615\u0004\u00ae\u0001" + + "\u0000\u0615\u0616\u0005\"\u0000\u0000\u0616\u0617\u0005\"\u0000\u0000" + + "\u0617\u0162\u0001\u0000\u0000\u0000\u0618\u0619\u0005\"\u0000\u0000\u0619" + + "\u061a\u0006\u00af\f\u0000\u061a\u061b\u0001\u0000\u0000\u0000\u061b\u061c" + + "\u0006\u00af\r\u0000\u061c\u0164\u0001\u0000\u0000\u0000\u061d\u061f\u0004" + + "\u00b0\u0002\u0000\u061e\u0620\b\t\u0000\u0000\u061f\u061e\u0001\u0000" + + "\u0000\u0000\u0620\u0621\u0001\u0000\u0000\u0000\u0621\u061f\u0001\u0000" + + "\u0000\u0000\u0621\u0622\u0001\u0000\u0000\u0000\u0622\u0166\u0001\u0000" + + "\u0000\u0000\u0623\u0625\u0004\u00b1\u0003\u0000\u0624\u0626\b\n\u0000" + + "\u0000\u0625\u0624\u0001\u0000\u0000\u0000\u0626\u0627\u0001\u0000\u0000" + + "\u0000\u0627\u0625\u0001\u0000\u0000\u0000\u0627\u0628\u0001\u0000\u0000" + + "\u0000\u0628\u0168\u0001\u0000\u0000\u0000\u0629\u062a\u0005}\u0000\u0000" + + "\u062a\u062b\u0005}\u0000\u0000\u062b\u062c\u0001\u0000\u0000\u0000\u062c" + + "\u062d\u0006\u00b2\u000e\u0000\u062d\u016a\u0001\u0000\u0000\u0000\u062e" + + "\u062f\u0005}\u0000\u0000\u062f\u0630\u0006\u00b3\u000f\u0000\u0630\u0631" + + "\u0001\u0000\u0000\u0000\u0631\u0632\u0006\u00b3\n\u0000\u0632\u0633\u0006" + + "\u00b3\r\u0000\u0633\u016c\u0001\u0000\u0000\u0000\u0634\u0636\b\u000b" + + "\u0000\u0000\u0635\u0634\u0001\u0000\u0000\u0000\u0636\u0637\u0001\u0000" + + "\u0000\u0000\u0637\u0635\u0001\u0000\u0000\u0000\u0637\u0638\u0001\u0000" + + "\u0000\u0000\u0638\u016e\u0001\u0000\u0000\u0000\u0639\u063b\u0003\u01bf" + + "\u00dd\u0000\u063a\u0639\u0001\u0000\u0000\u0000\u063b\u063c\u0001\u0000" + + "\u0000\u0000\u063c\u063a\u0001\u0000\u0000\u0000\u063c\u063d\u0001\u0000" + + "\u0000\u0000\u063d\u063e\u0001\u0000\u0000\u0000\u063e\u063f\u0006\u00b5" + + "\u0001\u0000\u063f\u0170\u0001\u0000\u0000\u0000\u0640\u0642\u0007\u0001" + + "\u0000\u0000\u0641\u0640\u0001\u0000\u0000\u0000\u0642\u0643\u0001\u0000" + + "\u0000\u0000\u0643\u0641\u0001\u0000\u0000\u0000\u0643\u0644\u0001\u0000" + + "\u0000\u0000\u0644\u0645\u0001\u0000\u0000\u0000\u0645\u0646\u0006\u00b6" + + "\u0010\u0000\u0646\u0172\u0001\u0000\u0000\u0000\u0647\u0648\u0005t\u0000" + + "\u0000\u0648\u0649\u0005r\u0000\u0000\u0649\u064a\u0005u\u0000\u0000\u064a" + + "\u064b\u0005e\u0000\u0000\u064b\u064c\u0001\u0000\u0000\u0000\u064c\u064d" + + "\u0006\u00b7\u0010\u0000\u064d\u064e\u0006\u00b7\u0011\u0000\u064e\u0174" + + "\u0001\u0000\u0000\u0000\u064f\u0650\u0005f\u0000\u0000\u0650\u0651\u0005" + + "a\u0000\u0000\u0651\u0652\u0005l\u0000\u0000\u0652\u0653\u0005s\u0000" + + "\u0000\u0653\u0654\u0005e\u0000\u0000\u0654\u0655\u0001\u0000\u0000\u0000" + + "\u0655\u0656\u0006\u00b8\u0010\u0000\u0656\u0657\u0006\u00b8\u0012\u0000" + + "\u0657\u0176\u0001\u0000\u0000\u0000\u0658\u0659\u0005d\u0000\u0000\u0659" + + "\u065a\u0005e\u0000\u0000\u065a\u065b\u0005f\u0000\u0000\u065b\u065c\u0005" + + "i\u0000\u0000\u065c\u065d\u0005n\u0000\u0000\u065d\u065e\u0005e\u0000" + + "\u0000\u065e\u065f\u0001\u0000\u0000\u0000\u065f\u0660\u0006\u00b9\u0010" + + "\u0000\u0660\u0178\u0001\u0000\u0000\u0000\u0661\u0662\u0005u\u0000\u0000" + + "\u0662\u0663\u0005n\u0000\u0000\u0663\u0664\u0005d\u0000\u0000\u0664\u0665" + + "\u0005e\u0000\u0000\u0665\u0666\u0005f\u0000\u0000\u0666\u0667\u0001\u0000" + + "\u0000\u0000\u0667\u0668\u0006\u00ba\u0010\u0000\u0668\u017a\u0001\u0000" + + "\u0000\u0000\u0669\u066a\u0005i\u0000\u0000\u066a\u066b\u0005f\u0000\u0000" + + "\u066b\u066c\u0001\u0000\u0000\u0000\u066c\u066d\u0006\u00bb\u0010\u0000" + + "\u066d\u066e\u0006\u00bb\u0013\u0000\u066e\u017c\u0001\u0000\u0000\u0000" + + "\u066f\u0670\u0005e\u0000\u0000\u0670\u0671\u0005l\u0000\u0000\u0671\u0672" + + "\u0005i\u0000\u0000\u0672\u0673\u0005f\u0000\u0000\u0673\u0674\u0001\u0000" + + "\u0000\u0000\u0674\u0675\u0006\u00bc\u0010\u0000\u0675\u017e\u0001\u0000" + + "\u0000\u0000\u0676\u0677\u0005e\u0000\u0000\u0677\u0678\u0005l\u0000\u0000" + + "\u0678\u0679\u0005s\u0000\u0000\u0679\u067a\u0005e\u0000\u0000\u067a\u067b" + + "\u0001\u0000\u0000\u0000\u067b\u067c\u0006\u00bd\u0010\u0000\u067c\u067d" + + "\u0006\u00bd\u0014\u0000\u067d\u0180\u0001\u0000\u0000\u0000\u067e\u067f" + + "\u0005e\u0000\u0000\u067f\u0680\u0005n\u0000\u0000\u0680\u0681\u0005d" + + "\u0000\u0000\u0681\u0682\u0005i\u0000\u0000\u0682\u0683\u0005f\u0000\u0000" + + "\u0683\u0684\u0001\u0000\u0000\u0000\u0684\u0685\u0006\u00be\u0010\u0000" + + "\u0685\u0182\u0001\u0000\u0000\u0000\u0686\u0687\u0005l\u0000\u0000\u0687" + + "\u0688\u0005i\u0000\u0000\u0688\u0689\u0005n\u0000\u0000\u0689\u068a\u0005" + + "e\u0000\u0000\u068a\u068b\u0001\u0000\u0000\u0000\u068b\u068c\u0006\u00bf" + + "\u0010\u0000\u068c\u0184\u0001\u0000\u0000\u0000\u068d\u068e\u0005e\u0000" + + "\u0000\u068e\u068f\u0005r\u0000\u0000\u068f\u0690\u0005r\u0000\u0000\u0690" + + "\u0691\u0005o\u0000\u0000\u0691\u0692\u0005r\u0000\u0000\u0692\u0694\u0001" + + "\u0000\u0000\u0000\u0693\u0695\u0003\u01bf\u00dd\u0000\u0694\u0693\u0001" + + "\u0000\u0000\u0000\u0695\u0696\u0001\u0000\u0000\u0000\u0696\u0694\u0001" + + "\u0000\u0000\u0000\u0696\u0697\u0001\u0000\u0000\u0000\u0697\u0698\u0001" + + "\u0000\u0000\u0000\u0698\u0699\u0006\u00c0\u0010\u0000\u0699\u069a\u0006" + + "\u00c0\u0015\u0000\u069a\u0186\u0001\u0000\u0000\u0000\u069b\u069c\u0005" + + "w\u0000\u0000\u069c\u069d\u0005a\u0000\u0000\u069d\u069e\u0005r\u0000" + + "\u0000\u069e\u069f\u0005n\u0000\u0000\u069f\u06a0\u0005i\u0000\u0000\u06a0" + + "\u06a1\u0005n\u0000\u0000\u06a1\u06a2\u0005g\u0000\u0000\u06a2\u06a4\u0001" + + "\u0000\u0000\u0000\u06a3\u06a5\u0003\u01bf\u00dd\u0000\u06a4\u06a3\u0001" + + "\u0000\u0000\u0000\u06a5\u06a6\u0001\u0000\u0000\u0000\u06a6\u06a4\u0001" + + "\u0000\u0000\u0000\u06a6\u06a7\u0001\u0000\u0000\u0000\u06a7\u06a8\u0001" + + "\u0000\u0000\u0000\u06a8\u06a9\u0006\u00c1\u0010\u0000\u06a9\u06aa\u0006" + + "\u00c1\u0015\u0000\u06aa\u0188\u0001\u0000\u0000\u0000\u06ab\u06ac\u0005" + + "r\u0000\u0000\u06ac\u06ad\u0005e\u0000\u0000\u06ad\u06ae\u0005g\u0000" + + "\u0000\u06ae\u06af\u0005i\u0000\u0000\u06af\u06b0\u0005o\u0000\u0000\u06b0" + + "\u06b1\u0005n\u0000\u0000\u06b1\u06b5\u0001\u0000\u0000\u0000\u06b2\u06b4" + + "\u0003\u01bf\u00dd\u0000\u06b3\u06b2\u0001\u0000\u0000\u0000\u06b4\u06b7" + + "\u0001\u0000\u0000\u0000\u06b5\u06b3\u0001\u0000\u0000\u0000\u06b5\u06b6" + + "\u0001\u0000\u0000\u0000\u06b6\u06b8\u0001\u0000\u0000\u0000\u06b7\u06b5" + + "\u0001\u0000\u0000\u0000\u06b8\u06b9\u0006\u00c2\u0010\u0000\u06b9\u06ba" + + "\u0006\u00c2\u0015\u0000\u06ba\u018a\u0001\u0000\u0000\u0000\u06bb\u06bc" + + "\u0005e\u0000\u0000\u06bc\u06bd\u0005n\u0000\u0000\u06bd\u06be\u0005d" + + "\u0000\u0000\u06be\u06bf\u0005r\u0000\u0000\u06bf\u06c0\u0005e\u0000\u0000" + + "\u06c0\u06c1\u0005g\u0000\u0000\u06c1\u06c2\u0005i\u0000\u0000\u06c2\u06c3" + + "\u0005o\u0000\u0000\u06c3\u06c4\u0005n\u0000\u0000\u06c4\u06c8\u0001\u0000" + + "\u0000\u0000\u06c5\u06c7\u0003\u01bf\u00dd\u0000\u06c6\u06c5\u0001\u0000" + + "\u0000\u0000\u06c7\u06ca\u0001\u0000\u0000\u0000\u06c8\u06c6\u0001\u0000" + + "\u0000\u0000\u06c8\u06c9\u0001\u0000\u0000\u0000\u06c9\u06cb\u0001\u0000" + + "\u0000\u0000\u06ca\u06c8\u0001\u0000\u0000\u0000\u06cb\u06cc\u0006\u00c3" + + "\u0010\u0000\u06cc\u06cd\u0006\u00c3\u0015\u0000\u06cd\u018c\u0001\u0000" + + "\u0000\u0000\u06ce\u06cf\u0005p\u0000\u0000\u06cf\u06d0\u0005r\u0000\u0000" + + "\u06d0\u06d1\u0005a\u0000\u0000\u06d1\u06d2\u0005g\u0000\u0000\u06d2\u06d3" + + "\u0005m\u0000\u0000\u06d3\u06d4\u0005a\u0000\u0000\u06d4\u06d6\u0001\u0000" + + "\u0000\u0000\u06d5\u06d7\u0003\u01bf\u00dd\u0000\u06d6\u06d5\u0001\u0000" + + "\u0000\u0000\u06d7\u06d8\u0001\u0000\u0000\u0000\u06d8\u06d6\u0001\u0000" + + "\u0000\u0000\u06d8\u06d9\u0001\u0000\u0000\u0000\u06d9\u06da\u0001\u0000" + + "\u0000\u0000\u06da\u06db\u0006\u00c4\u0010\u0000\u06db\u06dc\u0006\u00c4" + + "\u0015\u0000\u06dc\u018e\u0001\u0000\u0000\u0000\u06dd\u06de\u0005n\u0000" + + "\u0000\u06de\u06df\u0005u\u0000\u0000\u06df\u06e0\u0005l\u0000\u0000\u06e0" + + "\u06e1\u0005l\u0000\u0000\u06e1\u06e2\u0005a\u0000\u0000\u06e2\u06e3\u0005" + + "b\u0000\u0000\u06e3\u06e4\u0005l\u0000\u0000\u06e4\u06e5\u0005e\u0000" + + "\u0000\u06e5\u06e7\u0001\u0000\u0000\u0000\u06e6\u06e8\u0003\u01bf\u00dd" + + "\u0000\u06e7\u06e6\u0001\u0000\u0000\u0000\u06e8\u06e9\u0001\u0000\u0000" + + "\u0000\u06e9\u06e7\u0001\u0000\u0000\u0000\u06e9\u06ea\u0001\u0000\u0000" + + "\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ec\u0006\u00c5\u0010" + + "\u0000\u06ec\u06ed\u0006\u00c5\u0015\u0000\u06ed\u0190\u0001\u0000\u0000" + + "\u0000\u06ee\u06ef\u0005d\u0000\u0000\u06ef\u06f0\u0005e\u0000\u0000\u06f0" + + "\u06f1\u0005f\u0000\u0000\u06f1\u06f2\u0005a\u0000\u0000\u06f2\u06f3\u0005" + + "u\u0000\u0000\u06f3\u06f4\u0005l\u0000\u0000\u06f4\u06f5\u0005t\u0000" + + "\u0000\u06f5\u06f6\u0001\u0000\u0000\u0000\u06f6\u06f7\u0006\u00c6\u0010" + + "\u0000\u06f7\u06f8\u0006\u00c6\u0016\u0000\u06f8\u0192\u0001\u0000\u0000" + + "\u0000\u06f9\u06fa\u0005h\u0000\u0000\u06fa\u06fb\u0005i\u0000\u0000\u06fb" + + "\u06fc\u0005d\u0000\u0000\u06fc\u06fd\u0005d\u0000\u0000\u06fd\u06fe\u0005" + + "e\u0000\u0000\u06fe\u06ff\u0005n\u0000\u0000\u06ff\u0700\u0001\u0000\u0000" + + "\u0000\u0700\u0701\u0006\u00c7\u0010\u0000\u0701\u0194\u0001\u0000\u0000" + + "\u0000\u0702\u0703\u0005(\u0000\u0000\u0703\u0704\u0001\u0000\u0000\u0000" + + "\u0704\u0705\u0006\u00c8\u0010\u0000\u0705\u0706\u0006\u00c8\u0017\u0000" + + "\u0706\u0196\u0001\u0000\u0000\u0000\u0707\u0708\u0005)\u0000\u0000\u0708" + + "\u0709\u0001\u0000\u0000\u0000\u0709\u070a\u0006\u00c9\u0010\u0000\u070a" + + "\u070b\u0006\u00c9\u0018\u0000\u070b\u0198\u0001\u0000\u0000\u0000\u070c" + + "\u070d\u0005!\u0000\u0000\u070d\u070e\u0001\u0000\u0000\u0000\u070e\u070f" + + "\u0006\u00ca\u0010\u0000\u070f\u0710\u0006\u00ca\u0019\u0000\u0710\u019a" + + "\u0001\u0000\u0000\u0000\u0711\u0712\u0005=\u0000\u0000\u0712\u0713\u0005" + + "=\u0000\u0000\u0713\u0714\u0001\u0000\u0000\u0000\u0714\u0715\u0006\u00cb" + + "\u0010\u0000\u0715\u0716\u0006\u00cb\u001a\u0000\u0716\u019c\u0001\u0000" + + "\u0000\u0000\u0717\u0718\u0005!\u0000\u0000\u0718\u0719\u0005=\u0000\u0000" + + "\u0719\u071a\u0001\u0000\u0000\u0000\u071a\u071b\u0006\u00cc\u0010\u0000" + + "\u071b\u071c\u0006\u00cc\u001b\u0000\u071c\u019e\u0001\u0000\u0000\u0000" + + "\u071d\u071e\u0005&\u0000\u0000\u071e\u071f\u0005&\u0000\u0000\u071f\u0720" + + "\u0001\u0000\u0000\u0000\u0720\u0721\u0006\u00cd\u0010\u0000\u0721\u0722" + + "\u0006\u00cd\u001c\u0000\u0722\u01a0\u0001\u0000\u0000\u0000\u0723\u0724" + + "\u0005|\u0000\u0000\u0724\u0725\u0005|\u0000\u0000\u0725\u0726\u0001\u0000" + + "\u0000\u0000\u0726\u0727\u0006\u00ce\u0010\u0000\u0727\u0728\u0006\u00ce" + + "\u001d\u0000\u0728\u01a2\u0001\u0000\u0000\u0000\u0729\u072d\u0005\"\u0000" + + "\u0000\u072a\u072c\b\f\u0000\u0000\u072b\u072a\u0001\u0000\u0000\u0000" + + "\u072c\u072f\u0001\u0000\u0000\u0000\u072d\u072b\u0001\u0000\u0000\u0000" + + "\u072d\u072e\u0001\u0000\u0000\u0000\u072e\u0730\u0001\u0000\u0000\u0000" + + "\u072f\u072d\u0001\u0000\u0000\u0000\u0730\u0731\u0005\"\u0000\u0000\u0731" + + "\u0732\u0001\u0000\u0000\u0000\u0732\u0733\u0006\u00cf\u0010\u0000\u0733" + + "\u0734\u0006\u00cf\u001e\u0000\u0734\u01a4\u0001\u0000\u0000\u0000\u0735" + + "\u0736\u0003\u01c3\u00df\u0000\u0736\u0737\u0001\u0000\u0000\u0000\u0737" + + "\u0738\u0006\u00d0\u0010\u0000\u0738\u01a6\u0001\u0000\u0000\u0000\u0739" + + "\u073a\u0005/\u0000\u0000\u073a\u073b\u0005/\u0000\u0000\u073b\u073f\u0001" + + "\u0000\u0000\u0000\u073c\u073e\b\r\u0000\u0000\u073d\u073c\u0001\u0000" + + "\u0000\u0000\u073e\u0741\u0001\u0000\u0000\u0000\u073f\u073d\u0001\u0000" + + "\u0000\u0000\u073f\u0740\u0001\u0000\u0000\u0000\u0740\u0742\u0001\u0000" + + "\u0000\u0000\u0741\u073f\u0001\u0000\u0000\u0000\u0742\u0743\u0006\u00d1" + + "\u0000\u0000\u0743\u0744\u0006\u00d1\u001f\u0000\u0744\u01a8\u0001\u0000" + + "\u0000\u0000\u0745\u0746\u0003\u01bd\u00dc\u0000\u0746\u0747\u0001\u0000" + + "\u0000\u0000\u0747\u0748\u0006\u00d2\u0010\u0000\u0748\u0749\u0006\u00d2" + + " \u0000\u0749\u01aa\u0001\u0000\u0000\u0000\u074a\u074c\b\r\u0000\u0000" + + "\u074b\u074a\u0001\u0000\u0000\u0000\u074c\u074d\u0001\u0000\u0000\u0000" + + "\u074d\u074b\u0001\u0000\u0000\u0000\u074d\u074e\u0001\u0000\u0000\u0000" + + "\u074e\u074f\u0001\u0000\u0000\u0000\u074f\u0750\u0006\u00d3\u0010\u0000" + + "\u0750\u01ac\u0001\u0000\u0000\u0000\u0751\u0752\u0003\u01bd\u00dc\u0000" + + "\u0752\u0753\u0001\u0000\u0000\u0000\u0753\u0754\u0006\u00d4\u0010\u0000" + + "\u0754\u0755\u0006\u00d4!\u0000\u0755\u0756\u0006\u00d4 \u0000\u0756\u01ae" + + "\u0001\u0000\u0000\u0000\u0757\u0758\b\r\u0000\u0000\u0758\u01b0\u0001" + + "\u0000\u0000\u0000\u0759\u075a\u0007\r\u0000\u0000\u075a\u01b2\u0001\u0000" + + "\u0000\u0000\u075b\u075d\u0007\u000e\u0000\u0000\u075c\u075b\u0001\u0000" + + "\u0000\u0000\u075c\u075d\u0001\u0000\u0000\u0000\u075d\u075e\u0001\u0000" + + "\u0000\u0000\u075e\u0764\u0007\u000f\u0000\u0000\u075f\u0761\u0007\u000f" + + "\u0000\u0000\u0760\u075f\u0001\u0000\u0000\u0000\u0760\u0761\u0001\u0000" + + "\u0000\u0000\u0761\u0762\u0001\u0000\u0000\u0000\u0762\u0764\u0007\u000e" + + "\u0000\u0000\u0763\u075c\u0001\u0000\u0000\u0000\u0763\u0760\u0001\u0000" + + "\u0000\u0000\u0764\u01b4\u0001\u0000\u0000\u0000\u0765\u0767\u0007\u0010" + + "\u0000\u0000\u0766\u0768\u0007\u0011\u0000\u0000\u0767\u0766\u0001\u0000" + + "\u0000\u0000\u0767\u0768\u0001\u0000\u0000\u0000\u0768\u0769\u0001\u0000" + + "\u0000\u0000\u0769\u0773\u0007\u0001\u0000\u0000\u076a\u076c\u0005_\u0000" + + "\u0000\u076b\u076a\u0001\u0000\u0000\u0000\u076c\u076f\u0001\u0000\u0000" + + "\u0000\u076d\u076b\u0001\u0000\u0000\u0000\u076d\u076e\u0001\u0000\u0000" + + "\u0000\u076e\u0770\u0001\u0000\u0000\u0000\u076f\u076d\u0001\u0000\u0000" + + "\u0000\u0770\u0772\u0007\u0001\u0000\u0000\u0771\u076d\u0001\u0000\u0000" + + "\u0000\u0772\u0775\u0001\u0000\u0000\u0000\u0773\u0771\u0001\u0000\u0000" + + "\u0000\u0773\u0774\u0001\u0000\u0000\u0000\u0774\u01b6\u0001\u0000\u0000" + + "\u0000\u0775\u0773\u0001\u0000\u0000\u0000\u0776\u077a\u0003\u01b9\u00da" + + "\u0000\u0777\u077a\u0003\u01bb\u00db\u0000\u0778\u077a\u0003\u01d3\u00e7" + + "\u0000\u0779\u0776\u0001\u0000\u0000\u0000\u0779\u0777\u0001\u0000\u0000" + + "\u0000\u0779\u0778\u0001\u0000\u0000\u0000\u077a\u01b8\u0001\u0000\u0000" + + "\u0000\u077b\u077c\u0005\\\u0000\u0000\u077c\u0792\u0005\'\u0000\u0000" + + "\u077d\u077e\u0005\\\u0000\u0000\u077e\u0792\u0005\"\u0000\u0000\u077f" + + "\u0780\u0005\\\u0000\u0000\u0780\u0792\u0005\\\u0000\u0000\u0781\u0782" + + "\u0005\\\u0000\u0000\u0782\u0792\u00050\u0000\u0000\u0783\u0784\u0005" + + "\\\u0000\u0000\u0784\u0792\u0005a\u0000\u0000\u0785\u0786\u0005\\\u0000" + + "\u0000\u0786\u0792\u0005b\u0000\u0000\u0787\u0788\u0005\\\u0000\u0000" + + "\u0788\u0792\u0005f\u0000\u0000\u0789\u078a\u0005\\\u0000\u0000\u078a" + + "\u0792\u0005n\u0000\u0000\u078b\u078c\u0005\\\u0000\u0000\u078c\u0792" + + "\u0005r\u0000\u0000\u078d\u078e\u0005\\\u0000\u0000\u078e\u0792\u0005" + + "t\u0000\u0000\u078f\u0790\u0005\\\u0000\u0000\u0790\u0792\u0005v\u0000" + + "\u0000\u0791\u077b\u0001\u0000\u0000\u0000\u0791\u077d\u0001\u0000\u0000" + + "\u0000\u0791\u077f\u0001\u0000\u0000\u0000\u0791\u0781\u0001\u0000\u0000" + + "\u0000\u0791\u0783\u0001\u0000\u0000\u0000\u0791\u0785\u0001\u0000\u0000" + + "\u0000\u0791\u0787\u0001\u0000\u0000\u0000\u0791\u0789\u0001\u0000\u0000" + + "\u0000\u0791\u078b\u0001\u0000\u0000\u0000\u0791\u078d\u0001\u0000\u0000" + + "\u0000\u0791\u078f\u0001\u0000\u0000\u0000\u0792\u01ba\u0001\u0000\u0000" + + "\u0000\u0793\u0794\u0005\\\u0000\u0000\u0794\u0795\u0005x\u0000\u0000" + + "\u0795\u0796\u0001\u0000\u0000\u0000\u0796\u07ad\u0003\u01d5\u00e8\u0000" + + "\u0797\u0798\u0005\\\u0000\u0000\u0798\u0799\u0005x\u0000\u0000\u0799" + + "\u079a\u0001\u0000\u0000\u0000\u079a\u079b\u0003\u01d5\u00e8\u0000\u079b" + + "\u079c\u0003\u01d5\u00e8\u0000\u079c\u07ad\u0001\u0000\u0000\u0000\u079d" + + "\u079e\u0005\\\u0000\u0000\u079e\u079f\u0005x\u0000\u0000\u079f\u07a0" + + "\u0001\u0000\u0000\u0000\u07a0\u07a1\u0003\u01d5\u00e8\u0000\u07a1\u07a2" + + "\u0003\u01d5\u00e8\u0000\u07a2\u07a3\u0003\u01d5\u00e8\u0000\u07a3\u07ad" + + "\u0001\u0000\u0000\u0000\u07a4\u07a5\u0005\\\u0000\u0000\u07a5\u07a6\u0005" + + "x\u0000\u0000\u07a6\u07a7\u0001\u0000\u0000\u0000\u07a7\u07a8\u0003\u01d5" + + "\u00e8\u0000\u07a8\u07a9\u0003\u01d5\u00e8\u0000\u07a9\u07aa\u0003\u01d5" + + "\u00e8\u0000\u07aa\u07ab\u0003\u01d5\u00e8\u0000\u07ab\u07ad\u0001\u0000" + + "\u0000\u0000\u07ac\u0793\u0001\u0000\u0000\u0000\u07ac\u0797\u0001\u0000" + + "\u0000\u0000\u07ac\u079d\u0001\u0000\u0000\u0000\u07ac\u07a4\u0001\u0000" + + "\u0000\u0000\u07ad\u01bc\u0001\u0000\u0000\u0000\u07ae\u07af\u0005\r\u0000" + + "\u0000\u07af\u07b2\u0005\n\u0000\u0000\u07b0\u07b2\u0007\r\u0000\u0000" + + "\u07b1\u07ae\u0001\u0000\u0000\u0000\u07b1\u07b0\u0001\u0000\u0000\u0000" + + "\u07b2\u01be\u0001\u0000\u0000\u0000\u07b3\u07b6\u0003\u01c1\u00de\u0000" + + "\u07b4\u07b6\u0007\u0012\u0000\u0000\u07b5\u07b3\u0001\u0000\u0000\u0000" + + "\u07b5\u07b4\u0001\u0000\u0000\u0000\u07b6\u01c0\u0001\u0000\u0000\u0000" + + "\u07b7\u07b8\u0007\u0013\u0000\u0000\u07b8\u01c2\u0001\u0000\u0000\u0000" + + "\u07b9\u07bd\u0003\u01c5\u00e0\u0000\u07ba\u07bc\u0003\u01c7\u00e1\u0000" + + "\u07bb\u07ba\u0001\u0000\u0000\u0000\u07bc\u07bf\u0001\u0000\u0000\u0000" + + "\u07bd\u07bb\u0001\u0000\u0000\u0000\u07bd\u07be\u0001\u0000\u0000\u0000" + + "\u07be\u01c4\u0001\u0000\u0000\u0000\u07bf\u07bd\u0001\u0000\u0000\u0000" + + "\u07c0\u07c3\u0003\u01c9\u00e2\u0000\u07c1\u07c3\u0005_\u0000\u0000\u07c2" + + "\u07c0\u0001\u0000\u0000\u0000\u07c2\u07c1\u0001\u0000\u0000\u0000\u07c3" + + "\u01c6\u0001\u0000\u0000\u0000\u07c4\u07ca\u0003\u01c9\u00e2\u0000\u07c5" + + "\u07ca\u0003\u01cb\u00e3\u0000\u07c6\u07ca\u0003\u01cd\u00e4\u0000\u07c7" + + "\u07ca\u0003\u01cf\u00e5\u0000\u07c8\u07ca\u0003\u01d1\u00e6\u0000\u07c9" + + "\u07c4\u0001\u0000\u0000\u0000\u07c9\u07c5\u0001\u0000\u0000\u0000\u07c9" + + "\u07c6\u0001\u0000\u0000\u0000\u07c9\u07c7\u0001\u0000\u0000\u0000\u07c9" + + "\u07c8\u0001\u0000\u0000\u0000\u07ca\u01c8\u0001\u0000\u0000\u0000\u07cb" + + "\u07d3\u0003\u01d7\u00e9\u0000\u07cc\u07d3\u0003\u01d9\u00ea\u0000\u07cd" + + "\u07d3\u0003\u01db\u00eb\u0000\u07ce\u07d3\u0003\u01dd\u00ec\u0000\u07cf" + + "\u07d3\u0003\u01df\u00ed\u0000\u07d0\u07d3\u0003\u01e1\u00ee\u0000\u07d1" + + "\u07d3\u0003\u01d3\u00e7\u0000\u07d2\u07cb\u0001\u0000\u0000\u0000\u07d2" + + "\u07cc\u0001\u0000\u0000\u0000\u07d2\u07cd\u0001\u0000\u0000\u0000\u07d2" + + "\u07ce\u0001\u0000\u0000\u0000\u07d2\u07cf\u0001\u0000\u0000\u0000\u07d2" + + "\u07d0\u0001\u0000\u0000\u0000\u07d2\u07d1\u0001\u0000\u0000\u0000\u07d3" + + "\u01ca\u0001\u0000\u0000\u0000\u07d4\u07d7\u0003\u01eb\u00f3\u0000\u07d5" + + "\u07d7\u0003\u01d3\u00e7\u0000\u07d6\u07d4\u0001\u0000\u0000\u0000\u07d6" + + "\u07d5\u0001\u0000\u0000\u0000\u07d7\u01cc\u0001\u0000\u0000\u0000\u07d8" + + "\u07db\u0003\u01e9\u00f2\u0000\u07d9\u07db\u0003\u01d3\u00e7\u0000\u07da" + + "\u07d8\u0001\u0000\u0000\u0000\u07da\u07d9\u0001\u0000\u0000\u0000\u07db" + + "\u01ce\u0001\u0000\u0000\u0000\u07dc\u07e0\u0003\u01e3\u00ef\u0000\u07dd" + + "\u07e0\u0003\u01e5\u00f0\u0000\u07de\u07e0\u0003\u01d3\u00e7\u0000\u07df" + + "\u07dc\u0001\u0000\u0000\u0000\u07df\u07dd\u0001\u0000\u0000\u0000\u07df" + + "\u07de\u0001\u0000\u0000\u0000\u07e0\u01d0\u0001\u0000\u0000\u0000\u07e1" + + "\u07e4\u0003\u01e7\u00f1\u0000\u07e2\u07e4\u0003\u01d3\u00e7\u0000\u07e3" + + "\u07e1\u0001\u0000\u0000\u0000\u07e3\u07e2\u0001\u0000\u0000\u0000\u07e4" + + "\u01d2\u0001\u0000\u0000\u0000\u07e5\u07e6\u0005\\\u0000\u0000\u07e6\u07e7" + + "\u0005u\u0000\u0000\u07e7\u07e8\u0001\u0000\u0000\u0000\u07e8\u07e9\u0003" + + "\u01d5\u00e8\u0000\u07e9\u07ea\u0003\u01d5\u00e8\u0000\u07ea\u07eb\u0003" + + "\u01d5\u00e8\u0000\u07eb\u07ec\u0003\u01d5\u00e8\u0000\u07ec\u07fa\u0001" + + "\u0000\u0000\u0000\u07ed\u07ee\u0005\\\u0000\u0000\u07ee\u07ef\u0005U" + + "\u0000\u0000\u07ef\u07f0\u0001\u0000\u0000\u0000\u07f0\u07f1\u0003\u01d5" + + "\u00e8\u0000\u07f1\u07f2\u0003\u01d5\u00e8\u0000\u07f2\u07f3\u0003\u01d5" + + "\u00e8\u0000\u07f3\u07f4\u0003\u01d5\u00e8\u0000\u07f4\u07f5\u0003\u01d5" + + "\u00e8\u0000\u07f5\u07f6\u0003\u01d5\u00e8\u0000\u07f6\u07f7\u0003\u01d5" + + "\u00e8\u0000\u07f7\u07f8\u0003\u01d5\u00e8\u0000\u07f8\u07fa\u0001\u0000" + + "\u0000\u0000\u07f9\u07e5\u0001\u0000\u0000\u0000\u07f9\u07ed\u0001\u0000" + + "\u0000\u0000\u07fa\u01d4\u0001\u0000\u0000\u0000\u07fb\u07fd\u0007\u0014" + + "\u0000\u0000\u07fc\u07fb\u0001\u0000\u0000\u0000\u07fd\u01d6\u0001\u0000" + + "\u0000\u0000\u07fe\u07ff\u0007\u0015\u0000\u0000\u07ff\u01d8\u0001\u0000" + + "\u0000\u0000\u0800\u0801\u0007\u0016\u0000\u0000\u0801\u01da\u0001\u0000" + + "\u0000\u0000\u0802\u0803\u0007\u0017\u0000\u0000\u0803\u01dc\u0001\u0000" + + "\u0000\u0000\u0804\u0805\u0007\u0018\u0000\u0000\u0805\u01de\u0001\u0000" + + "\u0000\u0000\u0806\u0807\u0007\u0019\u0000\u0000\u0807\u01e0\u0001\u0000" + + "\u0000\u0000\u0808\u0809\u0007\u001a\u0000\u0000\u0809\u01e2\u0001\u0000" + + "\u0000\u0000\u080a\u080b\u0002\u0300\u0310\u0000\u080b\u01e4\u0001\u0000" + + "\u0000\u0000\u080c\u080d\u0007\u001b\u0000\u0000\u080d\u01e6\u0001\u0000" + + "\u0000\u0000\u080e\u080f\u0007\u001c\u0000\u0000\u080f\u01e8\u0001\u0000" + + "\u0000\u0000\u0810\u0811\u0007\u001d\u0000\u0000\u0811\u01ea\u0001\u0000" + + "\u0000\u0000\u0812\u0813\u0007\u001e\u0000\u0000\u0813\u01ec\u0001\u0000" + + "\u0000\u0000M\u0000\u0001\u0002\u0003\u0004\u01f8\u020d\u021b\u0226\u0230" + + "\u0232\u04de\u04e6\u04ec\u04f0\u04f4\u04fc\u0502\u0506\u050d\u0513\u0516" + + "\u051d\u0523\u0526\u052c\u0532\u0535\u053c\u0542\u0546\u0549\u054f\u0555" + + "\u055b\u055d\u055f\u0564\u056b\u056d\u0578\u057a\u0621\u0627\u0637\u063c" + + "\u0643\u0696\u06a6\u06b5\u06c8\u06d8\u06e9\u072d\u073f\u074d\u075c\u0760" + + "\u0763\u0767\u076d\u0773\u0779\u0791\u07ac\u07b1\u07b5\u07bd\u07c2\u07c9" + + "\u07d2\u07d6\u07da\u07df\u07e3\u07f9\u07fc\"\u0000\u0002\u0000\u0000\u0001" + + "\u0000\u0002\u0003\u0000\u0001z\u0000\u0005\u0001\u0000\u0001{\u0001\u0001" + + "|\u0002\u0001}\u0003\u0001\u0084\u0004\u0001\u00ac\u0005\u0006\u0000\u0000" + + "\u0005\u0000\u0000\u0001\u00af\u0006\u0004\u0000\u0000\u0007\u00b4\u0000" + + "\u0001\u00b3\u0007\u0000\u0003\u0000\u0007`\u0000\u0007*\u0000\u00074" + + "\u0000\u0007$\u0000\u0002\u0004\u0000\u0007\u001e\u0000\u0007\u0081\u0000" + + "\u0007\u0082\u0000\u0007\u008f\u0000\u0007\u009c\u0000\u0007\u009d\u0000" + + "\u0007\u0099\u0000\u0007\u009a\u0000\u0007[\u0000\u0007\u0005\u0000\u0002" + + "\u0000\u0000\u0007\u00c4\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.tokens b/src/main/java/CSharpLexer.tokens similarity index 100% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.tokens rename to src/main/java/CSharpLexer.tokens diff --git a/src/main/java/CSharpParser.interp b/src/main/java/CSharpParser.interp new file mode 100644 index 0000000..764f628 --- /dev/null +++ b/src/main/java/CSharpParser.interp @@ -0,0 +1,625 @@ +token literal names: +null +'\u00EF\u00BB\u00BF' +null +'/***/' +null +null +null +null +'#' +'abstract' +'add' +'alias' +'__arglist' +'as' +'ascending' +'async' +'await' +'base' +'bool' +'break' +'by' +'byte' +'case' +'catch' +'char' +'checked' +'class' +'const' +'continue' +'decimal' +'default' +'delegate' +'descending' +'do' +'double' +'dynamic' +'else' +'enum' +'equals' +'event' +'explicit' +'extern' +'false' +'finally' +'fixed' +'float' +'for' +'foreach' +'from' +'get' +'goto' +'group' +'if' +'implicit' +'in' +'int' +'interface' +'internal' +'into' +'is' +'join' +'let' +'lock' +'long' +'nameof' +'namespace' +'new' +'null' +'object' +'on' +'operator' +'orderby' +'out' +'override' +'params' +'partial' +'private' +'protected' +'public' +'readonly' +'ref' +'remove' +'return' +'sbyte' +'sealed' +'select' +'set' +'short' +'sizeof' +'stackalloc' +'static' +'string' +'struct' +'switch' +'this' +'throw' +'true' +'try' +'typeof' +'uint' +'ulong' +'unchecked' +'unmanaged' +'unsafe' +'ushort' +'using' +'var' +'virtual' +'void' +'volatile' +'when' +'where' +'while' +'yield' +null +null +null +null +null +null +null +null +null +null +null +'{' +'}' +'[' +']' +'(' +')' +'.' +',' +':' +';' +'+' +'-' +'*' +'/' +'%' +'&' +'|' +'^' +'!' +'~' +'=' +'<' +'>' +'?' +'::' +'??' +'++' +'--' +'&&' +'||' +'->' +'==' +'!=' +'<=' +'>=' +'+=' +'-=' +'*=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<' +'<<=' +'??=' +'..' +'{{' +null +null +null +null +null +null +null +null +null +null +'define' +'undef' +'elif' +'endif' +'line' +null +null +null +null +null +null +'hidden' +null +null +null +'}}' + +token symbolic names: +null +BYTE_ORDER_MARK +SINGLE_LINE_DOC_COMMENT +EMPTY_DELIMITED_DOC_COMMENT +DELIMITED_DOC_COMMENT +SINGLE_LINE_COMMENT +DELIMITED_COMMENT +WHITESPACES +SHARP +ABSTRACT +ADD +ALIAS +ARGLIST +AS +ASCENDING +ASYNC +AWAIT +BASE +BOOL +BREAK +BY +BYTE +CASE +CATCH +CHAR +CHECKED +CLASS +CONST +CONTINUE +DECIMAL +DEFAULT +DELEGATE +DESCENDING +DO +DOUBLE +DYNAMIC +ELSE +ENUM +EQUALS +EVENT +EXPLICIT +EXTERN +FALSE +FINALLY +FIXED +FLOAT +FOR +FOREACH +FROM +GET +GOTO +GROUP +IF +IMPLICIT +IN +INT +INTERFACE +INTERNAL +INTO +IS +JOIN +LET +LOCK +LONG +NAMEOF +NAMESPACE +NEW +NULL +OBJECT +ON +OPERATOR +ORDERBY +OUT +OVERRIDE +PARAMS +PARTIAL +PRIVATE +PROTECTED +PUBLIC +READONLY +REF +REMOVE +RETURN +SBYTE +SEALED +SELECT +SET +SHORT +SIZEOF +STACKALLOC +STATIC +STRING +STRUCT +SWITCH +THIS +THROW +TRUE +TRY +TYPEOF +UINT +ULONG +UNCHECKED +UNMANAGED +UNSAFE +USHORT +USING +VAR +VIRTUAL +VOID +VOLATILE +WHEN +WHERE +WHILE +YIELD +IDENTIFIER +LITERAL_ACCESS +INTEGER_LITERAL +HEX_INTEGER_LITERAL +BIN_INTEGER_LITERAL +REAL_LITERAL +CHARACTER_LITERAL +REGULAR_STRING +VERBATIUM_STRING +INTERPOLATED_REGULAR_STRING_START +INTERPOLATED_VERBATIUM_STRING_START +OPEN_BRACE +CLOSE_BRACE +OPEN_BRACKET +CLOSE_BRACKET +OPEN_PARENS +CLOSE_PARENS +DOT +COMMA +COLON +SEMICOLON +PLUS +MINUS +STAR +DIV +PERCENT +AMP +BITWISE_OR +CARET +BANG +TILDE +ASSIGNMENT +LT +GT +INTERR +DOUBLE_COLON +OP_COALESCING +OP_INC +OP_DEC +OP_AND +OP_OR +OP_PTR +OP_EQ +OP_NE +OP_LE +OP_GE +OP_ADD_ASSIGNMENT +OP_SUB_ASSIGNMENT +OP_MULT_ASSIGNMENT +OP_DIV_ASSIGNMENT +OP_MOD_ASSIGNMENT +OP_AND_ASSIGNMENT +OP_OR_ASSIGNMENT +OP_XOR_ASSIGNMENT +OP_LEFT_SHIFT +OP_LEFT_SHIFT_ASSIGNMENT +OP_COALESCING_ASSIGNMENT +OP_RANGE +DOUBLE_CURLY_INSIDE +OPEN_BRACE_INSIDE +REGULAR_CHAR_INSIDE +VERBATIUM_DOUBLE_QUOTE_INSIDE +DOUBLE_QUOTE_INSIDE +REGULAR_STRING_INSIDE +VERBATIUM_INSIDE_STRING +CLOSE_BRACE_INSIDE +FORMAT_STRING +DIRECTIVE_WHITESPACES +DIGITS +DEFINE +UNDEF +ELIF +ENDIF +LINE +ERROR +WARNING +REGION +ENDREGION +PRAGMA +NULLABLE +DIRECTIVE_HIDDEN +CONDITIONAL_SYMBOL +DIRECTIVE_NEW_LINE +TEXT +DOUBLE_CURLY_CLOSE_INSIDE + +rule names: +compilation_unit +namespace_or_type_name +type_ +base_type +tuple_type +tuple_element +simple_type +numeric_type +integral_type +floating_point_type +class_type +type_argument_list +argument_list +argument +expression +non_assignment_expression +assignment +assignment_operator +conditional_expression +null_coalescing_expression +conditional_or_expression +conditional_and_expression +inclusive_or_expression +exclusive_or_expression +and_expression +equality_expression +relational_expression +shift_expression +additive_expression +multiplicative_expression +switch_expression +switch_expression_arms +switch_expression_arm +range_expression +unary_expression +primary_expression +primary_expression_start +throwable_expression +throw_expression +member_access +bracket_expression +indexer_argument +predefined_type +expression_list +object_or_collection_initializer +object_initializer +member_initializer_list +member_initializer +initializer_value +collection_initializer +element_initializer +anonymous_object_initializer +member_declarator_list +member_declarator +unbound_type_name +generic_dimension_specifier +isType +isTypePatternArms +isTypePatternArm +lambda_expression +anonymous_function_signature +explicit_anonymous_function_parameter_list +explicit_anonymous_function_parameter +implicit_anonymous_function_parameter_list +anonymous_function_body +query_expression +from_clause +query_body +query_body_clause +let_clause +where_clause +combined_join_clause +orderby_clause +ordering +select_or_group_clause +query_continuation +statement +declarationStatement +local_function_declaration +local_function_header +local_function_modifiers +local_function_body +labeled_Statement +embedded_statement +simple_embedded_statement +block +local_variable_declaration +local_variable_type +local_variable_declarator +local_variable_initializer +local_constant_declaration +if_body +switch_section +switch_label +case_guard +statement_list +for_initializer +for_iterator +catch_clauses +specific_catch_clause +general_catch_clause +exception_filter +finally_clause +resource_acquisition +namespace_declaration +qualified_identifier +namespace_body +extern_alias_directives +extern_alias_directive +using_directives +using_directive +namespace_member_declarations +namespace_member_declaration +type_declaration +qualified_alias_member +type_parameter_list +type_parameter +class_base +interface_type_list +type_parameter_constraints_clauses +type_parameter_constraints_clause +type_parameter_constraints +primary_constraint +secondary_constraints +constructor_constraint +class_body +class_member_declarations +class_member_declaration +all_member_modifiers +all_member_modifier +common_member_declaration +typed_member_declaration +constant_declarators +constant_declarator +variable_declarators +variable_declarator +variable_initializer +return_type +member_name +method_body +formal_parameter_list +fixed_parameters +fixed_parameter +parameter_modifier +parameter_array +accessor_declarations +get_accessor_declaration +set_accessor_declaration +accessor_modifier +accessor_body +event_accessor_declarations +add_accessor_declaration +remove_accessor_declaration +overloadable_operator +conversion_operator_declarator +constructor_initializer +body +struct_interfaces +struct_body +struct_member_declaration +array_type +rank_specifier +array_initializer +variant_type_parameter_list +variant_type_parameter +variance_annotation +interface_base +interface_body +interface_member_declaration +interface_accessors +enum_base +enum_body +enum_member_declaration +global_attribute_section +global_attribute_target +attributes +attribute_section +attribute_target +attribute_list +attribute +attribute_argument +pointer_type +fixed_pointer_declarators +fixed_pointer_declarator +fixed_pointer_initializer +fixed_size_buffer_declarator +stackalloc_initializer +right_arrow +right_shift +right_shift_assignment +literal +boolean_literal +string_literal +interpolated_regular_string +interpolated_verbatium_string +interpolated_regular_string_part +interpolated_verbatium_string_part +interpolated_string_expression +keyword +class_definition +struct_definition +interface_definition +enum_definition +delegate_definition +event_declaration +field_declaration +property_declaration +constant_declaration +indexer_declaration +destructor_definition +constructor_declaration +method_declaration +method_member_name +operator_declaration +arg_declaration +method_invocation +object_creation_expression +identifier + + +atn: +[4, 1, 198, 2642, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 1, 0, 3, 0, 438, 8, 0, 1, 0, 3, 0, 441, 8, 0, 1, 0, 3, 0, 444, 8, 0, 1, 0, 5, 0, 447, 8, 0, 10, 0, 12, 0, 450, 9, 0, 1, 0, 3, 0, 453, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 459, 8, 1, 1, 1, 3, 1, 462, 8, 1, 1, 1, 1, 1, 1, 1, 3, 1, 467, 8, 1, 5, 1, 469, 8, 1, 10, 1, 12, 1, 472, 9, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 478, 8, 2, 10, 2, 12, 2, 481, 9, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 488, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 494, 8, 4, 11, 4, 12, 4, 495, 1, 4, 1, 4, 1, 5, 1, 5, 3, 5, 502, 8, 5, 1, 6, 1, 6, 3, 6, 506, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 511, 8, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 521, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 527, 8, 11, 10, 11, 12, 11, 530, 9, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 5, 12, 537, 8, 12, 10, 12, 12, 12, 540, 9, 12, 1, 13, 1, 13, 1, 13, 3, 13, 545, 8, 13, 1, 13, 3, 13, 548, 8, 13, 1, 13, 1, 13, 3, 13, 552, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 560, 8, 14, 1, 15, 1, 15, 1, 15, 3, 15, 565, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 575, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 588, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 596, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 602, 8, 19, 3, 19, 604, 8, 19, 1, 20, 1, 20, 1, 20, 5, 20, 609, 8, 20, 10, 20, 12, 20, 612, 9, 20, 1, 21, 1, 21, 1, 21, 5, 21, 617, 8, 21, 10, 21, 12, 21, 620, 9, 21, 1, 22, 1, 22, 1, 22, 5, 22, 625, 8, 22, 10, 22, 12, 22, 628, 9, 22, 1, 23, 1, 23, 1, 23, 5, 23, 633, 8, 23, 10, 23, 12, 23, 636, 9, 23, 1, 24, 1, 24, 1, 24, 5, 24, 641, 8, 24, 10, 24, 12, 24, 644, 9, 24, 1, 25, 1, 25, 1, 25, 5, 25, 649, 8, 25, 10, 25, 12, 25, 652, 9, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 5, 26, 661, 8, 26, 10, 26, 12, 26, 664, 9, 26, 1, 27, 1, 27, 1, 27, 3, 27, 669, 8, 27, 1, 27, 5, 27, 672, 8, 27, 10, 27, 12, 27, 675, 9, 27, 1, 28, 1, 28, 1, 28, 5, 28, 680, 8, 28, 10, 28, 12, 28, 683, 9, 28, 1, 29, 1, 29, 1, 29, 5, 29, 688, 8, 29, 10, 29, 12, 29, 691, 9, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 698, 8, 30, 3, 30, 700, 8, 30, 1, 30, 3, 30, 703, 8, 30, 1, 31, 1, 31, 1, 31, 5, 31, 708, 8, 31, 10, 31, 12, 31, 711, 9, 31, 1, 32, 1, 32, 3, 32, 715, 8, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 722, 8, 33, 1, 33, 1, 33, 3, 33, 726, 8, 33, 3, 33, 728, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 756, 8, 34, 1, 35, 1, 35, 3, 35, 760, 8, 35, 1, 35, 5, 35, 763, 8, 35, 10, 35, 12, 35, 766, 9, 35, 1, 35, 3, 35, 769, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 777, 8, 35, 1, 35, 3, 35, 780, 8, 35, 1, 35, 5, 35, 783, 8, 35, 10, 35, 12, 35, 786, 9, 35, 1, 35, 3, 35, 789, 8, 35, 5, 35, 791, 8, 35, 10, 35, 12, 35, 794, 9, 35, 1, 36, 1, 36, 1, 36, 3, 36, 799, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 813, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 819, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 829, 8, 36, 10, 36, 12, 36, 832, 9, 36, 1, 36, 3, 36, 835, 8, 36, 1, 36, 4, 36, 838, 8, 36, 11, 36, 12, 36, 839, 1, 36, 1, 36, 3, 36, 844, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 850, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 4, 36, 856, 8, 36, 11, 36, 12, 36, 857, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 867, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 885, 8, 36, 1, 36, 3, 36, 888, 8, 36, 1, 36, 1, 36, 1, 36, 3, 36, 893, 8, 36, 1, 36, 3, 36, 896, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 909, 8, 36, 10, 36, 12, 36, 912, 9, 36, 1, 36, 1, 36, 1, 36, 3, 36, 917, 8, 36, 1, 37, 1, 37, 3, 37, 921, 8, 37, 1, 38, 1, 38, 1, 38, 1, 39, 3, 39, 927, 8, 39, 1, 39, 1, 39, 1, 39, 3, 39, 932, 8, 39, 1, 40, 3, 40, 935, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 5, 40, 941, 8, 40, 10, 40, 12, 40, 944, 9, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 3, 41, 951, 8, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 5, 43, 960, 8, 43, 10, 43, 12, 43, 963, 9, 43, 1, 44, 1, 44, 3, 44, 967, 8, 44, 1, 45, 1, 45, 1, 45, 3, 45, 972, 8, 45, 3, 45, 974, 8, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 5, 46, 981, 8, 46, 10, 46, 12, 46, 984, 9, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 991, 8, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 3, 48, 998, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 1004, 8, 49, 10, 49, 12, 49, 1007, 9, 49, 1, 49, 3, 49, 1010, 8, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1019, 8, 50, 1, 51, 1, 51, 1, 51, 3, 51, 1024, 8, 51, 3, 51, 1026, 8, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 5, 52, 1033, 8, 52, 10, 52, 12, 52, 1036, 9, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1043, 8, 53, 1, 54, 1, 54, 3, 54, 1047, 8, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1052, 8, 54, 3, 54, 1054, 8, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1059, 8, 54, 5, 54, 1061, 8, 54, 10, 54, 12, 54, 1064, 9, 54, 1, 55, 1, 55, 5, 55, 1068, 8, 55, 10, 55, 12, 55, 1071, 9, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 5, 56, 1078, 8, 56, 10, 56, 12, 56, 1081, 9, 56, 1, 56, 3, 56, 1084, 8, 56, 1, 56, 3, 56, 1087, 8, 56, 1, 56, 3, 56, 1090, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1096, 8, 57, 10, 57, 12, 57, 1099, 9, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 3, 59, 1108, 8, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1125, 8, 60, 1, 61, 1, 61, 1, 61, 5, 61, 1130, 8, 61, 10, 61, 12, 61, 1133, 9, 61, 1, 62, 3, 62, 1136, 8, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1144, 8, 63, 10, 63, 12, 63, 1147, 9, 63, 1, 64, 1, 64, 3, 64, 1151, 8, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 3, 66, 1158, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 5, 67, 1165, 8, 67, 10, 67, 12, 67, 1168, 9, 67, 1, 67, 1, 67, 3, 67, 1172, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1179, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 3, 71, 1191, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1202, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 5, 72, 1208, 8, 72, 10, 72, 12, 72, 1211, 9, 72, 1, 73, 1, 73, 3, 73, 1215, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1224, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1233, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1242, 8, 77, 1, 78, 1, 78, 1, 78, 1, 79, 3, 79, 1248, 8, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1253, 8, 79, 1, 79, 1, 79, 3, 79, 1257, 8, 79, 1, 79, 1, 79, 3, 79, 1261, 8, 79, 1, 80, 1, 80, 3, 80, 1265, 8, 80, 1, 80, 1, 80, 3, 80, 1269, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1276, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1284, 8, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1297, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 5, 84, 1305, 8, 84, 10, 84, 12, 84, 1308, 9, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1329, 8, 84, 1, 84, 1, 84, 3, 84, 1333, 8, 84, 1, 84, 1, 84, 3, 84, 1337, 8, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1342, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1362, 8, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1367, 8, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1372, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1379, 8, 84, 1, 84, 3, 84, 1382, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1404, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1416, 8, 84, 1, 85, 1, 85, 3, 85, 1420, 8, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1428, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 5, 86, 1434, 8, 86, 10, 86, 12, 86, 1437, 9, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1443, 8, 86, 1, 87, 1, 87, 3, 87, 1447, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1452, 8, 88, 1, 88, 3, 88, 1455, 8, 88, 1, 89, 1, 89, 1, 89, 3, 89, 1460, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 3, 91, 1468, 8, 91, 1, 92, 4, 92, 1471, 8, 92, 11, 92, 12, 92, 1472, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 3, 93, 1480, 8, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1486, 8, 93, 1, 94, 1, 94, 1, 94, 1, 95, 4, 95, 1492, 8, 95, 11, 95, 12, 95, 1493, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 1500, 8, 96, 10, 96, 12, 96, 1503, 9, 96, 3, 96, 1505, 8, 96, 1, 97, 1, 97, 1, 97, 5, 97, 1510, 8, 97, 10, 97, 12, 97, 1513, 9, 97, 1, 98, 1, 98, 5, 98, 1517, 8, 98, 10, 98, 12, 98, 1520, 9, 98, 1, 98, 3, 98, 1523, 8, 98, 1, 98, 3, 98, 1526, 8, 98, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1532, 8, 99, 1, 99, 1, 99, 3, 99, 1536, 8, 99, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 1542, 8, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 3, 103, 1556, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1562, 8, 104, 1, 105, 1, 105, 1, 105, 5, 105, 1567, 8, 105, 10, 105, 12, 105, 1570, 9, 105, 1, 106, 1, 106, 3, 106, 1574, 8, 106, 1, 106, 3, 106, 1577, 8, 106, 1, 106, 3, 106, 1580, 8, 106, 1, 106, 1, 106, 1, 107, 4, 107, 1585, 8, 107, 11, 107, 12, 107, 1586, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 4, 109, 1595, 8, 109, 11, 109, 12, 109, 1596, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1614, 8, 110, 1, 111, 4, 111, 1617, 8, 111, 11, 111, 12, 111, 1618, 1, 112, 1, 112, 3, 112, 1623, 8, 112, 1, 113, 3, 113, 1626, 8, 113, 1, 113, 3, 113, 1629, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1636, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1642, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1648, 8, 115, 10, 115, 12, 115, 1651, 9, 115, 1, 115, 1, 115, 1, 116, 3, 116, 1656, 8, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1664, 8, 117, 10, 117, 12, 117, 1667, 9, 117, 1, 118, 1, 118, 1, 118, 5, 118, 1672, 8, 118, 10, 118, 12, 118, 1675, 9, 118, 1, 119, 4, 119, 1678, 8, 119, 11, 119, 12, 119, 1679, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 1691, 8, 121, 1, 121, 1, 121, 3, 121, 1695, 8, 121, 3, 121, 1697, 8, 121, 1, 122, 1, 122, 1, 122, 3, 122, 1702, 8, 122, 1, 122, 1, 122, 3, 122, 1706, 8, 122, 1, 123, 1, 123, 1, 123, 5, 123, 1711, 8, 123, 10, 123, 12, 123, 1714, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 3, 125, 1722, 8, 125, 1, 125, 1, 125, 1, 126, 4, 126, 1727, 8, 126, 11, 126, 12, 126, 1728, 1, 127, 3, 127, 1732, 8, 127, 1, 127, 3, 127, 1735, 8, 127, 1, 127, 1, 127, 3, 127, 1739, 8, 127, 1, 128, 4, 128, 1742, 8, 128, 11, 128, 12, 128, 1743, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1757, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1767, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1774, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1786, 8, 131, 1, 132, 1, 132, 1, 132, 5, 132, 1791, 8, 132, 10, 132, 12, 132, 1794, 9, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 5, 134, 1803, 8, 134, 10, 134, 12, 134, 1806, 9, 134, 1, 135, 1, 135, 1, 135, 3, 135, 1811, 8, 135, 1, 136, 1, 136, 3, 136, 1815, 8, 136, 1, 137, 1, 137, 3, 137, 1819, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 3, 139, 1825, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1831, 8, 140, 3, 140, 1833, 8, 140, 1, 141, 1, 141, 1, 141, 5, 141, 1838, 8, 141, 10, 141, 12, 141, 1841, 9, 141, 1, 142, 3, 142, 1844, 8, 142, 1, 142, 3, 142, 1847, 8, 142, 1, 142, 1, 142, 3, 142, 1851, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 1861, 8, 143, 1, 144, 3, 144, 1864, 8, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 3, 145, 1871, 8, 145, 1, 145, 3, 145, 1874, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1879, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1884, 8, 145, 3, 145, 1886, 8, 145, 1, 146, 3, 146, 1889, 8, 146, 1, 146, 3, 146, 1892, 8, 146, 1, 146, 1, 146, 1, 146, 1, 147, 3, 147, 1898, 8, 147, 1, 147, 3, 147, 1901, 8, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 1913, 8, 148, 1, 149, 1, 149, 3, 149, 1917, 8, 149, 1, 150, 3, 150, 1920, 8, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 1930, 8, 150, 1, 151, 3, 151, 1933, 8, 151, 1, 151, 1, 151, 1, 151, 1, 152, 3, 152, 1939, 8, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 1966, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 1979, 8, 155, 1, 155, 1, 155, 1, 156, 1, 156, 3, 156, 1985, 8, 156, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 5, 158, 1992, 8, 158, 10, 158, 12, 158, 1995, 9, 158, 1, 158, 1, 158, 1, 159, 3, 159, 2000, 8, 159, 1, 159, 3, 159, 2003, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 4, 159, 2009, 8, 159, 11, 159, 12, 159, 2010, 1, 159, 1, 159, 3, 159, 2015, 8, 159, 1, 160, 1, 160, 5, 160, 2019, 8, 160, 10, 160, 12, 160, 2022, 9, 160, 1, 160, 4, 160, 2025, 8, 160, 11, 160, 12, 160, 2026, 1, 161, 1, 161, 5, 161, 2031, 8, 161, 10, 161, 12, 161, 2034, 9, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2042, 8, 162, 10, 162, 12, 162, 2045, 9, 162, 1, 162, 3, 162, 2048, 8, 162, 3, 162, 2050, 8, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 5, 163, 2058, 8, 163, 10, 163, 12, 163, 2061, 9, 163, 1, 163, 1, 163, 1, 164, 3, 164, 2066, 8, 164, 1, 164, 3, 164, 2069, 8, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2080, 8, 167, 10, 167, 12, 167, 2083, 9, 167, 1, 167, 1, 167, 1, 168, 3, 168, 2088, 8, 168, 1, 168, 3, 168, 2091, 8, 168, 1, 168, 3, 168, 2094, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2101, 8, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2106, 8, 168, 1, 168, 1, 168, 3, 168, 2110, 8, 168, 1, 168, 1, 168, 3, 168, 2114, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2131, 8, 168, 1, 168, 3, 168, 2134, 8, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2139, 8, 168, 1, 168, 1, 168, 3, 168, 2143, 8, 168, 1, 168, 1, 168, 3, 168, 2147, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2156, 8, 168, 1, 169, 3, 169, 2159, 8, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2164, 8, 169, 1, 169, 1, 169, 3, 169, 2168, 8, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2173, 8, 169, 1, 169, 1, 169, 3, 169, 2177, 8, 169, 3, 169, 2179, 8, 169, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2188, 8, 171, 10, 171, 12, 171, 2191, 9, 171, 1, 171, 3, 171, 2194, 8, 171, 3, 171, 2196, 8, 171, 1, 171, 1, 171, 1, 172, 3, 172, 2201, 8, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2206, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 2213, 8, 173, 1, 173, 1, 173, 1, 174, 1, 174, 3, 174, 2219, 8, 174, 1, 175, 4, 175, 2222, 8, 175, 11, 175, 12, 175, 2223, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2230, 8, 176, 1, 176, 1, 176, 3, 176, 2234, 8, 176, 1, 176, 1, 176, 1, 177, 1, 177, 3, 177, 2240, 8, 177, 1, 178, 1, 178, 1, 178, 5, 178, 2245, 8, 178, 10, 178, 12, 178, 2248, 9, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 5, 179, 2255, 8, 179, 10, 179, 12, 179, 2258, 9, 179, 3, 179, 2260, 8, 179, 1, 179, 3, 179, 2263, 8, 179, 1, 180, 1, 180, 1, 180, 3, 180, 2268, 8, 180, 1, 180, 1, 180, 1, 181, 1, 181, 3, 181, 2274, 8, 181, 1, 181, 1, 181, 5, 181, 2278, 8, 181, 10, 181, 12, 181, 2281, 9, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2287, 8, 181, 1, 182, 1, 182, 1, 182, 5, 182, 2292, 8, 182, 10, 182, 12, 182, 2295, 9, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 3, 184, 2302, 8, 184, 1, 184, 1, 184, 3, 184, 2306, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 2321, 8, 186, 1, 186, 1, 186, 3, 186, 2325, 8, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 5, 186, 2332, 8, 186, 10, 186, 12, 186, 2335, 9, 186, 1, 186, 3, 186, 2338, 8, 186, 1, 186, 1, 186, 3, 186, 2342, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 2364, 8, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 2372, 8, 192, 1, 193, 1, 193, 5, 193, 2376, 8, 193, 10, 193, 12, 193, 2379, 9, 193, 1, 193, 1, 193, 1, 194, 1, 194, 5, 194, 2385, 8, 194, 10, 194, 12, 194, 2388, 9, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 2396, 8, 195, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, 2402, 8, 196, 1, 197, 1, 197, 1, 197, 5, 197, 2407, 8, 197, 10, 197, 12, 197, 2410, 9, 197, 1, 197, 1, 197, 4, 197, 2414, 8, 197, 11, 197, 12, 197, 2415, 3, 197, 2418, 8, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 3, 199, 2425, 8, 199, 1, 199, 3, 199, 2428, 8, 199, 1, 199, 3, 199, 2431, 8, 199, 1, 199, 1, 199, 3, 199, 2435, 8, 199, 1, 200, 3, 200, 2438, 8, 200, 1, 200, 1, 200, 1, 200, 3, 200, 2443, 8, 200, 1, 200, 3, 200, 2446, 8, 200, 1, 200, 3, 200, 2449, 8, 200, 1, 200, 1, 200, 3, 200, 2453, 8, 200, 1, 201, 1, 201, 1, 201, 3, 201, 2458, 8, 201, 1, 201, 3, 201, 2461, 8, 201, 1, 201, 3, 201, 2464, 8, 201, 1, 201, 1, 201, 3, 201, 2468, 8, 201, 1, 202, 1, 202, 1, 202, 3, 202, 2473, 8, 202, 1, 202, 1, 202, 3, 202, 2477, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 2483, 8, 203, 1, 203, 1, 203, 3, 203, 2487, 8, 203, 1, 203, 1, 203, 3, 203, 2491, 8, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 2505, 8, 204, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 2518, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 2524, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 2543, 8, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 3, 210, 2554, 8, 210, 1, 210, 1, 210, 3, 210, 2558, 8, 210, 1, 210, 1, 210, 1, 211, 1, 211, 3, 211, 2564, 8, 211, 1, 211, 1, 211, 3, 211, 2568, 8, 211, 1, 211, 1, 211, 3, 211, 2572, 8, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 2579, 8, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 2586, 8, 212, 1, 212, 3, 212, 2589, 8, 212, 1, 212, 1, 212, 5, 212, 2593, 8, 212, 10, 212, 12, 212, 2596, 9, 212, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 2602, 8, 213, 1, 213, 1, 213, 1, 213, 3, 213, 2607, 8, 213, 1, 213, 3, 213, 2610, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 2618, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 2624, 8, 214, 1, 215, 1, 215, 3, 215, 2628, 8, 215, 1, 215, 1, 215, 1, 216, 1, 216, 3, 216, 2634, 8, 216, 1, 216, 1, 216, 3, 216, 2638, 8, 216, 1, 217, 1, 217, 1, 217, 0, 0, 218, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 0, 19, 8, 0, 21, 21, 24, 24, 55, 55, 63, 63, 83, 83, 87, 87, 99, 100, 104, 104, 2, 0, 34, 34, 45, 45, 3, 0, 54, 54, 72, 72, 80, 80, 1, 0, 156, 157, 2, 0, 146, 147, 158, 159, 1, 0, 135, 136, 1, 0, 137, 139, 14, 0, 18, 18, 21, 21, 24, 24, 29, 29, 34, 34, 45, 45, 55, 55, 63, 63, 68, 68, 83, 83, 87, 87, 91, 91, 99, 100, 104, 104, 2, 0, 14, 14, 32, 32, 2, 0, 15, 15, 103, 103, 12, 0, 9, 9, 15, 15, 41, 41, 57, 57, 66, 66, 73, 73, 75, 79, 84, 84, 90, 90, 103, 103, 107, 107, 109, 109, 2, 0, 40, 40, 53, 53, 2, 0, 17, 17, 94, 94, 2, 0, 137, 137, 148, 148, 2, 0, 54, 54, 72, 72, 2, 0, 42, 42, 96, 96, 19, 0, 9, 9, 13, 13, 17, 19, 21, 31, 33, 34, 36, 37, 39, 47, 50, 50, 52, 57, 59, 59, 62, 63, 65, 68, 70, 70, 72, 74, 76, 80, 82, 84, 87, 105, 107, 109, 112, 112, 1, 0, 79, 80, 20, 0, 10, 12, 14, 16, 20, 20, 32, 32, 35, 35, 38, 38, 48, 49, 51, 51, 58, 58, 60, 61, 64, 64, 69, 69, 71, 71, 75, 75, 81, 81, 85, 86, 102, 102, 106, 106, 110, 111, 113, 114, 2912, 0, 437, 1, 0, 0, 0, 2, 461, 1, 0, 0, 0, 4, 473, 1, 0, 0, 0, 6, 487, 1, 0, 0, 0, 8, 489, 1, 0, 0, 0, 10, 499, 1, 0, 0, 0, 12, 505, 1, 0, 0, 0, 14, 510, 1, 0, 0, 0, 16, 512, 1, 0, 0, 0, 18, 514, 1, 0, 0, 0, 20, 520, 1, 0, 0, 0, 22, 522, 1, 0, 0, 0, 24, 533, 1, 0, 0, 0, 26, 544, 1, 0, 0, 0, 28, 559, 1, 0, 0, 0, 30, 564, 1, 0, 0, 0, 32, 574, 1, 0, 0, 0, 34, 587, 1, 0, 0, 0, 36, 589, 1, 0, 0, 0, 38, 597, 1, 0, 0, 0, 40, 605, 1, 0, 0, 0, 42, 613, 1, 0, 0, 0, 44, 621, 1, 0, 0, 0, 46, 629, 1, 0, 0, 0, 48, 637, 1, 0, 0, 0, 50, 645, 1, 0, 0, 0, 52, 653, 1, 0, 0, 0, 54, 665, 1, 0, 0, 0, 56, 676, 1, 0, 0, 0, 58, 684, 1, 0, 0, 0, 60, 692, 1, 0, 0, 0, 62, 704, 1, 0, 0, 0, 64, 712, 1, 0, 0, 0, 66, 727, 1, 0, 0, 0, 68, 755, 1, 0, 0, 0, 70, 757, 1, 0, 0, 0, 72, 916, 1, 0, 0, 0, 74, 920, 1, 0, 0, 0, 76, 922, 1, 0, 0, 0, 78, 926, 1, 0, 0, 0, 80, 934, 1, 0, 0, 0, 82, 950, 1, 0, 0, 0, 84, 954, 1, 0, 0, 0, 86, 956, 1, 0, 0, 0, 88, 966, 1, 0, 0, 0, 90, 968, 1, 0, 0, 0, 92, 977, 1, 0, 0, 0, 94, 990, 1, 0, 0, 0, 96, 997, 1, 0, 0, 0, 98, 999, 1, 0, 0, 0, 100, 1018, 1, 0, 0, 0, 102, 1020, 1, 0, 0, 0, 104, 1029, 1, 0, 0, 0, 106, 1042, 1, 0, 0, 0, 108, 1044, 1, 0, 0, 0, 110, 1065, 1, 0, 0, 0, 112, 1074, 1, 0, 0, 0, 114, 1091, 1, 0, 0, 0, 116, 1102, 1, 0, 0, 0, 118, 1107, 1, 0, 0, 0, 120, 1124, 1, 0, 0, 0, 122, 1126, 1, 0, 0, 0, 124, 1135, 1, 0, 0, 0, 126, 1140, 1, 0, 0, 0, 128, 1150, 1, 0, 0, 0, 130, 1152, 1, 0, 0, 0, 132, 1155, 1, 0, 0, 0, 134, 1166, 1, 0, 0, 0, 136, 1178, 1, 0, 0, 0, 138, 1180, 1, 0, 0, 0, 140, 1185, 1, 0, 0, 0, 142, 1188, 1, 0, 0, 0, 144, 1203, 1, 0, 0, 0, 146, 1212, 1, 0, 0, 0, 148, 1223, 1, 0, 0, 0, 150, 1225, 1, 0, 0, 0, 152, 1232, 1, 0, 0, 0, 154, 1241, 1, 0, 0, 0, 156, 1243, 1, 0, 0, 0, 158, 1247, 1, 0, 0, 0, 160, 1268, 1, 0, 0, 0, 162, 1275, 1, 0, 0, 0, 164, 1277, 1, 0, 0, 0, 166, 1283, 1, 0, 0, 0, 168, 1415, 1, 0, 0, 0, 170, 1417, 1, 0, 0, 0, 172, 1442, 1, 0, 0, 0, 174, 1446, 1, 0, 0, 0, 176, 1448, 1, 0, 0, 0, 178, 1459, 1, 0, 0, 0, 180, 1461, 1, 0, 0, 0, 182, 1467, 1, 0, 0, 0, 184, 1470, 1, 0, 0, 0, 186, 1485, 1, 0, 0, 0, 188, 1487, 1, 0, 0, 0, 190, 1491, 1, 0, 0, 0, 192, 1504, 1, 0, 0, 0, 194, 1506, 1, 0, 0, 0, 196, 1525, 1, 0, 0, 0, 198, 1527, 1, 0, 0, 0, 200, 1539, 1, 0, 0, 0, 202, 1545, 1, 0, 0, 0, 204, 1550, 1, 0, 0, 0, 206, 1555, 1, 0, 0, 0, 208, 1557, 1, 0, 0, 0, 210, 1563, 1, 0, 0, 0, 212, 1571, 1, 0, 0, 0, 214, 1584, 1, 0, 0, 0, 216, 1588, 1, 0, 0, 0, 218, 1594, 1, 0, 0, 0, 220, 1613, 1, 0, 0, 0, 222, 1616, 1, 0, 0, 0, 224, 1622, 1, 0, 0, 0, 226, 1625, 1, 0, 0, 0, 228, 1637, 1, 0, 0, 0, 230, 1643, 1, 0, 0, 0, 232, 1655, 1, 0, 0, 0, 234, 1659, 1, 0, 0, 0, 236, 1668, 1, 0, 0, 0, 238, 1677, 1, 0, 0, 0, 240, 1681, 1, 0, 0, 0, 242, 1696, 1, 0, 0, 0, 244, 1705, 1, 0, 0, 0, 246, 1707, 1, 0, 0, 0, 248, 1715, 1, 0, 0, 0, 250, 1719, 1, 0, 0, 0, 252, 1726, 1, 0, 0, 0, 254, 1731, 1, 0, 0, 0, 256, 1741, 1, 0, 0, 0, 258, 1745, 1, 0, 0, 0, 260, 1766, 1, 0, 0, 0, 262, 1773, 1, 0, 0, 0, 264, 1787, 1, 0, 0, 0, 266, 1795, 1, 0, 0, 0, 268, 1799, 1, 0, 0, 0, 270, 1807, 1, 0, 0, 0, 272, 1814, 1, 0, 0, 0, 274, 1818, 1, 0, 0, 0, 276, 1820, 1, 0, 0, 0, 278, 1824, 1, 0, 0, 0, 280, 1832, 1, 0, 0, 0, 282, 1834, 1, 0, 0, 0, 284, 1850, 1, 0, 0, 0, 286, 1860, 1, 0, 0, 0, 288, 1863, 1, 0, 0, 0, 290, 1870, 1, 0, 0, 0, 292, 1888, 1, 0, 0, 0, 294, 1897, 1, 0, 0, 0, 296, 1912, 1, 0, 0, 0, 298, 1916, 1, 0, 0, 0, 300, 1919, 1, 0, 0, 0, 302, 1932, 1, 0, 0, 0, 304, 1938, 1, 0, 0, 0, 306, 1965, 1, 0, 0, 0, 308, 1967, 1, 0, 0, 0, 310, 1974, 1, 0, 0, 0, 312, 1984, 1, 0, 0, 0, 314, 1986, 1, 0, 0, 0, 316, 1989, 1, 0, 0, 0, 318, 1999, 1, 0, 0, 0, 320, 2016, 1, 0, 0, 0, 322, 2028, 1, 0, 0, 0, 324, 2037, 1, 0, 0, 0, 326, 2053, 1, 0, 0, 0, 328, 2065, 1, 0, 0, 0, 330, 2072, 1, 0, 0, 0, 332, 2074, 1, 0, 0, 0, 334, 2077, 1, 0, 0, 0, 336, 2087, 1, 0, 0, 0, 338, 2158, 1, 0, 0, 0, 340, 2180, 1, 0, 0, 0, 342, 2183, 1, 0, 0, 0, 344, 2200, 1, 0, 0, 0, 346, 2207, 1, 0, 0, 0, 348, 2218, 1, 0, 0, 0, 350, 2221, 1, 0, 0, 0, 352, 2225, 1, 0, 0, 0, 354, 2239, 1, 0, 0, 0, 356, 2241, 1, 0, 0, 0, 358, 2249, 1, 0, 0, 0, 360, 2267, 1, 0, 0, 0, 362, 2286, 1, 0, 0, 0, 364, 2288, 1, 0, 0, 0, 366, 2296, 1, 0, 0, 0, 368, 2305, 1, 0, 0, 0, 370, 2307, 1, 0, 0, 0, 372, 2341, 1, 0, 0, 0, 374, 2343, 1, 0, 0, 0, 376, 2347, 1, 0, 0, 0, 378, 2351, 1, 0, 0, 0, 380, 2363, 1, 0, 0, 0, 382, 2365, 1, 0, 0, 0, 384, 2371, 1, 0, 0, 0, 386, 2373, 1, 0, 0, 0, 388, 2382, 1, 0, 0, 0, 390, 2395, 1, 0, 0, 0, 392, 2401, 1, 0, 0, 0, 394, 2403, 1, 0, 0, 0, 396, 2419, 1, 0, 0, 0, 398, 2421, 1, 0, 0, 0, 400, 2437, 1, 0, 0, 0, 402, 2454, 1, 0, 0, 0, 404, 2469, 1, 0, 0, 0, 406, 2478, 1, 0, 0, 0, 408, 2494, 1, 0, 0, 0, 410, 2506, 1, 0, 0, 0, 412, 2509, 1, 0, 0, 0, 414, 2525, 1, 0, 0, 0, 416, 2530, 1, 0, 0, 0, 418, 2544, 1, 0, 0, 0, 420, 2550, 1, 0, 0, 0, 422, 2561, 1, 0, 0, 0, 424, 2585, 1, 0, 0, 0, 426, 2597, 1, 0, 0, 0, 428, 2619, 1, 0, 0, 0, 430, 2625, 1, 0, 0, 0, 432, 2631, 1, 0, 0, 0, 434, 2639, 1, 0, 0, 0, 436, 438, 5, 1, 0, 0, 437, 436, 1, 0, 0, 0, 437, 438, 1, 0, 0, 0, 438, 440, 1, 0, 0, 0, 439, 441, 3, 214, 107, 0, 440, 439, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0, 441, 443, 1, 0, 0, 0, 442, 444, 3, 218, 109, 0, 443, 442, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 448, 1, 0, 0, 0, 445, 447, 3, 346, 173, 0, 446, 445, 1, 0, 0, 0, 447, 450, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 452, 1, 0, 0, 0, 450, 448, 1, 0, 0, 0, 451, 453, 3, 222, 111, 0, 452, 451, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 454, 455, 5, 0, 0, 1, 455, 1, 1, 0, 0, 0, 456, 458, 3, 434, 217, 0, 457, 459, 3, 22, 11, 0, 458, 457, 1, 0, 0, 0, 458, 459, 1, 0, 0, 0, 459, 462, 1, 0, 0, 0, 460, 462, 3, 228, 114, 0, 461, 456, 1, 0, 0, 0, 461, 460, 1, 0, 0, 0, 462, 470, 1, 0, 0, 0, 463, 464, 5, 131, 0, 0, 464, 466, 3, 434, 217, 0, 465, 467, 3, 22, 11, 0, 466, 465, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 469, 1, 0, 0, 0, 468, 463, 1, 0, 0, 0, 469, 472, 1, 0, 0, 0, 470, 468, 1, 0, 0, 0, 470, 471, 1, 0, 0, 0, 471, 3, 1, 0, 0, 0, 472, 470, 1, 0, 0, 0, 473, 479, 3, 6, 3, 0, 474, 478, 5, 148, 0, 0, 475, 478, 3, 322, 161, 0, 476, 478, 5, 137, 0, 0, 477, 474, 1, 0, 0, 0, 477, 475, 1, 0, 0, 0, 477, 476, 1, 0, 0, 0, 478, 481, 1, 0, 0, 0, 479, 477, 1, 0, 0, 0, 479, 480, 1, 0, 0, 0, 480, 5, 1, 0, 0, 0, 481, 479, 1, 0, 0, 0, 482, 488, 3, 12, 6, 0, 483, 488, 3, 20, 10, 0, 484, 485, 5, 108, 0, 0, 485, 488, 5, 137, 0, 0, 486, 488, 3, 8, 4, 0, 487, 482, 1, 0, 0, 0, 487, 483, 1, 0, 0, 0, 487, 484, 1, 0, 0, 0, 487, 486, 1, 0, 0, 0, 488, 7, 1, 0, 0, 0, 489, 490, 5, 129, 0, 0, 490, 493, 3, 10, 5, 0, 491, 492, 5, 132, 0, 0, 492, 494, 3, 10, 5, 0, 493, 491, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 493, 1, 0, 0, 0, 495, 496, 1, 0, 0, 0, 496, 497, 1, 0, 0, 0, 497, 498, 5, 130, 0, 0, 498, 9, 1, 0, 0, 0, 499, 501, 3, 4, 2, 0, 500, 502, 3, 434, 217, 0, 501, 500, 1, 0, 0, 0, 501, 502, 1, 0, 0, 0, 502, 11, 1, 0, 0, 0, 503, 506, 3, 14, 7, 0, 504, 506, 5, 18, 0, 0, 505, 503, 1, 0, 0, 0, 505, 504, 1, 0, 0, 0, 506, 13, 1, 0, 0, 0, 507, 511, 3, 16, 8, 0, 508, 511, 3, 18, 9, 0, 509, 511, 5, 29, 0, 0, 510, 507, 1, 0, 0, 0, 510, 508, 1, 0, 0, 0, 510, 509, 1, 0, 0, 0, 511, 15, 1, 0, 0, 0, 512, 513, 7, 0, 0, 0, 513, 17, 1, 0, 0, 0, 514, 515, 7, 1, 0, 0, 515, 19, 1, 0, 0, 0, 516, 521, 3, 2, 1, 0, 517, 521, 5, 68, 0, 0, 518, 521, 5, 35, 0, 0, 519, 521, 5, 91, 0, 0, 520, 516, 1, 0, 0, 0, 520, 517, 1, 0, 0, 0, 520, 518, 1, 0, 0, 0, 520, 519, 1, 0, 0, 0, 521, 21, 1, 0, 0, 0, 522, 523, 5, 146, 0, 0, 523, 528, 3, 4, 2, 0, 524, 525, 5, 132, 0, 0, 525, 527, 3, 4, 2, 0, 526, 524, 1, 0, 0, 0, 527, 530, 1, 0, 0, 0, 528, 526, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 531, 1, 0, 0, 0, 530, 528, 1, 0, 0, 0, 531, 532, 5, 147, 0, 0, 532, 23, 1, 0, 0, 0, 533, 538, 3, 26, 13, 0, 534, 535, 5, 132, 0, 0, 535, 537, 3, 26, 13, 0, 536, 534, 1, 0, 0, 0, 537, 540, 1, 0, 0, 0, 538, 536, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 539, 25, 1, 0, 0, 0, 540, 538, 1, 0, 0, 0, 541, 542, 3, 434, 217, 0, 542, 543, 5, 133, 0, 0, 543, 545, 1, 0, 0, 0, 544, 541, 1, 0, 0, 0, 544, 545, 1, 0, 0, 0, 545, 547, 1, 0, 0, 0, 546, 548, 7, 2, 0, 0, 547, 546, 1, 0, 0, 0, 547, 548, 1, 0, 0, 0, 548, 551, 1, 0, 0, 0, 549, 552, 5, 106, 0, 0, 550, 552, 3, 4, 2, 0, 551, 549, 1, 0, 0, 0, 551, 550, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 554, 3, 28, 14, 0, 554, 27, 1, 0, 0, 0, 555, 560, 3, 32, 16, 0, 556, 560, 3, 30, 15, 0, 557, 558, 5, 80, 0, 0, 558, 560, 3, 30, 15, 0, 559, 555, 1, 0, 0, 0, 559, 556, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 560, 29, 1, 0, 0, 0, 561, 565, 3, 118, 59, 0, 562, 565, 3, 130, 65, 0, 563, 565, 3, 36, 18, 0, 564, 561, 1, 0, 0, 0, 564, 562, 1, 0, 0, 0, 564, 563, 1, 0, 0, 0, 565, 31, 1, 0, 0, 0, 566, 567, 3, 68, 34, 0, 567, 568, 3, 34, 17, 0, 568, 569, 3, 28, 14, 0, 569, 575, 1, 0, 0, 0, 570, 571, 3, 68, 34, 0, 571, 572, 5, 170, 0, 0, 572, 573, 3, 74, 37, 0, 573, 575, 1, 0, 0, 0, 574, 566, 1, 0, 0, 0, 574, 570, 1, 0, 0, 0, 575, 33, 1, 0, 0, 0, 576, 588, 5, 145, 0, 0, 577, 588, 5, 160, 0, 0, 578, 588, 5, 161, 0, 0, 579, 588, 5, 162, 0, 0, 580, 588, 5, 163, 0, 0, 581, 588, 5, 164, 0, 0, 582, 588, 5, 165, 0, 0, 583, 588, 5, 166, 0, 0, 584, 588, 5, 167, 0, 0, 585, 588, 5, 169, 0, 0, 586, 588, 3, 378, 189, 0, 587, 576, 1, 0, 0, 0, 587, 577, 1, 0, 0, 0, 587, 578, 1, 0, 0, 0, 587, 579, 1, 0, 0, 0, 587, 580, 1, 0, 0, 0, 587, 581, 1, 0, 0, 0, 587, 582, 1, 0, 0, 0, 587, 583, 1, 0, 0, 0, 587, 584, 1, 0, 0, 0, 587, 585, 1, 0, 0, 0, 587, 586, 1, 0, 0, 0, 588, 35, 1, 0, 0, 0, 589, 595, 3, 38, 19, 0, 590, 591, 5, 148, 0, 0, 591, 592, 3, 74, 37, 0, 592, 593, 5, 133, 0, 0, 593, 594, 3, 74, 37, 0, 594, 596, 1, 0, 0, 0, 595, 590, 1, 0, 0, 0, 595, 596, 1, 0, 0, 0, 596, 37, 1, 0, 0, 0, 597, 603, 3, 40, 20, 0, 598, 601, 5, 150, 0, 0, 599, 602, 3, 38, 19, 0, 600, 602, 3, 76, 38, 0, 601, 599, 1, 0, 0, 0, 601, 600, 1, 0, 0, 0, 602, 604, 1, 0, 0, 0, 603, 598, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 39, 1, 0, 0, 0, 605, 610, 3, 42, 21, 0, 606, 607, 5, 154, 0, 0, 607, 609, 3, 42, 21, 0, 608, 606, 1, 0, 0, 0, 609, 612, 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 41, 1, 0, 0, 0, 612, 610, 1, 0, 0, 0, 613, 618, 3, 44, 22, 0, 614, 615, 5, 153, 0, 0, 615, 617, 3, 44, 22, 0, 616, 614, 1, 0, 0, 0, 617, 620, 1, 0, 0, 0, 618, 616, 1, 0, 0, 0, 618, 619, 1, 0, 0, 0, 619, 43, 1, 0, 0, 0, 620, 618, 1, 0, 0, 0, 621, 626, 3, 46, 23, 0, 622, 623, 5, 141, 0, 0, 623, 625, 3, 46, 23, 0, 624, 622, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 45, 1, 0, 0, 0, 628, 626, 1, 0, 0, 0, 629, 634, 3, 48, 24, 0, 630, 631, 5, 142, 0, 0, 631, 633, 3, 48, 24, 0, 632, 630, 1, 0, 0, 0, 633, 636, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 47, 1, 0, 0, 0, 636, 634, 1, 0, 0, 0, 637, 642, 3, 50, 25, 0, 638, 639, 5, 140, 0, 0, 639, 641, 3, 50, 25, 0, 640, 638, 1, 0, 0, 0, 641, 644, 1, 0, 0, 0, 642, 640, 1, 0, 0, 0, 642, 643, 1, 0, 0, 0, 643, 49, 1, 0, 0, 0, 644, 642, 1, 0, 0, 0, 645, 650, 3, 52, 26, 0, 646, 647, 7, 3, 0, 0, 647, 649, 3, 52, 26, 0, 648, 646, 1, 0, 0, 0, 649, 652, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 51, 1, 0, 0, 0, 652, 650, 1, 0, 0, 0, 653, 662, 3, 54, 27, 0, 654, 655, 7, 4, 0, 0, 655, 661, 3, 54, 27, 0, 656, 657, 5, 59, 0, 0, 657, 661, 3, 112, 56, 0, 658, 659, 5, 13, 0, 0, 659, 661, 3, 4, 2, 0, 660, 654, 1, 0, 0, 0, 660, 656, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 664, 1, 0, 0, 0, 662, 660, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 53, 1, 0, 0, 0, 664, 662, 1, 0, 0, 0, 665, 673, 3, 56, 28, 0, 666, 669, 5, 168, 0, 0, 667, 669, 3, 376, 188, 0, 668, 666, 1, 0, 0, 0, 668, 667, 1, 0, 0, 0, 669, 670, 1, 0, 0, 0, 670, 672, 3, 56, 28, 0, 671, 668, 1, 0, 0, 0, 672, 675, 1, 0, 0, 0, 673, 671, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 55, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 676, 681, 3, 58, 29, 0, 677, 678, 7, 5, 0, 0, 678, 680, 3, 58, 29, 0, 679, 677, 1, 0, 0, 0, 680, 683, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 681, 682, 1, 0, 0, 0, 682, 57, 1, 0, 0, 0, 683, 681, 1, 0, 0, 0, 684, 689, 3, 60, 30, 0, 685, 686, 7, 6, 0, 0, 686, 688, 3, 60, 30, 0, 687, 685, 1, 0, 0, 0, 688, 691, 1, 0, 0, 0, 689, 687, 1, 0, 0, 0, 689, 690, 1, 0, 0, 0, 690, 59, 1, 0, 0, 0, 691, 689, 1, 0, 0, 0, 692, 702, 3, 66, 33, 0, 693, 694, 5, 93, 0, 0, 694, 699, 5, 125, 0, 0, 695, 697, 3, 62, 31, 0, 696, 698, 5, 132, 0, 0, 697, 696, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 700, 1, 0, 0, 0, 699, 695, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 701, 1, 0, 0, 0, 701, 703, 5, 126, 0, 0, 702, 693, 1, 0, 0, 0, 702, 703, 1, 0, 0, 0, 703, 61, 1, 0, 0, 0, 704, 709, 3, 64, 32, 0, 705, 706, 5, 132, 0, 0, 706, 708, 3, 64, 32, 0, 707, 705, 1, 0, 0, 0, 708, 711, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 63, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 712, 714, 3, 28, 14, 0, 713, 715, 3, 188, 94, 0, 714, 713, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 717, 3, 374, 187, 0, 717, 718, 3, 74, 37, 0, 718, 65, 1, 0, 0, 0, 719, 728, 3, 68, 34, 0, 720, 722, 3, 68, 34, 0, 721, 720, 1, 0, 0, 0, 721, 722, 1, 0, 0, 0, 722, 723, 1, 0, 0, 0, 723, 725, 5, 171, 0, 0, 724, 726, 3, 68, 34, 0, 725, 724, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 728, 1, 0, 0, 0, 727, 719, 1, 0, 0, 0, 727, 721, 1, 0, 0, 0, 728, 67, 1, 0, 0, 0, 729, 756, 3, 70, 35, 0, 730, 731, 5, 135, 0, 0, 731, 756, 3, 68, 34, 0, 732, 733, 5, 136, 0, 0, 733, 756, 3, 68, 34, 0, 734, 735, 5, 143, 0, 0, 735, 756, 3, 68, 34, 0, 736, 737, 5, 144, 0, 0, 737, 756, 3, 68, 34, 0, 738, 739, 5, 151, 0, 0, 739, 756, 3, 68, 34, 0, 740, 741, 5, 152, 0, 0, 741, 756, 3, 68, 34, 0, 742, 743, 5, 129, 0, 0, 743, 744, 3, 4, 2, 0, 744, 745, 5, 130, 0, 0, 745, 746, 3, 68, 34, 0, 746, 756, 1, 0, 0, 0, 747, 748, 5, 16, 0, 0, 748, 756, 3, 68, 34, 0, 749, 750, 5, 140, 0, 0, 750, 756, 3, 68, 34, 0, 751, 752, 5, 137, 0, 0, 752, 756, 3, 68, 34, 0, 753, 754, 5, 142, 0, 0, 754, 756, 3, 68, 34, 0, 755, 729, 1, 0, 0, 0, 755, 730, 1, 0, 0, 0, 755, 732, 1, 0, 0, 0, 755, 734, 1, 0, 0, 0, 755, 736, 1, 0, 0, 0, 755, 738, 1, 0, 0, 0, 755, 740, 1, 0, 0, 0, 755, 742, 1, 0, 0, 0, 755, 747, 1, 0, 0, 0, 755, 749, 1, 0, 0, 0, 755, 751, 1, 0, 0, 0, 755, 753, 1, 0, 0, 0, 756, 69, 1, 0, 0, 0, 757, 759, 3, 72, 36, 0, 758, 760, 5, 143, 0, 0, 759, 758, 1, 0, 0, 0, 759, 760, 1, 0, 0, 0, 760, 764, 1, 0, 0, 0, 761, 763, 3, 80, 40, 0, 762, 761, 1, 0, 0, 0, 763, 766, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 764, 765, 1, 0, 0, 0, 765, 768, 1, 0, 0, 0, 766, 764, 1, 0, 0, 0, 767, 769, 5, 143, 0, 0, 768, 767, 1, 0, 0, 0, 768, 769, 1, 0, 0, 0, 769, 792, 1, 0, 0, 0, 770, 777, 3, 78, 39, 0, 771, 777, 3, 430, 215, 0, 772, 777, 5, 151, 0, 0, 773, 777, 5, 152, 0, 0, 774, 775, 5, 155, 0, 0, 775, 777, 3, 434, 217, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 776, 772, 1, 0, 0, 0, 776, 773, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 779, 1, 0, 0, 0, 778, 780, 5, 143, 0, 0, 779, 778, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 784, 1, 0, 0, 0, 781, 783, 3, 80, 40, 0, 782, 781, 1, 0, 0, 0, 783, 786, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, 785, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 789, 5, 143, 0, 0, 788, 787, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 791, 1, 0, 0, 0, 790, 776, 1, 0, 0, 0, 791, 794, 1, 0, 0, 0, 792, 790, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 71, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 795, 917, 3, 380, 190, 0, 796, 798, 3, 434, 217, 0, 797, 799, 3, 22, 11, 0, 798, 797, 1, 0, 0, 0, 798, 799, 1, 0, 0, 0, 799, 917, 1, 0, 0, 0, 800, 801, 5, 129, 0, 0, 801, 802, 3, 28, 14, 0, 802, 803, 5, 130, 0, 0, 803, 917, 1, 0, 0, 0, 804, 917, 3, 84, 42, 0, 805, 917, 3, 228, 114, 0, 806, 917, 5, 115, 0, 0, 807, 917, 5, 94, 0, 0, 808, 818, 5, 17, 0, 0, 809, 810, 5, 131, 0, 0, 810, 812, 3, 434, 217, 0, 811, 813, 3, 22, 11, 0, 812, 811, 1, 0, 0, 0, 812, 813, 1, 0, 0, 0, 813, 819, 1, 0, 0, 0, 814, 815, 5, 127, 0, 0, 815, 816, 3, 86, 43, 0, 816, 817, 5, 128, 0, 0, 817, 819, 1, 0, 0, 0, 818, 809, 1, 0, 0, 0, 818, 814, 1, 0, 0, 0, 819, 917, 1, 0, 0, 0, 820, 849, 5, 66, 0, 0, 821, 843, 3, 4, 2, 0, 822, 844, 3, 432, 216, 0, 823, 844, 3, 88, 44, 0, 824, 825, 5, 127, 0, 0, 825, 826, 3, 86, 43, 0, 826, 830, 5, 128, 0, 0, 827, 829, 3, 322, 161, 0, 828, 827, 1, 0, 0, 0, 829, 832, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 834, 1, 0, 0, 0, 832, 830, 1, 0, 0, 0, 833, 835, 3, 324, 162, 0, 834, 833, 1, 0, 0, 0, 834, 835, 1, 0, 0, 0, 835, 844, 1, 0, 0, 0, 836, 838, 3, 322, 161, 0, 837, 836, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 839, 840, 1, 0, 0, 0, 840, 841, 1, 0, 0, 0, 841, 842, 3, 324, 162, 0, 842, 844, 1, 0, 0, 0, 843, 822, 1, 0, 0, 0, 843, 823, 1, 0, 0, 0, 843, 824, 1, 0, 0, 0, 843, 837, 1, 0, 0, 0, 844, 850, 1, 0, 0, 0, 845, 850, 3, 102, 51, 0, 846, 847, 3, 322, 161, 0, 847, 848, 3, 324, 162, 0, 848, 850, 1, 0, 0, 0, 849, 821, 1, 0, 0, 0, 849, 845, 1, 0, 0, 0, 849, 846, 1, 0, 0, 0, 850, 917, 1, 0, 0, 0, 851, 852, 5, 129, 0, 0, 852, 855, 3, 26, 13, 0, 853, 854, 5, 132, 0, 0, 854, 856, 3, 26, 13, 0, 855, 853, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 855, 1, 0, 0, 0, 857, 858, 1, 0, 0, 0, 858, 859, 1, 0, 0, 0, 859, 860, 5, 130, 0, 0, 860, 917, 1, 0, 0, 0, 861, 862, 5, 98, 0, 0, 862, 866, 5, 129, 0, 0, 863, 867, 3, 108, 54, 0, 864, 867, 3, 4, 2, 0, 865, 867, 5, 108, 0, 0, 866, 863, 1, 0, 0, 0, 866, 864, 1, 0, 0, 0, 866, 865, 1, 0, 0, 0, 867, 868, 1, 0, 0, 0, 868, 917, 5, 130, 0, 0, 869, 870, 5, 25, 0, 0, 870, 871, 5, 129, 0, 0, 871, 872, 3, 28, 14, 0, 872, 873, 5, 130, 0, 0, 873, 917, 1, 0, 0, 0, 874, 875, 5, 101, 0, 0, 875, 876, 5, 129, 0, 0, 876, 877, 3, 28, 14, 0, 877, 878, 5, 130, 0, 0, 878, 917, 1, 0, 0, 0, 879, 884, 5, 30, 0, 0, 880, 881, 5, 129, 0, 0, 881, 882, 3, 4, 2, 0, 882, 883, 5, 130, 0, 0, 883, 885, 1, 0, 0, 0, 884, 880, 1, 0, 0, 0, 884, 885, 1, 0, 0, 0, 885, 917, 1, 0, 0, 0, 886, 888, 5, 15, 0, 0, 887, 886, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 889, 1, 0, 0, 0, 889, 895, 5, 31, 0, 0, 890, 892, 5, 129, 0, 0, 891, 893, 3, 122, 61, 0, 892, 891, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 896, 5, 130, 0, 0, 895, 890, 1, 0, 0, 0, 895, 896, 1, 0, 0, 0, 896, 897, 1, 0, 0, 0, 897, 917, 3, 170, 85, 0, 898, 899, 5, 88, 0, 0, 899, 900, 5, 129, 0, 0, 900, 901, 3, 4, 2, 0, 901, 902, 5, 130, 0, 0, 902, 917, 1, 0, 0, 0, 903, 904, 5, 64, 0, 0, 904, 910, 5, 129, 0, 0, 905, 906, 3, 434, 217, 0, 906, 907, 5, 131, 0, 0, 907, 909, 1, 0, 0, 0, 908, 905, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 913, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 434, 217, 0, 914, 915, 5, 130, 0, 0, 915, 917, 1, 0, 0, 0, 916, 795, 1, 0, 0, 0, 916, 796, 1, 0, 0, 0, 916, 800, 1, 0, 0, 0, 916, 804, 1, 0, 0, 0, 916, 805, 1, 0, 0, 0, 916, 806, 1, 0, 0, 0, 916, 807, 1, 0, 0, 0, 916, 808, 1, 0, 0, 0, 916, 820, 1, 0, 0, 0, 916, 851, 1, 0, 0, 0, 916, 861, 1, 0, 0, 0, 916, 869, 1, 0, 0, 0, 916, 874, 1, 0, 0, 0, 916, 879, 1, 0, 0, 0, 916, 887, 1, 0, 0, 0, 916, 898, 1, 0, 0, 0, 916, 903, 1, 0, 0, 0, 917, 73, 1, 0, 0, 0, 918, 921, 3, 28, 14, 0, 919, 921, 3, 76, 38, 0, 920, 918, 1, 0, 0, 0, 920, 919, 1, 0, 0, 0, 921, 75, 1, 0, 0, 0, 922, 923, 5, 95, 0, 0, 923, 924, 3, 28, 14, 0, 924, 77, 1, 0, 0, 0, 925, 927, 5, 148, 0, 0, 926, 925, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 928, 1, 0, 0, 0, 928, 929, 5, 131, 0, 0, 929, 931, 3, 434, 217, 0, 930, 932, 3, 22, 11, 0, 931, 930, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 79, 1, 0, 0, 0, 933, 935, 5, 148, 0, 0, 934, 933, 1, 0, 0, 0, 934, 935, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 937, 5, 127, 0, 0, 937, 942, 3, 82, 41, 0, 938, 939, 5, 132, 0, 0, 939, 941, 3, 82, 41, 0, 940, 938, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 945, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 946, 5, 128, 0, 0, 946, 81, 1, 0, 0, 0, 947, 948, 3, 434, 217, 0, 948, 949, 5, 133, 0, 0, 949, 951, 1, 0, 0, 0, 950, 947, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 3, 28, 14, 0, 953, 83, 1, 0, 0, 0, 954, 955, 7, 7, 0, 0, 955, 85, 1, 0, 0, 0, 956, 961, 3, 28, 14, 0, 957, 958, 5, 132, 0, 0, 958, 960, 3, 28, 14, 0, 959, 957, 1, 0, 0, 0, 960, 963, 1, 0, 0, 0, 961, 959, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 87, 1, 0, 0, 0, 963, 961, 1, 0, 0, 0, 964, 967, 3, 90, 45, 0, 965, 967, 3, 98, 49, 0, 966, 964, 1, 0, 0, 0, 966, 965, 1, 0, 0, 0, 967, 89, 1, 0, 0, 0, 968, 973, 5, 125, 0, 0, 969, 971, 3, 92, 46, 0, 970, 972, 5, 132, 0, 0, 971, 970, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 974, 1, 0, 0, 0, 973, 969, 1, 0, 0, 0, 973, 974, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 5, 126, 0, 0, 976, 91, 1, 0, 0, 0, 977, 982, 3, 94, 47, 0, 978, 979, 5, 132, 0, 0, 979, 981, 3, 94, 47, 0, 980, 978, 1, 0, 0, 0, 981, 984, 1, 0, 0, 0, 982, 980, 1, 0, 0, 0, 982, 983, 1, 0, 0, 0, 983, 93, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 985, 991, 3, 434, 217, 0, 986, 987, 5, 127, 0, 0, 987, 988, 3, 28, 14, 0, 988, 989, 5, 128, 0, 0, 989, 991, 1, 0, 0, 0, 990, 985, 1, 0, 0, 0, 990, 986, 1, 0, 0, 0, 991, 992, 1, 0, 0, 0, 992, 993, 5, 145, 0, 0, 993, 994, 3, 96, 48, 0, 994, 95, 1, 0, 0, 0, 995, 998, 3, 28, 14, 0, 996, 998, 3, 88, 44, 0, 997, 995, 1, 0, 0, 0, 997, 996, 1, 0, 0, 0, 998, 97, 1, 0, 0, 0, 999, 1000, 5, 125, 0, 0, 1000, 1005, 3, 100, 50, 0, 1001, 1002, 5, 132, 0, 0, 1002, 1004, 3, 100, 50, 0, 1003, 1001, 1, 0, 0, 0, 1004, 1007, 1, 0, 0, 0, 1005, 1003, 1, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1009, 1, 0, 0, 0, 1007, 1005, 1, 0, 0, 0, 1008, 1010, 5, 132, 0, 0, 1009, 1008, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 5, 126, 0, 0, 1012, 99, 1, 0, 0, 0, 1013, 1019, 3, 30, 15, 0, 1014, 1015, 5, 125, 0, 0, 1015, 1016, 3, 86, 43, 0, 1016, 1017, 5, 126, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 1013, 1, 0, 0, 0, 1018, 1014, 1, 0, 0, 0, 1019, 101, 1, 0, 0, 0, 1020, 1025, 5, 125, 0, 0, 1021, 1023, 3, 104, 52, 0, 1022, 1024, 5, 132, 0, 0, 1023, 1022, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1026, 1, 0, 0, 0, 1025, 1021, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 1027, 1, 0, 0, 0, 1027, 1028, 5, 126, 0, 0, 1028, 103, 1, 0, 0, 0, 1029, 1034, 3, 106, 53, 0, 1030, 1031, 5, 132, 0, 0, 1031, 1033, 3, 106, 53, 0, 1032, 1030, 1, 0, 0, 0, 1033, 1036, 1, 0, 0, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1035, 1, 0, 0, 0, 1035, 105, 1, 0, 0, 0, 1036, 1034, 1, 0, 0, 0, 1037, 1043, 3, 70, 35, 0, 1038, 1039, 3, 434, 217, 0, 1039, 1040, 5, 145, 0, 0, 1040, 1041, 3, 28, 14, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1037, 1, 0, 0, 0, 1042, 1038, 1, 0, 0, 0, 1043, 107, 1, 0, 0, 0, 1044, 1053, 3, 434, 217, 0, 1045, 1047, 3, 110, 55, 0, 1046, 1045, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1054, 1, 0, 0, 0, 1048, 1049, 5, 149, 0, 0, 1049, 1051, 3, 434, 217, 0, 1050, 1052, 3, 110, 55, 0, 1051, 1050, 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1054, 1, 0, 0, 0, 1053, 1046, 1, 0, 0, 0, 1053, 1048, 1, 0, 0, 0, 1054, 1062, 1, 0, 0, 0, 1055, 1056, 5, 131, 0, 0, 1056, 1058, 3, 434, 217, 0, 1057, 1059, 3, 110, 55, 0, 1058, 1057, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1061, 1, 0, 0, 0, 1060, 1055, 1, 0, 0, 0, 1061, 1064, 1, 0, 0, 0, 1062, 1060, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 109, 1, 0, 0, 0, 1064, 1062, 1, 0, 0, 0, 1065, 1069, 5, 146, 0, 0, 1066, 1068, 5, 132, 0, 0, 1067, 1066, 1, 0, 0, 0, 1068, 1071, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1072, 1073, 5, 147, 0, 0, 1073, 111, 1, 0, 0, 0, 1074, 1079, 3, 6, 3, 0, 1075, 1078, 3, 322, 161, 0, 1076, 1078, 5, 137, 0, 0, 1077, 1075, 1, 0, 0, 0, 1077, 1076, 1, 0, 0, 0, 1078, 1081, 1, 0, 0, 0, 1079, 1077, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 1083, 1, 0, 0, 0, 1081, 1079, 1, 0, 0, 0, 1082, 1084, 5, 148, 0, 0, 1083, 1082, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1087, 3, 114, 57, 0, 1086, 1085, 1, 0, 0, 0, 1086, 1087, 1, 0, 0, 0, 1087, 1089, 1, 0, 0, 0, 1088, 1090, 3, 434, 217, 0, 1089, 1088, 1, 0, 0, 0, 1089, 1090, 1, 0, 0, 0, 1090, 113, 1, 0, 0, 0, 1091, 1092, 5, 125, 0, 0, 1092, 1097, 3, 116, 58, 0, 1093, 1094, 5, 132, 0, 0, 1094, 1096, 3, 116, 58, 0, 1095, 1093, 1, 0, 0, 0, 1096, 1099, 1, 0, 0, 0, 1097, 1095, 1, 0, 0, 0, 1097, 1098, 1, 0, 0, 0, 1098, 1100, 1, 0, 0, 0, 1099, 1097, 1, 0, 0, 0, 1100, 1101, 5, 126, 0, 0, 1101, 115, 1, 0, 0, 0, 1102, 1103, 3, 434, 217, 0, 1103, 1104, 5, 133, 0, 0, 1104, 1105, 3, 28, 14, 0, 1105, 117, 1, 0, 0, 0, 1106, 1108, 5, 15, 0, 0, 1107, 1106, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1110, 3, 120, 60, 0, 1110, 1111, 3, 374, 187, 0, 1111, 1112, 3, 128, 64, 0, 1112, 119, 1, 0, 0, 0, 1113, 1114, 5, 129, 0, 0, 1114, 1125, 5, 130, 0, 0, 1115, 1116, 5, 129, 0, 0, 1116, 1117, 3, 122, 61, 0, 1117, 1118, 5, 130, 0, 0, 1118, 1125, 1, 0, 0, 0, 1119, 1120, 5, 129, 0, 0, 1120, 1121, 3, 126, 63, 0, 1121, 1122, 5, 130, 0, 0, 1122, 1125, 1, 0, 0, 0, 1123, 1125, 3, 434, 217, 0, 1124, 1113, 1, 0, 0, 0, 1124, 1115, 1, 0, 0, 0, 1124, 1119, 1, 0, 0, 0, 1124, 1123, 1, 0, 0, 0, 1125, 121, 1, 0, 0, 0, 1126, 1131, 3, 124, 62, 0, 1127, 1128, 5, 132, 0, 0, 1128, 1130, 3, 124, 62, 0, 1129, 1127, 1, 0, 0, 0, 1130, 1133, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 123, 1, 0, 0, 0, 1133, 1131, 1, 0, 0, 0, 1134, 1136, 7, 2, 0, 0, 1135, 1134, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1138, 3, 4, 2, 0, 1138, 1139, 3, 434, 217, 0, 1139, 125, 1, 0, 0, 0, 1140, 1145, 3, 434, 217, 0, 1141, 1142, 5, 132, 0, 0, 1142, 1144, 3, 434, 217, 0, 1143, 1141, 1, 0, 0, 0, 1144, 1147, 1, 0, 0, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1146, 1, 0, 0, 0, 1146, 127, 1, 0, 0, 0, 1147, 1145, 1, 0, 0, 0, 1148, 1151, 3, 74, 37, 0, 1149, 1151, 3, 170, 85, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1149, 1, 0, 0, 0, 1151, 129, 1, 0, 0, 0, 1152, 1153, 3, 132, 66, 0, 1153, 1154, 3, 134, 67, 0, 1154, 131, 1, 0, 0, 0, 1155, 1157, 5, 48, 0, 0, 1156, 1158, 3, 4, 2, 0, 1157, 1156, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1160, 3, 434, 217, 0, 1160, 1161, 5, 54, 0, 0, 1161, 1162, 3, 28, 14, 0, 1162, 133, 1, 0, 0, 0, 1163, 1165, 3, 136, 68, 0, 1164, 1163, 1, 0, 0, 0, 1165, 1168, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1169, 1, 0, 0, 0, 1168, 1166, 1, 0, 0, 0, 1169, 1171, 3, 148, 74, 0, 1170, 1172, 3, 150, 75, 0, 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 135, 1, 0, 0, 0, 1173, 1179, 3, 132, 66, 0, 1174, 1179, 3, 138, 69, 0, 1175, 1179, 3, 140, 70, 0, 1176, 1179, 3, 142, 71, 0, 1177, 1179, 3, 144, 72, 0, 1178, 1173, 1, 0, 0, 0, 1178, 1174, 1, 0, 0, 0, 1178, 1175, 1, 0, 0, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 137, 1, 0, 0, 0, 1180, 1181, 5, 61, 0, 0, 1181, 1182, 3, 434, 217, 0, 1182, 1183, 5, 145, 0, 0, 1183, 1184, 3, 28, 14, 0, 1184, 139, 1, 0, 0, 0, 1185, 1186, 5, 111, 0, 0, 1186, 1187, 3, 28, 14, 0, 1187, 141, 1, 0, 0, 0, 1188, 1190, 5, 60, 0, 0, 1189, 1191, 3, 4, 2, 0, 1190, 1189, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 1193, 3, 434, 217, 0, 1193, 1194, 5, 54, 0, 0, 1194, 1195, 3, 28, 14, 0, 1195, 1196, 5, 69, 0, 0, 1196, 1197, 3, 28, 14, 0, 1197, 1198, 5, 38, 0, 0, 1198, 1201, 3, 28, 14, 0, 1199, 1200, 5, 58, 0, 0, 1200, 1202, 3, 434, 217, 0, 1201, 1199, 1, 0, 0, 0, 1201, 1202, 1, 0, 0, 0, 1202, 143, 1, 0, 0, 0, 1203, 1204, 5, 71, 0, 0, 1204, 1209, 3, 146, 73, 0, 1205, 1206, 5, 132, 0, 0, 1206, 1208, 3, 146, 73, 0, 1207, 1205, 1, 0, 0, 0, 1208, 1211, 1, 0, 0, 0, 1209, 1207, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 145, 1, 0, 0, 0, 1211, 1209, 1, 0, 0, 0, 1212, 1214, 3, 28, 14, 0, 1213, 1215, 7, 8, 0, 0, 1214, 1213, 1, 0, 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 147, 1, 0, 0, 0, 1216, 1217, 5, 85, 0, 0, 1217, 1224, 3, 28, 14, 0, 1218, 1219, 5, 51, 0, 0, 1219, 1220, 3, 28, 14, 0, 1220, 1221, 5, 20, 0, 0, 1221, 1222, 3, 28, 14, 0, 1222, 1224, 1, 0, 0, 0, 1223, 1216, 1, 0, 0, 0, 1223, 1218, 1, 0, 0, 0, 1224, 149, 1, 0, 0, 0, 1225, 1226, 5, 58, 0, 0, 1226, 1227, 3, 434, 217, 0, 1227, 1228, 3, 134, 67, 0, 1228, 151, 1, 0, 0, 0, 1229, 1233, 3, 164, 82, 0, 1230, 1233, 3, 154, 77, 0, 1231, 1233, 3, 166, 83, 0, 1232, 1229, 1, 0, 0, 0, 1232, 1230, 1, 0, 0, 0, 1232, 1231, 1, 0, 0, 0, 1233, 153, 1, 0, 0, 0, 1234, 1235, 3, 172, 86, 0, 1235, 1236, 5, 134, 0, 0, 1236, 1242, 1, 0, 0, 0, 1237, 1238, 3, 180, 90, 0, 1238, 1239, 5, 134, 0, 0, 1239, 1242, 1, 0, 0, 0, 1240, 1242, 3, 156, 78, 0, 1241, 1234, 1, 0, 0, 0, 1241, 1237, 1, 0, 0, 0, 1241, 1240, 1, 0, 0, 0, 1242, 155, 1, 0, 0, 0, 1243, 1244, 3, 158, 79, 0, 1244, 1245, 3, 162, 81, 0, 1245, 157, 1, 0, 0, 0, 1246, 1248, 3, 160, 80, 0, 1247, 1246, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1249, 1, 0, 0, 0, 1249, 1250, 3, 274, 137, 0, 1250, 1252, 3, 434, 217, 0, 1251, 1253, 3, 230, 115, 0, 1252, 1251, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1256, 5, 129, 0, 0, 1255, 1257, 3, 280, 140, 0, 1256, 1255, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1260, 5, 130, 0, 0, 1259, 1261, 3, 238, 119, 0, 1260, 1259, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 159, 1, 0, 0, 0, 1262, 1264, 7, 9, 0, 0, 1263, 1265, 5, 90, 0, 0, 1264, 1263, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1269, 1, 0, 0, 0, 1266, 1267, 5, 90, 0, 0, 1267, 1269, 7, 9, 0, 0, 1268, 1262, 1, 0, 0, 0, 1268, 1266, 1, 0, 0, 0, 1269, 161, 1, 0, 0, 0, 1270, 1276, 3, 170, 85, 0, 1271, 1272, 3, 374, 187, 0, 1272, 1273, 3, 74, 37, 0, 1273, 1274, 5, 134, 0, 0, 1274, 1276, 1, 0, 0, 0, 1275, 1270, 1, 0, 0, 0, 1275, 1271, 1, 0, 0, 0, 1276, 163, 1, 0, 0, 0, 1277, 1278, 3, 434, 217, 0, 1278, 1279, 5, 133, 0, 0, 1279, 1280, 3, 152, 76, 0, 1280, 165, 1, 0, 0, 0, 1281, 1284, 3, 170, 85, 0, 1282, 1284, 3, 168, 84, 0, 1283, 1281, 1, 0, 0, 0, 1283, 1282, 1, 0, 0, 0, 1284, 167, 1, 0, 0, 0, 1285, 1416, 5, 134, 0, 0, 1286, 1287, 3, 28, 14, 0, 1287, 1288, 5, 134, 0, 0, 1288, 1416, 1, 0, 0, 0, 1289, 1290, 5, 52, 0, 0, 1290, 1291, 5, 129, 0, 0, 1291, 1292, 3, 28, 14, 0, 1292, 1293, 5, 130, 0, 0, 1293, 1296, 3, 182, 91, 0, 1294, 1295, 5, 36, 0, 0, 1295, 1297, 3, 182, 91, 0, 1296, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1416, 1, 0, 0, 0, 1298, 1299, 5, 93, 0, 0, 1299, 1300, 5, 129, 0, 0, 1300, 1301, 3, 28, 14, 0, 1301, 1302, 5, 130, 0, 0, 1302, 1306, 5, 125, 0, 0, 1303, 1305, 3, 184, 92, 0, 1304, 1303, 1, 0, 0, 0, 1305, 1308, 1, 0, 0, 0, 1306, 1304, 1, 0, 0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 1309, 1, 0, 0, 0, 1308, 1306, 1, 0, 0, 0, 1309, 1310, 5, 126, 0, 0, 1310, 1416, 1, 0, 0, 0, 1311, 1312, 5, 112, 0, 0, 1312, 1313, 5, 129, 0, 0, 1313, 1314, 3, 28, 14, 0, 1314, 1315, 5, 130, 0, 0, 1315, 1316, 3, 166, 83, 0, 1316, 1416, 1, 0, 0, 0, 1317, 1318, 5, 33, 0, 0, 1318, 1319, 3, 166, 83, 0, 1319, 1320, 5, 112, 0, 0, 1320, 1321, 5, 129, 0, 0, 1321, 1322, 3, 28, 14, 0, 1322, 1323, 5, 130, 0, 0, 1323, 1324, 5, 134, 0, 0, 1324, 1416, 1, 0, 0, 0, 1325, 1326, 5, 46, 0, 0, 1326, 1328, 5, 129, 0, 0, 1327, 1329, 3, 192, 96, 0, 1328, 1327, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 1332, 5, 134, 0, 0, 1331, 1333, 3, 28, 14, 0, 1332, 1331, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1336, 5, 134, 0, 0, 1335, 1337, 3, 194, 97, 0, 1336, 1335, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 1338, 1, 0, 0, 0, 1338, 1339, 5, 130, 0, 0, 1339, 1416, 3, 166, 83, 0, 1340, 1342, 5, 16, 0, 0, 1341, 1340, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 5, 47, 0, 0, 1344, 1345, 5, 129, 0, 0, 1345, 1346, 3, 174, 87, 0, 1346, 1347, 3, 434, 217, 0, 1347, 1348, 5, 54, 0, 0, 1348, 1349, 3, 28, 14, 0, 1349, 1350, 5, 130, 0, 0, 1350, 1351, 3, 166, 83, 0, 1351, 1416, 1, 0, 0, 0, 1352, 1353, 5, 19, 0, 0, 1353, 1416, 5, 134, 0, 0, 1354, 1355, 5, 28, 0, 0, 1355, 1416, 5, 134, 0, 0, 1356, 1361, 5, 50, 0, 0, 1357, 1362, 3, 434, 217, 0, 1358, 1359, 5, 22, 0, 0, 1359, 1362, 3, 28, 14, 0, 1360, 1362, 5, 30, 0, 0, 1361, 1357, 1, 0, 0, 0, 1361, 1358, 1, 0, 0, 0, 1361, 1360, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1416, 5, 134, 0, 0, 1364, 1366, 5, 82, 0, 0, 1365, 1367, 3, 28, 14, 0, 1366, 1365, 1, 0, 0, 0, 1366, 1367, 1, 0, 0, 0, 1367, 1368, 1, 0, 0, 0, 1368, 1416, 5, 134, 0, 0, 1369, 1371, 5, 95, 0, 0, 1370, 1372, 3, 28, 14, 0, 1371, 1370, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1416, 5, 134, 0, 0, 1374, 1375, 5, 97, 0, 0, 1375, 1381, 3, 170, 85, 0, 1376, 1378, 3, 196, 98, 0, 1377, 1379, 3, 204, 102, 0, 1378, 1377, 1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1382, 1, 0, 0, 0, 1380, 1382, 3, 204, 102, 0, 1381, 1376, 1, 0, 0, 0, 1381, 1380, 1, 0, 0, 0, 1382, 1416, 1, 0, 0, 0, 1383, 1384, 5, 25, 0, 0, 1384, 1416, 3, 170, 85, 0, 1385, 1386, 5, 101, 0, 0, 1386, 1416, 3, 170, 85, 0, 1387, 1388, 5, 62, 0, 0, 1388, 1389, 5, 129, 0, 0, 1389, 1390, 3, 28, 14, 0, 1390, 1391, 5, 130, 0, 0, 1391, 1392, 3, 166, 83, 0, 1392, 1416, 1, 0, 0, 0, 1393, 1394, 5, 105, 0, 0, 1394, 1395, 5, 129, 0, 0, 1395, 1396, 3, 206, 103, 0, 1396, 1397, 5, 130, 0, 0, 1397, 1398, 3, 166, 83, 0, 1398, 1416, 1, 0, 0, 0, 1399, 1403, 5, 113, 0, 0, 1400, 1401, 5, 82, 0, 0, 1401, 1404, 3, 28, 14, 0, 1402, 1404, 5, 19, 0, 0, 1403, 1400, 1, 0, 0, 0, 1403, 1402, 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, 1416, 5, 134, 0, 0, 1406, 1407, 5, 103, 0, 0, 1407, 1416, 3, 170, 85, 0, 1408, 1409, 5, 44, 0, 0, 1409, 1410, 5, 129, 0, 0, 1410, 1411, 3, 362, 181, 0, 1411, 1412, 3, 364, 182, 0, 1412, 1413, 5, 130, 0, 0, 1413, 1414, 3, 166, 83, 0, 1414, 1416, 1, 0, 0, 0, 1415, 1285, 1, 0, 0, 0, 1415, 1286, 1, 0, 0, 0, 1415, 1289, 1, 0, 0, 0, 1415, 1298, 1, 0, 0, 0, 1415, 1311, 1, 0, 0, 0, 1415, 1317, 1, 0, 0, 0, 1415, 1325, 1, 0, 0, 0, 1415, 1341, 1, 0, 0, 0, 1415, 1352, 1, 0, 0, 0, 1415, 1354, 1, 0, 0, 0, 1415, 1356, 1, 0, 0, 0, 1415, 1364, 1, 0, 0, 0, 1415, 1369, 1, 0, 0, 0, 1415, 1374, 1, 0, 0, 0, 1415, 1383, 1, 0, 0, 0, 1415, 1385, 1, 0, 0, 0, 1415, 1387, 1, 0, 0, 0, 1415, 1393, 1, 0, 0, 0, 1415, 1399, 1, 0, 0, 0, 1415, 1406, 1, 0, 0, 0, 1415, 1408, 1, 0, 0, 0, 1416, 169, 1, 0, 0, 0, 1417, 1419, 5, 125, 0, 0, 1418, 1420, 3, 190, 95, 0, 1419, 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 5, 126, 0, 0, 1422, 171, 1, 0, 0, 0, 1423, 1428, 5, 105, 0, 0, 1424, 1428, 5, 80, 0, 0, 1425, 1426, 5, 80, 0, 0, 1426, 1428, 5, 79, 0, 0, 1427, 1423, 1, 0, 0, 0, 1427, 1424, 1, 0, 0, 0, 1427, 1425, 1, 0, 0, 0, 1427, 1428, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1430, 3, 174, 87, 0, 1430, 1435, 3, 176, 88, 0, 1431, 1432, 5, 132, 0, 0, 1432, 1434, 3, 176, 88, 0, 1433, 1431, 1, 0, 0, 0, 1434, 1437, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1443, 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1438, 1439, 5, 44, 0, 0, 1439, 1440, 3, 362, 181, 0, 1440, 1441, 3, 364, 182, 0, 1441, 1443, 1, 0, 0, 0, 1442, 1427, 1, 0, 0, 0, 1442, 1438, 1, 0, 0, 0, 1443, 173, 1, 0, 0, 0, 1444, 1447, 5, 106, 0, 0, 1445, 1447, 3, 4, 2, 0, 1446, 1444, 1, 0, 0, 0, 1446, 1445, 1, 0, 0, 0, 1447, 175, 1, 0, 0, 0, 1448, 1454, 3, 434, 217, 0, 1449, 1451, 5, 145, 0, 0, 1450, 1452, 5, 80, 0, 0, 1451, 1450, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1455, 3, 178, 89, 0, 1454, 1449, 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 177, 1, 0, 0, 0, 1456, 1460, 3, 28, 14, 0, 1457, 1460, 3, 324, 162, 0, 1458, 1460, 3, 372, 186, 0, 1459, 1456, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, 0, 1459, 1458, 1, 0, 0, 0, 1460, 179, 1, 0, 0, 0, 1461, 1462, 5, 27, 0, 0, 1462, 1463, 3, 4, 2, 0, 1463, 1464, 3, 264, 132, 0, 1464, 181, 1, 0, 0, 0, 1465, 1468, 3, 170, 85, 0, 1466, 1468, 3, 168, 84, 0, 1467, 1465, 1, 0, 0, 0, 1467, 1466, 1, 0, 0, 0, 1468, 183, 1, 0, 0, 0, 1469, 1471, 3, 186, 93, 0, 1470, 1469, 1, 0, 0, 0, 1471, 1472, 1, 0, 0, 0, 1472, 1470, 1, 0, 0, 0, 1472, 1473, 1, 0, 0, 0, 1473, 1474, 1, 0, 0, 0, 1474, 1475, 3, 190, 95, 0, 1475, 185, 1, 0, 0, 0, 1476, 1477, 5, 22, 0, 0, 1477, 1479, 3, 28, 14, 0, 1478, 1480, 3, 188, 94, 0, 1479, 1478, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1482, 5, 133, 0, 0, 1482, 1486, 1, 0, 0, 0, 1483, 1484, 5, 30, 0, 0, 1484, 1486, 5, 133, 0, 0, 1485, 1476, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1486, 187, 1, 0, 0, 0, 1487, 1488, 5, 110, 0, 0, 1488, 1489, 3, 28, 14, 0, 1489, 189, 1, 0, 0, 0, 1490, 1492, 3, 152, 76, 0, 1491, 1490, 1, 0, 0, 0, 1492, 1493, 1, 0, 0, 0, 1493, 1491, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 191, 1, 0, 0, 0, 1495, 1505, 3, 172, 86, 0, 1496, 1501, 3, 28, 14, 0, 1497, 1498, 5, 132, 0, 0, 1498, 1500, 3, 28, 14, 0, 1499, 1497, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1505, 1, 0, 0, 0, 1503, 1501, 1, 0, 0, 0, 1504, 1495, 1, 0, 0, 0, 1504, 1496, 1, 0, 0, 0, 1505, 193, 1, 0, 0, 0, 1506, 1511, 3, 28, 14, 0, 1507, 1508, 5, 132, 0, 0, 1508, 1510, 3, 28, 14, 0, 1509, 1507, 1, 0, 0, 0, 1510, 1513, 1, 0, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 195, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1514, 1518, 3, 198, 99, 0, 1515, 1517, 3, 198, 99, 0, 1516, 1515, 1, 0, 0, 0, 1517, 1520, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1522, 1, 0, 0, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1523, 3, 200, 100, 0, 1522, 1521, 1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1526, 1, 0, 0, 0, 1524, 1526, 3, 200, 100, 0, 1525, 1514, 1, 0, 0, 0, 1525, 1524, 1, 0, 0, 0, 1526, 197, 1, 0, 0, 0, 1527, 1528, 5, 23, 0, 0, 1528, 1529, 5, 129, 0, 0, 1529, 1531, 3, 20, 10, 0, 1530, 1532, 3, 434, 217, 0, 1531, 1530, 1, 0, 0, 0, 1531, 1532, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1535, 5, 130, 0, 0, 1534, 1536, 3, 202, 101, 0, 1535, 1534, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1537, 1, 0, 0, 0, 1537, 1538, 3, 170, 85, 0, 1538, 199, 1, 0, 0, 0, 1539, 1541, 5, 23, 0, 0, 1540, 1542, 3, 202, 101, 0, 1541, 1540, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1544, 3, 170, 85, 0, 1544, 201, 1, 0, 0, 0, 1545, 1546, 5, 110, 0, 0, 1546, 1547, 5, 129, 0, 0, 1547, 1548, 3, 28, 14, 0, 1548, 1549, 5, 130, 0, 0, 1549, 203, 1, 0, 0, 0, 1550, 1551, 5, 43, 0, 0, 1551, 1552, 3, 170, 85, 0, 1552, 205, 1, 0, 0, 0, 1553, 1556, 3, 172, 86, 0, 1554, 1556, 3, 28, 14, 0, 1555, 1553, 1, 0, 0, 0, 1555, 1554, 1, 0, 0, 0, 1556, 207, 1, 0, 0, 0, 1557, 1558, 5, 65, 0, 0, 1558, 1559, 3, 210, 105, 0, 1559, 1561, 3, 212, 106, 0, 1560, 1562, 5, 134, 0, 0, 1561, 1560, 1, 0, 0, 0, 1561, 1562, 1, 0, 0, 0, 1562, 209, 1, 0, 0, 0, 1563, 1568, 3, 434, 217, 0, 1564, 1565, 5, 131, 0, 0, 1565, 1567, 3, 434, 217, 0, 1566, 1564, 1, 0, 0, 0, 1567, 1570, 1, 0, 0, 0, 1568, 1566, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 211, 1, 0, 0, 0, 1570, 1568, 1, 0, 0, 0, 1571, 1573, 5, 125, 0, 0, 1572, 1574, 3, 214, 107, 0, 1573, 1572, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1577, 3, 218, 109, 0, 1576, 1575, 1, 0, 0, 0, 1576, 1577, 1, 0, 0, 0, 1577, 1579, 1, 0, 0, 0, 1578, 1580, 3, 222, 111, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1582, 5, 126, 0, 0, 1582, 213, 1, 0, 0, 0, 1583, 1585, 3, 216, 108, 0, 1584, 1583, 1, 0, 0, 0, 1585, 1586, 1, 0, 0, 0, 1586, 1584, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 215, 1, 0, 0, 0, 1588, 1589, 5, 41, 0, 0, 1589, 1590, 5, 11, 0, 0, 1590, 1591, 3, 434, 217, 0, 1591, 1592, 5, 134, 0, 0, 1592, 217, 1, 0, 0, 0, 1593, 1595, 3, 220, 110, 0, 1594, 1593, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 219, 1, 0, 0, 0, 1598, 1599, 5, 105, 0, 0, 1599, 1600, 3, 434, 217, 0, 1600, 1601, 5, 145, 0, 0, 1601, 1602, 3, 2, 1, 0, 1602, 1603, 5, 134, 0, 0, 1603, 1614, 1, 0, 0, 0, 1604, 1605, 5, 105, 0, 0, 1605, 1606, 3, 2, 1, 0, 1606, 1607, 5, 134, 0, 0, 1607, 1614, 1, 0, 0, 0, 1608, 1609, 5, 105, 0, 0, 1609, 1610, 5, 90, 0, 0, 1610, 1611, 3, 2, 1, 0, 1611, 1612, 5, 134, 0, 0, 1612, 1614, 1, 0, 0, 0, 1613, 1598, 1, 0, 0, 0, 1613, 1604, 1, 0, 0, 0, 1613, 1608, 1, 0, 0, 0, 1614, 221, 1, 0, 0, 0, 1615, 1617, 3, 224, 112, 0, 1616, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 223, 1, 0, 0, 0, 1620, 1623, 3, 208, 104, 0, 1621, 1623, 3, 226, 113, 0, 1622, 1620, 1, 0, 0, 0, 1622, 1621, 1, 0, 0, 0, 1623, 225, 1, 0, 0, 0, 1624, 1626, 3, 350, 175, 0, 1625, 1624, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1629, 3, 256, 128, 0, 1628, 1627, 1, 0, 0, 0, 1628, 1629, 1, 0, 0, 0, 1629, 1635, 1, 0, 0, 0, 1630, 1636, 3, 398, 199, 0, 1631, 1636, 3, 400, 200, 0, 1632, 1636, 3, 402, 201, 0, 1633, 1636, 3, 404, 202, 0, 1634, 1636, 3, 406, 203, 0, 1635, 1630, 1, 0, 0, 0, 1635, 1631, 1, 0, 0, 0, 1635, 1632, 1, 0, 0, 0, 1635, 1633, 1, 0, 0, 0, 1635, 1634, 1, 0, 0, 0, 1636, 227, 1, 0, 0, 0, 1637, 1638, 3, 434, 217, 0, 1638, 1639, 5, 149, 0, 0, 1639, 1641, 3, 434, 217, 0, 1640, 1642, 3, 22, 11, 0, 1641, 1640, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 229, 1, 0, 0, 0, 1643, 1644, 5, 146, 0, 0, 1644, 1649, 3, 232, 116, 0, 1645, 1646, 5, 132, 0, 0, 1646, 1648, 3, 232, 116, 0, 1647, 1645, 1, 0, 0, 0, 1648, 1651, 1, 0, 0, 0, 1649, 1647, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1652, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1652, 1653, 5, 147, 0, 0, 1653, 231, 1, 0, 0, 0, 1654, 1656, 3, 350, 175, 0, 1655, 1654, 1, 0, 0, 0, 1655, 1656, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, 1657, 1658, 3, 434, 217, 0, 1658, 233, 1, 0, 0, 0, 1659, 1660, 5, 133, 0, 0, 1660, 1665, 3, 20, 10, 0, 1661, 1662, 5, 132, 0, 0, 1662, 1664, 3, 2, 1, 0, 1663, 1661, 1, 0, 0, 0, 1664, 1667, 1, 0, 0, 0, 1665, 1663, 1, 0, 0, 0, 1665, 1666, 1, 0, 0, 0, 1666, 235, 1, 0, 0, 0, 1667, 1665, 1, 0, 0, 0, 1668, 1673, 3, 2, 1, 0, 1669, 1670, 5, 132, 0, 0, 1670, 1672, 3, 2, 1, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1675, 1, 0, 0, 0, 1673, 1671, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 237, 1, 0, 0, 0, 1675, 1673, 1, 0, 0, 0, 1676, 1678, 3, 240, 120, 0, 1677, 1676, 1, 0, 0, 0, 1678, 1679, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 239, 1, 0, 0, 0, 1681, 1682, 5, 111, 0, 0, 1682, 1683, 3, 434, 217, 0, 1683, 1684, 5, 133, 0, 0, 1684, 1685, 3, 242, 121, 0, 1685, 241, 1, 0, 0, 0, 1686, 1697, 3, 248, 124, 0, 1687, 1690, 3, 244, 122, 0, 1688, 1689, 5, 132, 0, 0, 1689, 1691, 3, 246, 123, 0, 1690, 1688, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 1694, 1, 0, 0, 0, 1692, 1693, 5, 132, 0, 0, 1693, 1695, 3, 248, 124, 0, 1694, 1692, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1695, 1697, 1, 0, 0, 0, 1696, 1686, 1, 0, 0, 0, 1696, 1687, 1, 0, 0, 0, 1697, 243, 1, 0, 0, 0, 1698, 1706, 3, 20, 10, 0, 1699, 1701, 5, 26, 0, 0, 1700, 1702, 5, 148, 0, 0, 1701, 1700, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0, 1702, 1706, 1, 0, 0, 0, 1703, 1706, 5, 92, 0, 0, 1704, 1706, 5, 102, 0, 0, 1705, 1698, 1, 0, 0, 0, 1705, 1699, 1, 0, 0, 0, 1705, 1703, 1, 0, 0, 0, 1705, 1704, 1, 0, 0, 0, 1706, 245, 1, 0, 0, 0, 1707, 1712, 3, 2, 1, 0, 1708, 1709, 5, 132, 0, 0, 1709, 1711, 3, 2, 1, 0, 1710, 1708, 1, 0, 0, 0, 1711, 1714, 1, 0, 0, 0, 1712, 1710, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 247, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1715, 1716, 5, 66, 0, 0, 1716, 1717, 5, 129, 0, 0, 1717, 1718, 5, 130, 0, 0, 1718, 249, 1, 0, 0, 0, 1719, 1721, 5, 125, 0, 0, 1720, 1722, 3, 252, 126, 0, 1721, 1720, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1724, 5, 126, 0, 0, 1724, 251, 1, 0, 0, 0, 1725, 1727, 3, 254, 127, 0, 1726, 1725, 1, 0, 0, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1726, 1, 0, 0, 0, 1728, 1729, 1, 0, 0, 0, 1729, 253, 1, 0, 0, 0, 1730, 1732, 3, 350, 175, 0, 1731, 1730, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1734, 1, 0, 0, 0, 1733, 1735, 3, 256, 128, 0, 1734, 1733, 1, 0, 0, 0, 1734, 1735, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1739, 3, 260, 130, 0, 1737, 1739, 3, 418, 209, 0, 1738, 1736, 1, 0, 0, 0, 1738, 1737, 1, 0, 0, 0, 1739, 255, 1, 0, 0, 0, 1740, 1742, 3, 258, 129, 0, 1741, 1740, 1, 0, 0, 0, 1742, 1743, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 257, 1, 0, 0, 0, 1745, 1746, 7, 10, 0, 0, 1746, 259, 1, 0, 0, 0, 1747, 1767, 3, 414, 207, 0, 1748, 1767, 3, 262, 131, 0, 1749, 1767, 3, 408, 204, 0, 1750, 1756, 3, 308, 154, 0, 1751, 1757, 3, 312, 156, 0, 1752, 1753, 3, 374, 187, 0, 1753, 1754, 3, 74, 37, 0, 1754, 1755, 5, 134, 0, 0, 1755, 1757, 1, 0, 0, 0, 1756, 1751, 1, 0, 0, 0, 1756, 1752, 1, 0, 0, 0, 1757, 1767, 1, 0, 0, 0, 1758, 1767, 3, 420, 210, 0, 1759, 1760, 5, 108, 0, 0, 1760, 1767, 3, 422, 211, 0, 1761, 1767, 3, 398, 199, 0, 1762, 1767, 3, 400, 200, 0, 1763, 1767, 3, 402, 201, 0, 1764, 1767, 3, 404, 202, 0, 1765, 1767, 3, 406, 203, 0, 1766, 1747, 1, 0, 0, 0, 1766, 1748, 1, 0, 0, 0, 1766, 1749, 1, 0, 0, 0, 1766, 1750, 1, 0, 0, 0, 1766, 1758, 1, 0, 0, 0, 1766, 1759, 1, 0, 0, 0, 1766, 1761, 1, 0, 0, 0, 1766, 1762, 1, 0, 0, 0, 1766, 1763, 1, 0, 0, 0, 1766, 1764, 1, 0, 0, 0, 1766, 1765, 1, 0, 0, 0, 1767, 261, 1, 0, 0, 0, 1768, 1774, 5, 80, 0, 0, 1769, 1770, 5, 79, 0, 0, 1770, 1774, 5, 80, 0, 0, 1771, 1772, 5, 80, 0, 0, 1772, 1774, 5, 79, 0, 0, 1773, 1768, 1, 0, 0, 0, 1773, 1769, 1, 0, 0, 0, 1773, 1771, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1785, 3, 4, 2, 0, 1776, 1777, 3, 2, 1, 0, 1777, 1778, 5, 131, 0, 0, 1778, 1779, 3, 416, 208, 0, 1779, 1786, 1, 0, 0, 0, 1780, 1786, 3, 422, 211, 0, 1781, 1786, 3, 412, 206, 0, 1782, 1786, 3, 416, 208, 0, 1783, 1786, 3, 426, 213, 0, 1784, 1786, 3, 410, 205, 0, 1785, 1776, 1, 0, 0, 0, 1785, 1780, 1, 0, 0, 0, 1785, 1781, 1, 0, 0, 0, 1785, 1782, 1, 0, 0, 0, 1785, 1783, 1, 0, 0, 0, 1785, 1784, 1, 0, 0, 0, 1786, 263, 1, 0, 0, 0, 1787, 1792, 3, 266, 133, 0, 1788, 1789, 5, 132, 0, 0, 1789, 1791, 3, 266, 133, 0, 1790, 1788, 1, 0, 0, 0, 1791, 1794, 1, 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1792, 1793, 1, 0, 0, 0, 1793, 265, 1, 0, 0, 0, 1794, 1792, 1, 0, 0, 0, 1795, 1796, 3, 434, 217, 0, 1796, 1797, 5, 145, 0, 0, 1797, 1798, 3, 28, 14, 0, 1798, 267, 1, 0, 0, 0, 1799, 1804, 3, 270, 135, 0, 1800, 1801, 5, 132, 0, 0, 1801, 1803, 3, 270, 135, 0, 1802, 1800, 1, 0, 0, 0, 1803, 1806, 1, 0, 0, 0, 1804, 1802, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805, 269, 1, 0, 0, 0, 1806, 1804, 1, 0, 0, 0, 1807, 1810, 3, 434, 217, 0, 1808, 1809, 5, 145, 0, 0, 1809, 1811, 3, 272, 136, 0, 1810, 1808, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, 271, 1, 0, 0, 0, 1812, 1815, 3, 28, 14, 0, 1813, 1815, 3, 324, 162, 0, 1814, 1812, 1, 0, 0, 0, 1814, 1813, 1, 0, 0, 0, 1815, 273, 1, 0, 0, 0, 1816, 1819, 3, 4, 2, 0, 1817, 1819, 5, 108, 0, 0, 1818, 1816, 1, 0, 0, 0, 1818, 1817, 1, 0, 0, 0, 1819, 275, 1, 0, 0, 0, 1820, 1821, 3, 2, 1, 0, 1821, 277, 1, 0, 0, 0, 1822, 1825, 3, 170, 85, 0, 1823, 1825, 5, 134, 0, 0, 1824, 1822, 1, 0, 0, 0, 1824, 1823, 1, 0, 0, 0, 1825, 279, 1, 0, 0, 0, 1826, 1833, 3, 288, 144, 0, 1827, 1830, 3, 282, 141, 0, 1828, 1829, 5, 132, 0, 0, 1829, 1831, 3, 288, 144, 0, 1830, 1828, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1826, 1, 0, 0, 0, 1832, 1827, 1, 0, 0, 0, 1833, 281, 1, 0, 0, 0, 1834, 1839, 3, 284, 142, 0, 1835, 1836, 5, 132, 0, 0, 1836, 1838, 3, 284, 142, 0, 1837, 1835, 1, 0, 0, 0, 1838, 1841, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 283, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1842, 1844, 3, 350, 175, 0, 1843, 1842, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1846, 1, 0, 0, 0, 1845, 1847, 3, 286, 143, 0, 1846, 1845, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1848, 1, 0, 0, 0, 1848, 1851, 3, 428, 214, 0, 1849, 1851, 5, 12, 0, 0, 1850, 1843, 1, 0, 0, 0, 1850, 1849, 1, 0, 0, 0, 1851, 285, 1, 0, 0, 0, 1852, 1861, 5, 80, 0, 0, 1853, 1861, 5, 72, 0, 0, 1854, 1861, 5, 54, 0, 0, 1855, 1856, 5, 80, 0, 0, 1856, 1861, 5, 94, 0, 0, 1857, 1858, 5, 54, 0, 0, 1858, 1861, 5, 94, 0, 0, 1859, 1861, 5, 94, 0, 0, 1860, 1852, 1, 0, 0, 0, 1860, 1853, 1, 0, 0, 0, 1860, 1854, 1, 0, 0, 0, 1860, 1855, 1, 0, 0, 0, 1860, 1857, 1, 0, 0, 0, 1860, 1859, 1, 0, 0, 0, 1861, 287, 1, 0, 0, 0, 1862, 1864, 3, 350, 175, 0, 1863, 1862, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1866, 5, 74, 0, 0, 1866, 1867, 3, 320, 160, 0, 1867, 1868, 3, 434, 217, 0, 1868, 289, 1, 0, 0, 0, 1869, 1871, 3, 350, 175, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1873, 1, 0, 0, 0, 1872, 1874, 3, 296, 148, 0, 1873, 1872, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1885, 1, 0, 0, 0, 1875, 1876, 5, 49, 0, 0, 1876, 1878, 3, 298, 149, 0, 1877, 1879, 3, 294, 147, 0, 1878, 1877, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 1886, 1, 0, 0, 0, 1880, 1881, 5, 86, 0, 0, 1881, 1883, 3, 298, 149, 0, 1882, 1884, 3, 292, 146, 0, 1883, 1882, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1886, 1, 0, 0, 0, 1885, 1875, 1, 0, 0, 0, 1885, 1880, 1, 0, 0, 0, 1886, 291, 1, 0, 0, 0, 1887, 1889, 3, 350, 175, 0, 1888, 1887, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 1891, 1, 0, 0, 0, 1890, 1892, 3, 296, 148, 0, 1891, 1890, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1894, 5, 49, 0, 0, 1894, 1895, 3, 298, 149, 0, 1895, 293, 1, 0, 0, 0, 1896, 1898, 3, 350, 175, 0, 1897, 1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1900, 1, 0, 0, 0, 1899, 1901, 3, 296, 148, 0, 1900, 1899, 1, 0, 0, 0, 1900, 1901, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1903, 5, 86, 0, 0, 1903, 1904, 3, 298, 149, 0, 1904, 295, 1, 0, 0, 0, 1905, 1913, 5, 77, 0, 0, 1906, 1913, 5, 57, 0, 0, 1907, 1913, 5, 76, 0, 0, 1908, 1909, 5, 77, 0, 0, 1909, 1913, 5, 57, 0, 0, 1910, 1911, 5, 57, 0, 0, 1911, 1913, 5, 77, 0, 0, 1912, 1905, 1, 0, 0, 0, 1912, 1906, 1, 0, 0, 0, 1912, 1907, 1, 0, 0, 0, 1912, 1908, 1, 0, 0, 0, 1912, 1910, 1, 0, 0, 0, 1913, 297, 1, 0, 0, 0, 1914, 1917, 3, 170, 85, 0, 1915, 1917, 5, 134, 0, 0, 1916, 1914, 1, 0, 0, 0, 1916, 1915, 1, 0, 0, 0, 1917, 299, 1, 0, 0, 0, 1918, 1920, 3, 350, 175, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1929, 1, 0, 0, 0, 1921, 1922, 5, 10, 0, 0, 1922, 1923, 3, 170, 85, 0, 1923, 1924, 3, 304, 152, 0, 1924, 1930, 1, 0, 0, 0, 1925, 1926, 5, 81, 0, 0, 1926, 1927, 3, 170, 85, 0, 1927, 1928, 3, 302, 151, 0, 1928, 1930, 1, 0, 0, 0, 1929, 1921, 1, 0, 0, 0, 1929, 1925, 1, 0, 0, 0, 1930, 301, 1, 0, 0, 0, 1931, 1933, 3, 350, 175, 0, 1932, 1931, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1935, 5, 10, 0, 0, 1935, 1936, 3, 170, 85, 0, 1936, 303, 1, 0, 0, 0, 1937, 1939, 3, 350, 175, 0, 1938, 1937, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 5, 81, 0, 0, 1941, 1942, 3, 170, 85, 0, 1942, 305, 1, 0, 0, 0, 1943, 1966, 5, 135, 0, 0, 1944, 1966, 5, 136, 0, 0, 1945, 1966, 5, 143, 0, 0, 1946, 1966, 5, 144, 0, 0, 1947, 1966, 5, 151, 0, 0, 1948, 1966, 5, 152, 0, 0, 1949, 1966, 5, 96, 0, 0, 1950, 1966, 5, 42, 0, 0, 1951, 1966, 5, 137, 0, 0, 1952, 1966, 5, 138, 0, 0, 1953, 1966, 5, 139, 0, 0, 1954, 1966, 5, 140, 0, 0, 1955, 1966, 5, 141, 0, 0, 1956, 1966, 5, 142, 0, 0, 1957, 1966, 5, 168, 0, 0, 1958, 1966, 3, 376, 188, 0, 1959, 1966, 5, 156, 0, 0, 1960, 1966, 5, 157, 0, 0, 1961, 1966, 5, 147, 0, 0, 1962, 1966, 5, 146, 0, 0, 1963, 1966, 5, 159, 0, 0, 1964, 1966, 5, 158, 0, 0, 1965, 1943, 1, 0, 0, 0, 1965, 1944, 1, 0, 0, 0, 1965, 1945, 1, 0, 0, 0, 1965, 1946, 1, 0, 0, 0, 1965, 1947, 1, 0, 0, 0, 1965, 1948, 1, 0, 0, 0, 1965, 1949, 1, 0, 0, 0, 1965, 1950, 1, 0, 0, 0, 1965, 1951, 1, 0, 0, 0, 1965, 1952, 1, 0, 0, 0, 1965, 1953, 1, 0, 0, 0, 1965, 1954, 1, 0, 0, 0, 1965, 1955, 1, 0, 0, 0, 1965, 1956, 1, 0, 0, 0, 1965, 1957, 1, 0, 0, 0, 1965, 1958, 1, 0, 0, 0, 1965, 1959, 1, 0, 0, 0, 1965, 1960, 1, 0, 0, 0, 1965, 1961, 1, 0, 0, 0, 1965, 1962, 1, 0, 0, 0, 1965, 1963, 1, 0, 0, 0, 1965, 1964, 1, 0, 0, 0, 1966, 307, 1, 0, 0, 0, 1967, 1968, 7, 11, 0, 0, 1968, 1969, 5, 70, 0, 0, 1969, 1970, 3, 4, 2, 0, 1970, 1971, 5, 129, 0, 0, 1971, 1972, 3, 428, 214, 0, 1972, 1973, 5, 130, 0, 0, 1973, 309, 1, 0, 0, 0, 1974, 1975, 5, 133, 0, 0, 1975, 1976, 7, 12, 0, 0, 1976, 1978, 5, 129, 0, 0, 1977, 1979, 3, 24, 12, 0, 1978, 1977, 1, 0, 0, 0, 1978, 1979, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1981, 5, 130, 0, 0, 1981, 311, 1, 0, 0, 0, 1982, 1985, 3, 170, 85, 0, 1983, 1985, 5, 134, 0, 0, 1984, 1982, 1, 0, 0, 0, 1984, 1983, 1, 0, 0, 0, 1985, 313, 1, 0, 0, 0, 1986, 1987, 5, 133, 0, 0, 1987, 1988, 3, 236, 118, 0, 1988, 315, 1, 0, 0, 0, 1989, 1993, 5, 125, 0, 0, 1990, 1992, 3, 318, 159, 0, 1991, 1990, 1, 0, 0, 0, 1992, 1995, 1, 0, 0, 0, 1993, 1991, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1996, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, 0, 1996, 1997, 5, 126, 0, 0, 1997, 317, 1, 0, 0, 0, 1998, 2000, 3, 350, 175, 0, 1999, 1998, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2002, 1, 0, 0, 0, 2001, 2003, 3, 256, 128, 0, 2002, 2001, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2014, 1, 0, 0, 0, 2004, 2015, 3, 260, 130, 0, 2005, 2006, 5, 44, 0, 0, 2006, 2008, 3, 4, 2, 0, 2007, 2009, 3, 370, 185, 0, 2008, 2007, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2013, 5, 134, 0, 0, 2013, 2015, 1, 0, 0, 0, 2014, 2004, 1, 0, 0, 0, 2014, 2005, 1, 0, 0, 0, 2015, 319, 1, 0, 0, 0, 2016, 2024, 3, 6, 3, 0, 2017, 2019, 7, 13, 0, 0, 2018, 2017, 1, 0, 0, 0, 2019, 2022, 1, 0, 0, 0, 2020, 2018, 1, 0, 0, 0, 2020, 2021, 1, 0, 0, 0, 2021, 2023, 1, 0, 0, 0, 2022, 2020, 1, 0, 0, 0, 2023, 2025, 3, 322, 161, 0, 2024, 2020, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 321, 1, 0, 0, 0, 2028, 2032, 5, 127, 0, 0, 2029, 2031, 5, 132, 0, 0, 2030, 2029, 1, 0, 0, 0, 2031, 2034, 1, 0, 0, 0, 2032, 2030, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2032, 1, 0, 0, 0, 2035, 2036, 5, 128, 0, 0, 2036, 323, 1, 0, 0, 0, 2037, 2049, 5, 125, 0, 0, 2038, 2043, 3, 272, 136, 0, 2039, 2040, 5, 132, 0, 0, 2040, 2042, 3, 272, 136, 0, 2041, 2039, 1, 0, 0, 0, 2042, 2045, 1, 0, 0, 0, 2043, 2041, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2047, 1, 0, 0, 0, 2045, 2043, 1, 0, 0, 0, 2046, 2048, 5, 132, 0, 0, 2047, 2046, 1, 0, 0, 0, 2047, 2048, 1, 0, 0, 0, 2048, 2050, 1, 0, 0, 0, 2049, 2038, 1, 0, 0, 0, 2049, 2050, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2052, 5, 126, 0, 0, 2052, 325, 1, 0, 0, 0, 2053, 2054, 5, 146, 0, 0, 2054, 2059, 3, 328, 164, 0, 2055, 2056, 5, 132, 0, 0, 2056, 2058, 3, 328, 164, 0, 2057, 2055, 1, 0, 0, 0, 2058, 2061, 1, 0, 0, 0, 2059, 2057, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2062, 1, 0, 0, 0, 2061, 2059, 1, 0, 0, 0, 2062, 2063, 5, 147, 0, 0, 2063, 327, 1, 0, 0, 0, 2064, 2066, 3, 350, 175, 0, 2065, 2064, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2068, 1, 0, 0, 0, 2067, 2069, 3, 330, 165, 0, 2068, 2067, 1, 0, 0, 0, 2068, 2069, 1, 0, 0, 0, 2069, 2070, 1, 0, 0, 0, 2070, 2071, 3, 434, 217, 0, 2071, 329, 1, 0, 0, 0, 2072, 2073, 7, 14, 0, 0, 2073, 331, 1, 0, 0, 0, 2074, 2075, 5, 133, 0, 0, 2075, 2076, 3, 236, 118, 0, 2076, 333, 1, 0, 0, 0, 2077, 2081, 5, 125, 0, 0, 2078, 2080, 3, 336, 168, 0, 2079, 2078, 1, 0, 0, 0, 2080, 2083, 1, 0, 0, 0, 2081, 2079, 1, 0, 0, 0, 2081, 2082, 1, 0, 0, 0, 2082, 2084, 1, 0, 0, 0, 2083, 2081, 1, 0, 0, 0, 2084, 2085, 5, 126, 0, 0, 2085, 335, 1, 0, 0, 0, 2086, 2088, 3, 350, 175, 0, 2087, 2086, 1, 0, 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2090, 1, 0, 0, 0, 2089, 2091, 5, 66, 0, 0, 2090, 2089, 1, 0, 0, 0, 2090, 2091, 1, 0, 0, 0, 2091, 2155, 1, 0, 0, 0, 2092, 2094, 5, 103, 0, 0, 2093, 2092, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 2100, 1, 0, 0, 0, 2095, 2101, 5, 80, 0, 0, 2096, 2097, 5, 80, 0, 0, 2097, 2101, 5, 79, 0, 0, 2098, 2099, 5, 79, 0, 0, 2099, 2101, 5, 80, 0, 0, 2100, 2095, 1, 0, 0, 0, 2100, 2096, 1, 0, 0, 0, 2100, 2098, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2130, 3, 4, 2, 0, 2103, 2105, 3, 434, 217, 0, 2104, 2106, 3, 230, 115, 0, 2105, 2104, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 5, 129, 0, 0, 2108, 2110, 3, 280, 140, 0, 2109, 2108, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2113, 5, 130, 0, 0, 2112, 2114, 3, 238, 119, 0, 2113, 2112, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2116, 5, 134, 0, 0, 2116, 2131, 1, 0, 0, 0, 2117, 2118, 3, 434, 217, 0, 2118, 2119, 5, 125, 0, 0, 2119, 2120, 3, 338, 169, 0, 2120, 2121, 5, 126, 0, 0, 2121, 2131, 1, 0, 0, 0, 2122, 2123, 5, 94, 0, 0, 2123, 2124, 5, 127, 0, 0, 2124, 2125, 3, 280, 140, 0, 2125, 2126, 5, 128, 0, 0, 2126, 2127, 5, 125, 0, 0, 2127, 2128, 3, 338, 169, 0, 2128, 2129, 5, 126, 0, 0, 2129, 2131, 1, 0, 0, 0, 2130, 2103, 1, 0, 0, 0, 2130, 2117, 1, 0, 0, 0, 2130, 2122, 1, 0, 0, 0, 2131, 2156, 1, 0, 0, 0, 2132, 2134, 5, 103, 0, 0, 2133, 2132, 1, 0, 0, 0, 2133, 2134, 1, 0, 0, 0, 2134, 2135, 1, 0, 0, 0, 2135, 2136, 5, 108, 0, 0, 2136, 2138, 3, 434, 217, 0, 2137, 2139, 3, 230, 115, 0, 2138, 2137, 1, 0, 0, 0, 2138, 2139, 1, 0, 0, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2142, 5, 129, 0, 0, 2141, 2143, 3, 280, 140, 0, 2142, 2141, 1, 0, 0, 0, 2142, 2143, 1, 0, 0, 0, 2143, 2144, 1, 0, 0, 0, 2144, 2146, 5, 130, 0, 0, 2145, 2147, 3, 238, 119, 0, 2146, 2145, 1, 0, 0, 0, 2146, 2147, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2149, 5, 134, 0, 0, 2149, 2156, 1, 0, 0, 0, 2150, 2151, 5, 39, 0, 0, 2151, 2152, 3, 4, 2, 0, 2152, 2153, 3, 434, 217, 0, 2153, 2154, 5, 134, 0, 0, 2154, 2156, 1, 0, 0, 0, 2155, 2093, 1, 0, 0, 0, 2155, 2133, 1, 0, 0, 0, 2155, 2150, 1, 0, 0, 0, 2156, 337, 1, 0, 0, 0, 2157, 2159, 3, 350, 175, 0, 2158, 2157, 1, 0, 0, 0, 2158, 2159, 1, 0, 0, 0, 2159, 2178, 1, 0, 0, 0, 2160, 2161, 5, 49, 0, 0, 2161, 2167, 5, 134, 0, 0, 2162, 2164, 3, 350, 175, 0, 2163, 2162, 1, 0, 0, 0, 2163, 2164, 1, 0, 0, 0, 2164, 2165, 1, 0, 0, 0, 2165, 2166, 5, 86, 0, 0, 2166, 2168, 5, 134, 0, 0, 2167, 2163, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2179, 1, 0, 0, 0, 2169, 2170, 5, 86, 0, 0, 2170, 2176, 5, 134, 0, 0, 2171, 2173, 3, 350, 175, 0, 2172, 2171, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, 2174, 1, 0, 0, 0, 2174, 2175, 5, 49, 0, 0, 2175, 2177, 5, 134, 0, 0, 2176, 2172, 1, 0, 0, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2179, 1, 0, 0, 0, 2178, 2160, 1, 0, 0, 0, 2178, 2169, 1, 0, 0, 0, 2179, 339, 1, 0, 0, 0, 2180, 2181, 5, 133, 0, 0, 2181, 2182, 3, 4, 2, 0, 2182, 341, 1, 0, 0, 0, 2183, 2195, 5, 125, 0, 0, 2184, 2189, 3, 344, 172, 0, 2185, 2186, 5, 132, 0, 0, 2186, 2188, 3, 344, 172, 0, 2187, 2185, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 2193, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2194, 5, 132, 0, 0, 2193, 2192, 1, 0, 0, 0, 2193, 2194, 1, 0, 0, 0, 2194, 2196, 1, 0, 0, 0, 2195, 2184, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2198, 5, 126, 0, 0, 2198, 343, 1, 0, 0, 0, 2199, 2201, 3, 350, 175, 0, 2200, 2199, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2205, 3, 434, 217, 0, 2203, 2204, 5, 145, 0, 0, 2204, 2206, 3, 28, 14, 0, 2205, 2203, 1, 0, 0, 0, 2205, 2206, 1, 0, 0, 0, 2206, 345, 1, 0, 0, 0, 2207, 2208, 5, 127, 0, 0, 2208, 2209, 3, 348, 174, 0, 2209, 2210, 5, 133, 0, 0, 2210, 2212, 3, 356, 178, 0, 2211, 2213, 5, 132, 0, 0, 2212, 2211, 1, 0, 0, 0, 2212, 2213, 1, 0, 0, 0, 2213, 2214, 1, 0, 0, 0, 2214, 2215, 5, 128, 0, 0, 2215, 347, 1, 0, 0, 0, 2216, 2219, 3, 396, 198, 0, 2217, 2219, 3, 434, 217, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2217, 1, 0, 0, 0, 2219, 349, 1, 0, 0, 0, 2220, 2222, 3, 352, 176, 0, 2221, 2220, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2221, 1, 0, 0, 0, 2223, 2224, 1, 0, 0, 0, 2224, 351, 1, 0, 0, 0, 2225, 2229, 5, 127, 0, 0, 2226, 2227, 3, 354, 177, 0, 2227, 2228, 5, 133, 0, 0, 2228, 2230, 1, 0, 0, 0, 2229, 2226, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2233, 3, 356, 178, 0, 2232, 2234, 5, 132, 0, 0, 2233, 2232, 1, 0, 0, 0, 2233, 2234, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2236, 5, 128, 0, 0, 2236, 353, 1, 0, 0, 0, 2237, 2240, 3, 396, 198, 0, 2238, 2240, 3, 434, 217, 0, 2239, 2237, 1, 0, 0, 0, 2239, 2238, 1, 0, 0, 0, 2240, 355, 1, 0, 0, 0, 2241, 2246, 3, 358, 179, 0, 2242, 2243, 5, 132, 0, 0, 2243, 2245, 3, 358, 179, 0, 2244, 2242, 1, 0, 0, 0, 2245, 2248, 1, 0, 0, 0, 2246, 2244, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 357, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2262, 3, 2, 1, 0, 2250, 2259, 5, 129, 0, 0, 2251, 2256, 3, 360, 180, 0, 2252, 2253, 5, 132, 0, 0, 2253, 2255, 3, 360, 180, 0, 2254, 2252, 1, 0, 0, 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2260, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2251, 1, 0, 0, 0, 2259, 2260, 1, 0, 0, 0, 2260, 2261, 1, 0, 0, 0, 2261, 2263, 5, 130, 0, 0, 2262, 2250, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 359, 1, 0, 0, 0, 2264, 2265, 3, 434, 217, 0, 2265, 2266, 5, 133, 0, 0, 2266, 2268, 1, 0, 0, 0, 2267, 2264, 1, 0, 0, 0, 2267, 2268, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2270, 3, 28, 14, 0, 2270, 361, 1, 0, 0, 0, 2271, 2274, 3, 12, 6, 0, 2272, 2274, 3, 20, 10, 0, 2273, 2271, 1, 0, 0, 0, 2273, 2272, 1, 0, 0, 0, 2274, 2279, 1, 0, 0, 0, 2275, 2278, 3, 322, 161, 0, 2276, 2278, 5, 148, 0, 0, 2277, 2275, 1, 0, 0, 0, 2277, 2276, 1, 0, 0, 0, 2278, 2281, 1, 0, 0, 0, 2279, 2277, 1, 0, 0, 0, 2279, 2280, 1, 0, 0, 0, 2280, 2282, 1, 0, 0, 0, 2281, 2279, 1, 0, 0, 0, 2282, 2283, 5, 137, 0, 0, 2283, 2287, 1, 0, 0, 0, 2284, 2285, 5, 108, 0, 0, 2285, 2287, 5, 137, 0, 0, 2286, 2273, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 363, 1, 0, 0, 0, 2288, 2293, 3, 366, 183, 0, 2289, 2290, 5, 132, 0, 0, 2290, 2292, 3, 366, 183, 0, 2291, 2289, 1, 0, 0, 0, 2292, 2295, 1, 0, 0, 0, 2293, 2291, 1, 0, 0, 0, 2293, 2294, 1, 0, 0, 0, 2294, 365, 1, 0, 0, 0, 2295, 2293, 1, 0, 0, 0, 2296, 2297, 3, 434, 217, 0, 2297, 2298, 5, 145, 0, 0, 2298, 2299, 3, 368, 184, 0, 2299, 367, 1, 0, 0, 0, 2300, 2302, 5, 140, 0, 0, 2301, 2300, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, 0, 2302, 2303, 1, 0, 0, 0, 2303, 2306, 3, 28, 14, 0, 2304, 2306, 3, 372, 186, 0, 2305, 2301, 1, 0, 0, 0, 2305, 2304, 1, 0, 0, 0, 2306, 369, 1, 0, 0, 0, 2307, 2308, 3, 434, 217, 0, 2308, 2309, 5, 127, 0, 0, 2309, 2310, 3, 28, 14, 0, 2310, 2311, 5, 128, 0, 0, 2311, 371, 1, 0, 0, 0, 2312, 2313, 5, 89, 0, 0, 2313, 2314, 3, 4, 2, 0, 2314, 2315, 5, 127, 0, 0, 2315, 2316, 3, 28, 14, 0, 2316, 2317, 5, 128, 0, 0, 2317, 2342, 1, 0, 0, 0, 2318, 2320, 5, 89, 0, 0, 2319, 2321, 3, 4, 2, 0, 2320, 2319, 1, 0, 0, 0, 2320, 2321, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2324, 5, 127, 0, 0, 2323, 2325, 3, 28, 14, 0, 2324, 2323, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2327, 5, 128, 0, 0, 2327, 2328, 5, 125, 0, 0, 2328, 2333, 3, 28, 14, 0, 2329, 2330, 5, 132, 0, 0, 2330, 2332, 3, 28, 14, 0, 2331, 2329, 1, 0, 0, 0, 2332, 2335, 1, 0, 0, 0, 2333, 2331, 1, 0, 0, 0, 2333, 2334, 1, 0, 0, 0, 2334, 2337, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2336, 2338, 5, 132, 0, 0, 2337, 2336, 1, 0, 0, 0, 2337, 2338, 1, 0, 0, 0, 2338, 2339, 1, 0, 0, 0, 2339, 2340, 5, 126, 0, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2312, 1, 0, 0, 0, 2341, 2318, 1, 0, 0, 0, 2342, 373, 1, 0, 0, 0, 2343, 2344, 5, 145, 0, 0, 2344, 2345, 5, 147, 0, 0, 2345, 2346, 4, 187, 0, 1, 2346, 375, 1, 0, 0, 0, 2347, 2348, 5, 147, 0, 0, 2348, 2349, 5, 147, 0, 0, 2349, 2350, 4, 188, 1, 1, 2350, 377, 1, 0, 0, 0, 2351, 2352, 5, 147, 0, 0, 2352, 2353, 5, 159, 0, 0, 2353, 2354, 4, 189, 2, 1, 2354, 379, 1, 0, 0, 0, 2355, 2364, 3, 382, 191, 0, 2356, 2364, 3, 384, 192, 0, 2357, 2364, 5, 116, 0, 0, 2358, 2364, 5, 117, 0, 0, 2359, 2364, 5, 118, 0, 0, 2360, 2364, 5, 119, 0, 0, 2361, 2364, 5, 120, 0, 0, 2362, 2364, 5, 67, 0, 0, 2363, 2355, 1, 0, 0, 0, 2363, 2356, 1, 0, 0, 0, 2363, 2357, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2363, 2360, 1, 0, 0, 0, 2363, 2361, 1, 0, 0, 0, 2363, 2362, 1, 0, 0, 0, 2364, 381, 1, 0, 0, 0, 2365, 2366, 7, 15, 0, 0, 2366, 383, 1, 0, 0, 0, 2367, 2372, 3, 386, 193, 0, 2368, 2372, 3, 388, 194, 0, 2369, 2372, 5, 121, 0, 0, 2370, 2372, 5, 122, 0, 0, 2371, 2367, 1, 0, 0, 0, 2371, 2368, 1, 0, 0, 0, 2371, 2369, 1, 0, 0, 0, 2371, 2370, 1, 0, 0, 0, 2372, 385, 1, 0, 0, 0, 2373, 2377, 5, 123, 0, 0, 2374, 2376, 3, 390, 195, 0, 2375, 2374, 1, 0, 0, 0, 2376, 2379, 1, 0, 0, 0, 2377, 2375, 1, 0, 0, 0, 2377, 2378, 1, 0, 0, 0, 2378, 2380, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2380, 2381, 5, 176, 0, 0, 2381, 387, 1, 0, 0, 0, 2382, 2386, 5, 124, 0, 0, 2383, 2385, 3, 392, 196, 0, 2384, 2383, 1, 0, 0, 0, 2385, 2388, 1, 0, 0, 0, 2386, 2384, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2389, 1, 0, 0, 0, 2388, 2386, 1, 0, 0, 0, 2389, 2390, 5, 176, 0, 0, 2390, 389, 1, 0, 0, 0, 2391, 2396, 3, 394, 197, 0, 2392, 2396, 5, 172, 0, 0, 2393, 2396, 5, 174, 0, 0, 2394, 2396, 5, 177, 0, 0, 2395, 2391, 1, 0, 0, 0, 2395, 2392, 1, 0, 0, 0, 2395, 2393, 1, 0, 0, 0, 2395, 2394, 1, 0, 0, 0, 2396, 391, 1, 0, 0, 0, 2397, 2402, 3, 394, 197, 0, 2398, 2402, 5, 172, 0, 0, 2399, 2402, 5, 175, 0, 0, 2400, 2402, 5, 178, 0, 0, 2401, 2397, 1, 0, 0, 0, 2401, 2398, 1, 0, 0, 0, 2401, 2399, 1, 0, 0, 0, 2401, 2400, 1, 0, 0, 0, 2402, 393, 1, 0, 0, 0, 2403, 2408, 3, 28, 14, 0, 2404, 2405, 5, 132, 0, 0, 2405, 2407, 3, 28, 14, 0, 2406, 2404, 1, 0, 0, 0, 2407, 2410, 1, 0, 0, 0, 2408, 2406, 1, 0, 0, 0, 2408, 2409, 1, 0, 0, 0, 2409, 2417, 1, 0, 0, 0, 2410, 2408, 1, 0, 0, 0, 2411, 2413, 5, 133, 0, 0, 2412, 2414, 5, 180, 0, 0, 2413, 2412, 1, 0, 0, 0, 2414, 2415, 1, 0, 0, 0, 2415, 2413, 1, 0, 0, 0, 2415, 2416, 1, 0, 0, 0, 2416, 2418, 1, 0, 0, 0, 2417, 2411, 1, 0, 0, 0, 2417, 2418, 1, 0, 0, 0, 2418, 395, 1, 0, 0, 0, 2419, 2420, 7, 16, 0, 0, 2420, 397, 1, 0, 0, 0, 2421, 2422, 5, 26, 0, 0, 2422, 2424, 3, 434, 217, 0, 2423, 2425, 3, 230, 115, 0, 2424, 2423, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2427, 1, 0, 0, 0, 2426, 2428, 3, 234, 117, 0, 2427, 2426, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2430, 1, 0, 0, 0, 2429, 2431, 3, 238, 119, 0, 2430, 2429, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2432, 1, 0, 0, 0, 2432, 2434, 3, 250, 125, 0, 2433, 2435, 5, 134, 0, 0, 2434, 2433, 1, 0, 0, 0, 2434, 2435, 1, 0, 0, 0, 2435, 399, 1, 0, 0, 0, 2436, 2438, 7, 17, 0, 0, 2437, 2436, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2439, 1, 0, 0, 0, 2439, 2440, 5, 92, 0, 0, 2440, 2442, 3, 434, 217, 0, 2441, 2443, 3, 230, 115, 0, 2442, 2441, 1, 0, 0, 0, 2442, 2443, 1, 0, 0, 0, 2443, 2445, 1, 0, 0, 0, 2444, 2446, 3, 314, 157, 0, 2445, 2444, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2448, 1, 0, 0, 0, 2447, 2449, 3, 238, 119, 0, 2448, 2447, 1, 0, 0, 0, 2448, 2449, 1, 0, 0, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2452, 3, 316, 158, 0, 2451, 2453, 5, 134, 0, 0, 2452, 2451, 1, 0, 0, 0, 2452, 2453, 1, 0, 0, 0, 2453, 401, 1, 0, 0, 0, 2454, 2455, 5, 56, 0, 0, 2455, 2457, 3, 434, 217, 0, 2456, 2458, 3, 326, 163, 0, 2457, 2456, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2460, 1, 0, 0, 0, 2459, 2461, 3, 332, 166, 0, 2460, 2459, 1, 0, 0, 0, 2460, 2461, 1, 0, 0, 0, 2461, 2463, 1, 0, 0, 0, 2462, 2464, 3, 238, 119, 0, 2463, 2462, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2467, 3, 250, 125, 0, 2466, 2468, 5, 134, 0, 0, 2467, 2466, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, 2468, 403, 1, 0, 0, 0, 2469, 2470, 5, 37, 0, 0, 2470, 2472, 3, 434, 217, 0, 2471, 2473, 3, 340, 170, 0, 2472, 2471, 1, 0, 0, 0, 2472, 2473, 1, 0, 0, 0, 2473, 2474, 1, 0, 0, 0, 2474, 2476, 3, 342, 171, 0, 2475, 2477, 5, 134, 0, 0, 2476, 2475, 1, 0, 0, 0, 2476, 2477, 1, 0, 0, 0, 2477, 405, 1, 0, 0, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2480, 3, 274, 137, 0, 2480, 2482, 3, 434, 217, 0, 2481, 2483, 3, 326, 163, 0, 2482, 2481, 1, 0, 0, 0, 2482, 2483, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2486, 5, 129, 0, 0, 2485, 2487, 3, 280, 140, 0, 2486, 2485, 1, 0, 0, 0, 2486, 2487, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 2490, 5, 130, 0, 0, 2489, 2491, 3, 238, 119, 0, 2490, 2489, 1, 0, 0, 0, 2490, 2491, 1, 0, 0, 0, 2491, 2492, 1, 0, 0, 0, 2492, 2493, 5, 134, 0, 0, 2493, 407, 1, 0, 0, 0, 2494, 2495, 5, 39, 0, 0, 2495, 2504, 3, 4, 2, 0, 2496, 2497, 3, 268, 134, 0, 2497, 2498, 5, 134, 0, 0, 2498, 2505, 1, 0, 0, 0, 2499, 2500, 3, 276, 138, 0, 2500, 2501, 5, 125, 0, 0, 2501, 2502, 3, 300, 150, 0, 2502, 2503, 5, 126, 0, 0, 2503, 2505, 1, 0, 0, 0, 2504, 2496, 1, 0, 0, 0, 2504, 2499, 1, 0, 0, 0, 2505, 409, 1, 0, 0, 0, 2506, 2507, 3, 268, 134, 0, 2507, 2508, 5, 134, 0, 0, 2508, 411, 1, 0, 0, 0, 2509, 2523, 3, 276, 138, 0, 2510, 2511, 5, 125, 0, 0, 2511, 2512, 3, 290, 145, 0, 2512, 2517, 5, 126, 0, 0, 2513, 2514, 5, 145, 0, 0, 2514, 2515, 3, 272, 136, 0, 2515, 2516, 5, 134, 0, 0, 2516, 2518, 1, 0, 0, 0, 2517, 2513, 1, 0, 0, 0, 2517, 2518, 1, 0, 0, 0, 2518, 2524, 1, 0, 0, 0, 2519, 2520, 3, 374, 187, 0, 2520, 2521, 3, 74, 37, 0, 2521, 2522, 5, 134, 0, 0, 2522, 2524, 1, 0, 0, 0, 2523, 2510, 1, 0, 0, 0, 2523, 2519, 1, 0, 0, 0, 2524, 413, 1, 0, 0, 0, 2525, 2526, 5, 27, 0, 0, 2526, 2527, 3, 4, 2, 0, 2527, 2528, 3, 264, 132, 0, 2528, 2529, 5, 134, 0, 0, 2529, 415, 1, 0, 0, 0, 2530, 2531, 5, 94, 0, 0, 2531, 2532, 5, 127, 0, 0, 2532, 2533, 3, 280, 140, 0, 2533, 2542, 5, 128, 0, 0, 2534, 2535, 5, 125, 0, 0, 2535, 2536, 3, 290, 145, 0, 2536, 2537, 5, 126, 0, 0, 2537, 2543, 1, 0, 0, 0, 2538, 2539, 3, 374, 187, 0, 2539, 2540, 3, 74, 37, 0, 2540, 2541, 5, 134, 0, 0, 2541, 2543, 1, 0, 0, 0, 2542, 2534, 1, 0, 0, 0, 2542, 2538, 1, 0, 0, 0, 2543, 417, 1, 0, 0, 0, 2544, 2545, 5, 144, 0, 0, 2545, 2546, 3, 434, 217, 0, 2546, 2547, 5, 129, 0, 0, 2547, 2548, 5, 130, 0, 0, 2548, 2549, 3, 312, 156, 0, 2549, 419, 1, 0, 0, 0, 2550, 2551, 3, 434, 217, 0, 2551, 2553, 5, 129, 0, 0, 2552, 2554, 3, 280, 140, 0, 2553, 2552, 1, 0, 0, 0, 2553, 2554, 1, 0, 0, 0, 2554, 2555, 1, 0, 0, 0, 2555, 2557, 5, 130, 0, 0, 2556, 2558, 3, 310, 155, 0, 2557, 2556, 1, 0, 0, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2559, 1, 0, 0, 0, 2559, 2560, 3, 312, 156, 0, 2560, 421, 1, 0, 0, 0, 2561, 2563, 3, 424, 212, 0, 2562, 2564, 3, 230, 115, 0, 2563, 2562, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2565, 1, 0, 0, 0, 2565, 2567, 5, 129, 0, 0, 2566, 2568, 3, 280, 140, 0, 2567, 2566, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 2571, 5, 130, 0, 0, 2570, 2572, 3, 238, 119, 0, 2571, 2570, 1, 0, 0, 0, 2571, 2572, 1, 0, 0, 0, 2572, 2578, 1, 0, 0, 0, 2573, 2579, 3, 278, 139, 0, 2574, 2575, 3, 374, 187, 0, 2575, 2576, 3, 74, 37, 0, 2576, 2577, 5, 134, 0, 0, 2577, 2579, 1, 0, 0, 0, 2578, 2573, 1, 0, 0, 0, 2578, 2574, 1, 0, 0, 0, 2579, 423, 1, 0, 0, 0, 2580, 2586, 3, 434, 217, 0, 2581, 2582, 3, 434, 217, 0, 2582, 2583, 5, 149, 0, 0, 2583, 2584, 3, 434, 217, 0, 2584, 2586, 1, 0, 0, 0, 2585, 2580, 1, 0, 0, 0, 2585, 2581, 1, 0, 0, 0, 2586, 2594, 1, 0, 0, 0, 2587, 2589, 3, 22, 11, 0, 2588, 2587, 1, 0, 0, 0, 2588, 2589, 1, 0, 0, 0, 2589, 2590, 1, 0, 0, 0, 2590, 2591, 5, 131, 0, 0, 2591, 2593, 3, 434, 217, 0, 2592, 2588, 1, 0, 0, 0, 2593, 2596, 1, 0, 0, 0, 2594, 2592, 1, 0, 0, 0, 2594, 2595, 1, 0, 0, 0, 2595, 425, 1, 0, 0, 0, 2596, 2594, 1, 0, 0, 0, 2597, 2598, 5, 70, 0, 0, 2598, 2599, 3, 306, 153, 0, 2599, 2601, 5, 129, 0, 0, 2600, 2602, 5, 54, 0, 0, 2601, 2600, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2609, 3, 428, 214, 0, 2604, 2606, 5, 132, 0, 0, 2605, 2607, 5, 54, 0, 0, 2606, 2605, 1, 0, 0, 0, 2606, 2607, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2610, 3, 428, 214, 0, 2609, 2604, 1, 0, 0, 0, 2609, 2610, 1, 0, 0, 0, 2610, 2611, 1, 0, 0, 0, 2611, 2617, 5, 130, 0, 0, 2612, 2618, 3, 312, 156, 0, 2613, 2614, 3, 374, 187, 0, 2614, 2615, 3, 74, 37, 0, 2615, 2616, 5, 134, 0, 0, 2616, 2618, 1, 0, 0, 0, 2617, 2612, 1, 0, 0, 0, 2617, 2613, 1, 0, 0, 0, 2618, 427, 1, 0, 0, 0, 2619, 2620, 3, 4, 2, 0, 2620, 2623, 3, 434, 217, 0, 2621, 2622, 5, 145, 0, 0, 2622, 2624, 3, 28, 14, 0, 2623, 2621, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 429, 1, 0, 0, 0, 2625, 2627, 5, 129, 0, 0, 2626, 2628, 3, 24, 12, 0, 2627, 2626, 1, 0, 0, 0, 2627, 2628, 1, 0, 0, 0, 2628, 2629, 1, 0, 0, 0, 2629, 2630, 5, 130, 0, 0, 2630, 431, 1, 0, 0, 0, 2631, 2633, 5, 129, 0, 0, 2632, 2634, 3, 24, 12, 0, 2633, 2632, 1, 0, 0, 0, 2633, 2634, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, 2637, 5, 130, 0, 0, 2636, 2638, 3, 88, 44, 0, 2637, 2636, 1, 0, 0, 0, 2637, 2638, 1, 0, 0, 0, 2638, 433, 1, 0, 0, 0, 2639, 2640, 7, 18, 0, 0, 2640, 435, 1, 0, 0, 0, 344, 437, 440, 443, 448, 452, 458, 461, 466, 470, 477, 479, 487, 495, 501, 505, 510, 520, 528, 538, 544, 547, 551, 559, 564, 574, 587, 595, 601, 603, 610, 618, 626, 634, 642, 650, 660, 662, 668, 673, 681, 689, 697, 699, 702, 709, 714, 721, 725, 727, 755, 759, 764, 768, 776, 779, 784, 788, 792, 798, 812, 818, 830, 834, 839, 843, 849, 857, 866, 884, 887, 892, 895, 910, 916, 920, 926, 931, 934, 942, 950, 961, 966, 971, 973, 982, 990, 997, 1005, 1009, 1018, 1023, 1025, 1034, 1042, 1046, 1051, 1053, 1058, 1062, 1069, 1077, 1079, 1083, 1086, 1089, 1097, 1107, 1124, 1131, 1135, 1145, 1150, 1157, 1166, 1171, 1178, 1190, 1201, 1209, 1214, 1223, 1232, 1241, 1247, 1252, 1256, 1260, 1264, 1268, 1275, 1283, 1296, 1306, 1328, 1332, 1336, 1341, 1361, 1366, 1371, 1378, 1381, 1403, 1415, 1419, 1427, 1435, 1442, 1446, 1451, 1454, 1459, 1467, 1472, 1479, 1485, 1493, 1501, 1504, 1511, 1518, 1522, 1525, 1531, 1535, 1541, 1555, 1561, 1568, 1573, 1576, 1579, 1586, 1596, 1613, 1618, 1622, 1625, 1628, 1635, 1641, 1649, 1655, 1665, 1673, 1679, 1690, 1694, 1696, 1701, 1705, 1712, 1721, 1728, 1731, 1734, 1738, 1743, 1756, 1766, 1773, 1785, 1792, 1804, 1810, 1814, 1818, 1824, 1830, 1832, 1839, 1843, 1846, 1850, 1860, 1863, 1870, 1873, 1878, 1883, 1885, 1888, 1891, 1897, 1900, 1912, 1916, 1919, 1929, 1932, 1938, 1965, 1978, 1984, 1993, 1999, 2002, 2010, 2014, 2020, 2026, 2032, 2043, 2047, 2049, 2059, 2065, 2068, 2081, 2087, 2090, 2093, 2100, 2105, 2109, 2113, 2130, 2133, 2138, 2142, 2146, 2155, 2158, 2163, 2167, 2172, 2176, 2178, 2189, 2193, 2195, 2200, 2205, 2212, 2218, 2223, 2229, 2233, 2239, 2246, 2256, 2259, 2262, 2267, 2273, 2277, 2279, 2286, 2293, 2301, 2305, 2320, 2324, 2333, 2337, 2341, 2363, 2371, 2377, 2386, 2395, 2401, 2408, 2415, 2417, 2424, 2427, 2430, 2434, 2437, 2442, 2445, 2448, 2452, 2457, 2460, 2463, 2467, 2472, 2476, 2482, 2486, 2490, 2504, 2517, 2523, 2542, 2553, 2557, 2563, 2567, 2571, 2578, 2585, 2588, 2594, 2601, 2606, 2609, 2617, 2623, 2627, 2633, 2637] \ No newline at end of file diff --git a/src/main/java/CSharpParser.java b/src/main/java/CSharpParser.java new file mode 100644 index 0000000..ffdce6e --- /dev/null +++ b/src/main/java/CSharpParser.java @@ -0,0 +1,25249 @@ +// Generated from CSharpParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.FailedPredicateException; +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.Utils; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.TerminalNode; + +import java.util.List; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class CSharpParser extends Parser { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + BYTE_ORDER_MARK = 1, SINGLE_LINE_DOC_COMMENT = 2, EMPTY_DELIMITED_DOC_COMMENT = 3, + DELIMITED_DOC_COMMENT = 4, SINGLE_LINE_COMMENT = 5, DELIMITED_COMMENT = 6, WHITESPACES = 7, + SHARP = 8, ABSTRACT = 9, ADD = 10, ALIAS = 11, ARGLIST = 12, AS = 13, ASCENDING = 14, + ASYNC = 15, AWAIT = 16, BASE = 17, BOOL = 18, BREAK = 19, BY = 20, BYTE = 21, CASE = 22, + CATCH = 23, CHAR = 24, CHECKED = 25, CLASS = 26, CONST = 27, CONTINUE = 28, DECIMAL = 29, + DEFAULT = 30, DELEGATE = 31, DESCENDING = 32, DO = 33, DOUBLE = 34, DYNAMIC = 35, + ELSE = 36, ENUM = 37, EQUALS = 38, EVENT = 39, EXPLICIT = 40, EXTERN = 41, FALSE = 42, + FINALLY = 43, FIXED = 44, FLOAT = 45, FOR = 46, FOREACH = 47, FROM = 48, GET = 49, GOTO = 50, + GROUP = 51, IF = 52, IMPLICIT = 53, IN = 54, INT = 55, INTERFACE = 56, INTERNAL = 57, + INTO = 58, IS = 59, JOIN = 60, LET = 61, LOCK = 62, LONG = 63, NAMEOF = 64, NAMESPACE = 65, + NEW = 66, NULL = 67, OBJECT = 68, ON = 69, OPERATOR = 70, ORDERBY = 71, OUT = 72, OVERRIDE = 73, + PARAMS = 74, PARTIAL = 75, PRIVATE = 76, PROTECTED = 77, PUBLIC = 78, READONLY = 79, + REF = 80, REMOVE = 81, RETURN = 82, SBYTE = 83, SEALED = 84, SELECT = 85, SET = 86, + SHORT = 87, SIZEOF = 88, STACKALLOC = 89, STATIC = 90, STRING = 91, STRUCT = 92, SWITCH = 93, + THIS = 94, THROW = 95, TRUE = 96, TRY = 97, TYPEOF = 98, UINT = 99, ULONG = 100, UNCHECKED = 101, + UNMANAGED = 102, UNSAFE = 103, USHORT = 104, USING = 105, VAR = 106, VIRTUAL = 107, + VOID = 108, VOLATILE = 109, WHEN = 110, WHERE = 111, WHILE = 112, YIELD = 113, IDENTIFIER = 114, + LITERAL_ACCESS = 115, INTEGER_LITERAL = 116, HEX_INTEGER_LITERAL = 117, BIN_INTEGER_LITERAL = 118, + REAL_LITERAL = 119, CHARACTER_LITERAL = 120, REGULAR_STRING = 121, VERBATIUM_STRING = 122, + INTERPOLATED_REGULAR_STRING_START = 123, INTERPOLATED_VERBATIUM_STRING_START = 124, + OPEN_BRACE = 125, CLOSE_BRACE = 126, OPEN_BRACKET = 127, CLOSE_BRACKET = 128, + OPEN_PARENS = 129, CLOSE_PARENS = 130, DOT = 131, COMMA = 132, COLON = 133, SEMICOLON = 134, + PLUS = 135, MINUS = 136, STAR = 137, DIV = 138, PERCENT = 139, AMP = 140, BITWISE_OR = 141, + CARET = 142, BANG = 143, TILDE = 144, ASSIGNMENT = 145, LT = 146, GT = 147, INTERR = 148, + DOUBLE_COLON = 149, OP_COALESCING = 150, OP_INC = 151, OP_DEC = 152, OP_AND = 153, + OP_OR = 154, OP_PTR = 155, OP_EQ = 156, OP_NE = 157, OP_LE = 158, OP_GE = 159, OP_ADD_ASSIGNMENT = 160, + OP_SUB_ASSIGNMENT = 161, OP_MULT_ASSIGNMENT = 162, OP_DIV_ASSIGNMENT = 163, + OP_MOD_ASSIGNMENT = 164, OP_AND_ASSIGNMENT = 165, OP_OR_ASSIGNMENT = 166, OP_XOR_ASSIGNMENT = 167, + OP_LEFT_SHIFT = 168, OP_LEFT_SHIFT_ASSIGNMENT = 169, OP_COALESCING_ASSIGNMENT = 170, + OP_RANGE = 171, DOUBLE_CURLY_INSIDE = 172, OPEN_BRACE_INSIDE = 173, REGULAR_CHAR_INSIDE = 174, + VERBATIUM_DOUBLE_QUOTE_INSIDE = 175, DOUBLE_QUOTE_INSIDE = 176, REGULAR_STRING_INSIDE = 177, + VERBATIUM_INSIDE_STRING = 178, CLOSE_BRACE_INSIDE = 179, FORMAT_STRING = 180, + DIRECTIVE_WHITESPACES = 181, DIGITS = 182, DEFINE = 183, UNDEF = 184, ELIF = 185, + ENDIF = 186, LINE = 187, ERROR = 188, WARNING = 189, REGION = 190, ENDREGION = 191, + PRAGMA = 192, NULLABLE = 193, DIRECTIVE_HIDDEN = 194, CONDITIONAL_SYMBOL = 195, + DIRECTIVE_NEW_LINE = 196, TEXT = 197, DOUBLE_CURLY_CLOSE_INSIDE = 198; + public static final int + RULE_compilation_unit = 0, RULE_namespace_or_type_name = 1, RULE_type_ = 2, + RULE_base_type = 3, RULE_tuple_type = 4, RULE_tuple_element = 5, RULE_simple_type = 6, + RULE_numeric_type = 7, RULE_integral_type = 8, RULE_floating_point_type = 9, + RULE_class_type = 10, RULE_type_argument_list = 11, RULE_argument_list = 12, + RULE_argument = 13, RULE_expression = 14, RULE_non_assignment_expression = 15, + RULE_assignment = 16, RULE_assignment_operator = 17, RULE_conditional_expression = 18, + RULE_null_coalescing_expression = 19, RULE_conditional_or_expression = 20, + RULE_conditional_and_expression = 21, RULE_inclusive_or_expression = 22, + RULE_exclusive_or_expression = 23, RULE_and_expression = 24, RULE_equality_expression = 25, + RULE_relational_expression = 26, RULE_shift_expression = 27, RULE_additive_expression = 28, + RULE_multiplicative_expression = 29, RULE_switch_expression = 30, RULE_switch_expression_arms = 31, + RULE_switch_expression_arm = 32, RULE_range_expression = 33, RULE_unary_expression = 34, + RULE_primary_expression = 35, RULE_primary_expression_start = 36, RULE_throwable_expression = 37, + RULE_throw_expression = 38, RULE_member_access = 39, RULE_bracket_expression = 40, + RULE_indexer_argument = 41, RULE_predefined_type = 42, RULE_expression_list = 43, + RULE_object_or_collection_initializer = 44, RULE_object_initializer = 45, + RULE_member_initializer_list = 46, RULE_member_initializer = 47, RULE_initializer_value = 48, + RULE_collection_initializer = 49, RULE_element_initializer = 50, RULE_anonymous_object_initializer = 51, + RULE_member_declarator_list = 52, RULE_member_declarator = 53, RULE_unbound_type_name = 54, + RULE_generic_dimension_specifier = 55, RULE_isType = 56, RULE_isTypePatternArms = 57, + RULE_isTypePatternArm = 58, RULE_lambda_expression = 59, RULE_anonymous_function_signature = 60, + RULE_explicit_anonymous_function_parameter_list = 61, RULE_explicit_anonymous_function_parameter = 62, + RULE_implicit_anonymous_function_parameter_list = 63, RULE_anonymous_function_body = 64, + RULE_query_expression = 65, RULE_from_clause = 66, RULE_query_body = 67, + RULE_query_body_clause = 68, RULE_let_clause = 69, RULE_where_clause = 70, + RULE_combined_join_clause = 71, RULE_orderby_clause = 72, RULE_ordering = 73, + RULE_select_or_group_clause = 74, RULE_query_continuation = 75, RULE_statement = 76, + RULE_declarationStatement = 77, RULE_local_function_declaration = 78, + RULE_local_function_header = 79, RULE_local_function_modifiers = 80, RULE_local_function_body = 81, + RULE_labeled_Statement = 82, RULE_embedded_statement = 83, RULE_simple_embedded_statement = 84, + RULE_block = 85, RULE_local_variable_declaration = 86, RULE_local_variable_type = 87, + RULE_local_variable_declarator = 88, RULE_local_variable_initializer = 89, + RULE_local_constant_declaration = 90, RULE_if_body = 91, RULE_switch_section = 92, + RULE_switch_label = 93, RULE_case_guard = 94, RULE_statement_list = 95, + RULE_for_initializer = 96, RULE_for_iterator = 97, RULE_catch_clauses = 98, + RULE_specific_catch_clause = 99, RULE_general_catch_clause = 100, RULE_exception_filter = 101, + RULE_finally_clause = 102, RULE_resource_acquisition = 103, RULE_namespace_declaration = 104, + RULE_qualified_identifier = 105, RULE_namespace_body = 106, RULE_extern_alias_directives = 107, + RULE_extern_alias_directive = 108, RULE_using_directives = 109, RULE_using_directive = 110, + RULE_namespace_member_declarations = 111, RULE_namespace_member_declaration = 112, + RULE_type_declaration = 113, RULE_qualified_alias_member = 114, RULE_type_parameter_list = 115, + RULE_type_parameter = 116, RULE_class_base = 117, RULE_interface_type_list = 118, + RULE_type_parameter_constraints_clauses = 119, RULE_type_parameter_constraints_clause = 120, + RULE_type_parameter_constraints = 121, RULE_primary_constraint = 122, + RULE_secondary_constraints = 123, RULE_constructor_constraint = 124, RULE_class_body = 125, + RULE_class_member_declarations = 126, RULE_class_member_declaration = 127, + RULE_all_member_modifiers = 128, RULE_all_member_modifier = 129, RULE_common_member_declaration = 130, + RULE_typed_member_declaration = 131, RULE_constant_declarators = 132, + RULE_constant_declarator = 133, RULE_variable_declarators = 134, RULE_variable_declarator = 135, + RULE_variable_initializer = 136, RULE_return_type = 137, RULE_member_name = 138, + RULE_method_body = 139, RULE_formal_parameter_list = 140, RULE_fixed_parameters = 141, + RULE_fixed_parameter = 142, RULE_parameter_modifier = 143, RULE_parameter_array = 144, + RULE_accessor_declarations = 145, RULE_get_accessor_declaration = 146, + RULE_set_accessor_declaration = 147, RULE_accessor_modifier = 148, RULE_accessor_body = 149, + RULE_event_accessor_declarations = 150, RULE_add_accessor_declaration = 151, + RULE_remove_accessor_declaration = 152, RULE_overloadable_operator = 153, + RULE_conversion_operator_declarator = 154, RULE_constructor_initializer = 155, + RULE_body = 156, RULE_struct_interfaces = 157, RULE_struct_body = 158, + RULE_struct_member_declaration = 159, RULE_array_type = 160, RULE_rank_specifier = 161, + RULE_array_initializer = 162, RULE_variant_type_parameter_list = 163, + RULE_variant_type_parameter = 164, RULE_variance_annotation = 165, RULE_interface_base = 166, + RULE_interface_body = 167, RULE_interface_member_declaration = 168, RULE_interface_accessors = 169, + RULE_enum_base = 170, RULE_enum_body = 171, RULE_enum_member_declaration = 172, + RULE_global_attribute_section = 173, RULE_global_attribute_target = 174, + RULE_attributes = 175, RULE_attribute_section = 176, RULE_attribute_target = 177, + RULE_attribute_list = 178, RULE_attribute = 179, RULE_attribute_argument = 180, + RULE_pointer_type = 181, RULE_fixed_pointer_declarators = 182, RULE_fixed_pointer_declarator = 183, + RULE_fixed_pointer_initializer = 184, RULE_fixed_size_buffer_declarator = 185, + RULE_stackalloc_initializer = 186, RULE_right_arrow = 187, RULE_right_shift = 188, + RULE_right_shift_assignment = 189, RULE_literal = 190, RULE_boolean_literal = 191, + RULE_string_literal = 192, RULE_interpolated_regular_string = 193, RULE_interpolated_verbatium_string = 194, + RULE_interpolated_regular_string_part = 195, RULE_interpolated_verbatium_string_part = 196, + RULE_interpolated_string_expression = 197, RULE_keyword = 198, RULE_class_definition = 199, + RULE_struct_definition = 200, RULE_interface_definition = 201, RULE_enum_definition = 202, + RULE_delegate_definition = 203, RULE_event_declaration = 204, RULE_field_declaration = 205, + RULE_property_declaration = 206, RULE_constant_declaration = 207, RULE_indexer_declaration = 208, + RULE_destructor_definition = 209, RULE_constructor_declaration = 210, + RULE_method_declaration = 211, RULE_method_member_name = 212, RULE_operator_declaration = 213, + RULE_arg_declaration = 214, RULE_method_invocation = 215, RULE_object_creation_expression = 216, + RULE_identifier = 217; + + private static String[] makeRuleNames() { + return new String[]{ + "compilation_unit", "namespace_or_type_name", "type_", "base_type", "tuple_type", + "tuple_element", "simple_type", "numeric_type", "integral_type", "floating_point_type", + "class_type", "type_argument_list", "argument_list", "argument", "expression", + "non_assignment_expression", "assignment", "assignment_operator", "conditional_expression", + "null_coalescing_expression", "conditional_or_expression", "conditional_and_expression", + "inclusive_or_expression", "exclusive_or_expression", "and_expression", + "equality_expression", "relational_expression", "shift_expression", "additive_expression", + "multiplicative_expression", "switch_expression", "switch_expression_arms", + "switch_expression_arm", "range_expression", "unary_expression", "primary_expression", + "primary_expression_start", "throwable_expression", "throw_expression", + "member_access", "bracket_expression", "indexer_argument", "predefined_type", + "expression_list", "object_or_collection_initializer", "object_initializer", + "member_initializer_list", "member_initializer", "initializer_value", + "collection_initializer", "element_initializer", "anonymous_object_initializer", + "member_declarator_list", "member_declarator", "unbound_type_name", "generic_dimension_specifier", + "isType", "isTypePatternArms", "isTypePatternArm", "lambda_expression", + "anonymous_function_signature", "explicit_anonymous_function_parameter_list", + "explicit_anonymous_function_parameter", "implicit_anonymous_function_parameter_list", + "anonymous_function_body", "query_expression", "from_clause", "query_body", + "query_body_clause", "let_clause", "where_clause", "combined_join_clause", + "orderby_clause", "ordering", "select_or_group_clause", "query_continuation", + "statement", "declarationStatement", "local_function_declaration", "local_function_header", + "local_function_modifiers", "local_function_body", "labeled_Statement", + "embedded_statement", "simple_embedded_statement", "block", "local_variable_declaration", + "local_variable_type", "local_variable_declarator", "local_variable_initializer", + "local_constant_declaration", "if_body", "switch_section", "switch_label", + "case_guard", "statement_list", "for_initializer", "for_iterator", "catch_clauses", + "specific_catch_clause", "general_catch_clause", "exception_filter", + "finally_clause", "resource_acquisition", "namespace_declaration", "qualified_identifier", + "namespace_body", "extern_alias_directives", "extern_alias_directive", + "using_directives", "using_directive", "namespace_member_declarations", + "namespace_member_declaration", "type_declaration", "qualified_alias_member", + "type_parameter_list", "type_parameter", "class_base", "interface_type_list", + "type_parameter_constraints_clauses", "type_parameter_constraints_clause", + "type_parameter_constraints", "primary_constraint", "secondary_constraints", + "constructor_constraint", "class_body", "class_member_declarations", + "class_member_declaration", "all_member_modifiers", "all_member_modifier", + "common_member_declaration", "typed_member_declaration", "constant_declarators", + "constant_declarator", "variable_declarators", "variable_declarator", + "variable_initializer", "return_type", "member_name", "method_body", + "formal_parameter_list", "fixed_parameters", "fixed_parameter", "parameter_modifier", + "parameter_array", "accessor_declarations", "get_accessor_declaration", + "set_accessor_declaration", "accessor_modifier", "accessor_body", "event_accessor_declarations", + "add_accessor_declaration", "remove_accessor_declaration", "overloadable_operator", + "conversion_operator_declarator", "constructor_initializer", "body", + "struct_interfaces", "struct_body", "struct_member_declaration", "array_type", + "rank_specifier", "array_initializer", "variant_type_parameter_list", + "variant_type_parameter", "variance_annotation", "interface_base", "interface_body", + "interface_member_declaration", "interface_accessors", "enum_base", "enum_body", + "enum_member_declaration", "global_attribute_section", "global_attribute_target", + "attributes", "attribute_section", "attribute_target", "attribute_list", + "attribute", "attribute_argument", "pointer_type", "fixed_pointer_declarators", + "fixed_pointer_declarator", "fixed_pointer_initializer", "fixed_size_buffer_declarator", + "stackalloc_initializer", "right_arrow", "right_shift", "right_shift_assignment", + "literal", "boolean_literal", "string_literal", "interpolated_regular_string", + "interpolated_verbatium_string", "interpolated_regular_string_part", + "interpolated_verbatium_string_part", "interpolated_string_expression", + "keyword", "class_definition", "struct_definition", "interface_definition", + "enum_definition", "delegate_definition", "event_declaration", "field_declaration", + "property_declaration", "constant_declaration", "indexer_declaration", + "destructor_definition", "constructor_declaration", "method_declaration", + "method_member_name", "operator_declaration", "arg_declaration", "method_invocation", + "object_creation_expression", "identifier" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, "'\\u00EF\\u00BB\\u00BF'", null, "'/***/'", null, null, null, null, + "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", + "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", + "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", + "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", + "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", + "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", + "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", + "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", + "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", + "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", + "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", + "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", + "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", + "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", + "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", + "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", + "'yield'", null, null, null, null, null, null, null, null, null, null, + null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", + "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", + "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", + "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", + "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", + "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, + null, "'hidden'", null, null, null, "'}}'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", + "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", + "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", + "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", + "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", + "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", + "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", + "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", + "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", + "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", + "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", + "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", + "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", + "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", + "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", + "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", + "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", + "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", + "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", + "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", + "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", + "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", + "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", + "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", + "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", + "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", + "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", + "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", + "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", + "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", + "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", + "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", + "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { + return "CSharpParser.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public CSharpParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class Compilation_unitContext extends ParserRuleContext { + public TerminalNode EOF() { + return getToken(CSharpParser.EOF, 0); + } + + public TerminalNode BYTE_ORDER_MARK() { + return getToken(CSharpParser.BYTE_ORDER_MARK, 0); + } + + public Extern_alias_directivesContext extern_alias_directives() { + return getRuleContext(Extern_alias_directivesContext.class, 0); + } + + public Using_directivesContext using_directives() { + return getRuleContext(Using_directivesContext.class, 0); + } + + public List global_attribute_section() { + return getRuleContexts(Global_attribute_sectionContext.class); + } + + public Global_attribute_sectionContext global_attribute_section(int i) { + return getRuleContext(Global_attribute_sectionContext.class, i); + } + + public Namespace_member_declarationsContext namespace_member_declarations() { + return getRuleContext(Namespace_member_declarationsContext.class, 0); + } + + public Compilation_unitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_compilation_unit; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterCompilation_unit(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitCompilation_unit(this); + } + } + + public final Compilation_unitContext compilation_unit() throws RecognitionException { + Compilation_unitContext _localctx = new Compilation_unitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_compilation_unit); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == BYTE_ORDER_MARK) { + { + setState(436); + match(BYTE_ORDER_MARK); + } + } + + setState(440); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 1, _ctx)) { + case 1: { + setState(439); + extern_alias_directives(); + } + break; + } + setState(443); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == USING) { + { + setState(442); + using_directives(); + } + } + + setState(448); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 3, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(445); + global_attribute_section(); + } + } + } + setState(450); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 3, _ctx); + } + setState(452); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 216175120790618624L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4611708283706211587L) != 0)) { + { + setState(451); + namespace_member_declarations(); + } + } + + setState(454); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Namespace_or_type_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public Qualified_alias_memberContext qualified_alias_member() { + return getRuleContext(Qualified_alias_memberContext.class, 0); + } + + public List DOT() { + return getTokens(CSharpParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + + public List type_argument_list() { + return getRuleContexts(Type_argument_listContext.class); + } + + public Type_argument_listContext type_argument_list(int i) { + return getRuleContext(Type_argument_listContext.class, i); + } + + public Namespace_or_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namespace_or_type_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNamespace_or_type_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNamespace_or_type_name(this); + } + } + + public final Namespace_or_type_nameContext namespace_or_type_name() throws RecognitionException { + Namespace_or_type_nameContext _localctx = new Namespace_or_type_nameContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_namespace_or_type_name); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(461); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 6, _ctx)) { + case 1: { + setState(456); + identifier(); + setState(458); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) { + case 1: { + setState(457); + type_argument_list(); + } + break; + } + } + break; + case 2: { + setState(460); + qualified_alias_member(); + } + break; + } + setState(470); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 8, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(463); + match(DOT); + setState(464); + identifier(); + setState(466); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) { + case 1: { + setState(465); + type_argument_list(); + } + break; + } + } + } + } + setState(472); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 8, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_Context extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class, 0); + } + + public List INTERR() { + return getTokens(CSharpParser.INTERR); + } + + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class, i); + } + + public List STAR() { + return getTokens(CSharpParser.STAR); + } + + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + + public Type_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterType_(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitType_(this); + } + } + + public final Type_Context type_() throws RecognitionException { + Type_Context _localctx = new Type_Context(_ctx, getState()); + enterRule(_localctx, 4, RULE_type_); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(473); + base_type(); + setState(479); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 10, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + setState(477); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTERR: { + setState(474); + match(INTERR); + } + break; + case OPEN_BRACKET: { + setState(475); + rank_specifier(); + } + break; + case STAR: { + setState(476); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(481); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 10, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Base_typeContext extends ParserRuleContext { + public Simple_typeContext simple_type() { + return getRuleContext(Simple_typeContext.class, 0); + } + + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public TerminalNode STAR() { + return getToken(CSharpParser.STAR, 0); + } + + public Tuple_typeContext tuple_type() { + return getRuleContext(Tuple_typeContext.class, 0); + } + + public Base_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_base_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterBase_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitBase_type(this); + } + } + + public final Base_typeContext base_type() throws RecognitionException { + Base_typeContext _localctx = new Base_typeContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_base_type); + try { + setState(487); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOL: + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(482); + simple_type(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(483); + class_type(); + } + break; + case VOID: + enterOuterAlt(_localctx, 3); + { + setState(484); + match(VOID); + setState(485); + match(STAR); + } + break; + case OPEN_PARENS: + enterOuterAlt(_localctx, 4); + { + setState(486); + tuple_type(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Tuple_typeContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public List tuple_element() { + return getRuleContexts(Tuple_elementContext.class); + } + + public Tuple_elementContext tuple_element(int i) { + return getRuleContext(Tuple_elementContext.class, i); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Tuple_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_tuple_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterTuple_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTuple_type(this); + } + } + + public final Tuple_typeContext tuple_type() throws RecognitionException { + Tuple_typeContext _localctx = new Tuple_typeContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_tuple_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(489); + match(OPEN_PARENS); + setState(490); + tuple_element(); + setState(493); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(491); + match(COMMA); + setState(492); + tuple_element(); + } + } + setState(495); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == COMMA); + setState(497); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Tuple_elementContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Tuple_elementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_tuple_element; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterTuple_element(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTuple_element(this); + } + } + + public final Tuple_elementContext tuple_element() throws RecognitionException { + Tuple_elementContext _localctx = new Tuple_elementContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_tuple_element); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(499); + type_(); + setState(501); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1904629023639713L) != 0)) { + { + setState(500); + identifier(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_typeContext extends ParserRuleContext { + public Numeric_typeContext numeric_type() { + return getRuleContext(Numeric_typeContext.class, 0); + } + + public TerminalNode BOOL() { + return getToken(CSharpParser.BOOL, 0); + } + + public Simple_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simple_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterSimple_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSimple_type(this); + } + } + + public final Simple_typeContext simple_type() throws RecognitionException { + Simple_typeContext _localctx = new Simple_typeContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_simple_type); + try { + setState(505); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(503); + numeric_type(); + } + break; + case BOOL: + enterOuterAlt(_localctx, 2); + { + setState(504); + match(BOOL); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Numeric_typeContext extends ParserRuleContext { + public Integral_typeContext integral_type() { + return getRuleContext(Integral_typeContext.class, 0); + } + + public Floating_point_typeContext floating_point_type() { + return getRuleContext(Floating_point_typeContext.class, 0); + } + + public TerminalNode DECIMAL() { + return getToken(CSharpParser.DECIMAL, 0); + } + + public Numeric_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_numeric_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterNumeric_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitNumeric_type(this); + } + } + + public final Numeric_typeContext numeric_type() throws RecognitionException { + Numeric_typeContext _localctx = new Numeric_typeContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_numeric_type); + try { + setState(510); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: + enterOuterAlt(_localctx, 1); + { + setState(507); + integral_type(); + } + break; + case DOUBLE: + case FLOAT: + enterOuterAlt(_localctx, 2); + { + setState(508); + floating_point_type(); + } + break; + case DECIMAL: + enterOuterAlt(_localctx, 3); + { + setState(509); + match(DECIMAL); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Integral_typeContext extends ParserRuleContext { + public TerminalNode SBYTE() { + return getToken(CSharpParser.SBYTE, 0); + } + + public TerminalNode BYTE() { + return getToken(CSharpParser.BYTE, 0); + } + + public TerminalNode SHORT() { + return getToken(CSharpParser.SHORT, 0); + } + + public TerminalNode USHORT() { + return getToken(CSharpParser.USHORT, 0); + } + + public TerminalNode INT() { + return getToken(CSharpParser.INT, 0); + } + + public TerminalNode UINT() { + return getToken(CSharpParser.UINT, 0); + } + + public TerminalNode LONG() { + return getToken(CSharpParser.LONG, 0); + } + + public TerminalNode ULONG() { + return getToken(CSharpParser.ULONG, 0); + } + + public TerminalNode CHAR() { + return getToken(CSharpParser.CHAR, 0); + } + + public Integral_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_integral_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIntegral_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIntegral_type(this); + } + } + + public final Integral_typeContext integral_type() throws RecognitionException { + Integral_typeContext _localctx = new Integral_typeContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_integral_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(512); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & -9187343239816937472L) != 0) || ((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & 2293777L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Floating_point_typeContext extends ParserRuleContext { + public TerminalNode FLOAT() { + return getToken(CSharpParser.FLOAT, 0); + } + + public TerminalNode DOUBLE() { + return getToken(CSharpParser.DOUBLE, 0); + } + + public Floating_point_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_floating_point_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFloating_point_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFloating_point_type(this); + } + } + + public final Floating_point_typeContext floating_point_type() throws RecognitionException { + Floating_point_typeContext _localctx = new Floating_point_typeContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_floating_point_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(514); + _la = _input.LA(1); + if (!(_la == DOUBLE || _la == FLOAT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_typeContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode OBJECT() { + return getToken(CSharpParser.OBJECT, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(CSharpParser.DYNAMIC, 0); + } + + public TerminalNode STRING() { + return getToken(CSharpParser.STRING, 0); + } + + public Class_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterClass_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitClass_type(this); + } + } + + public final Class_typeContext class_type() throws RecognitionException { + Class_typeContext _localctx = new Class_typeContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_class_type); + try { + setState(520); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 16, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(516); + namespace_or_type_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(517); + match(OBJECT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(518); + match(DYNAMIC); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(519); + match(STRING); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_argument_listContext extends ParserRuleContext { + public TerminalNode LT() { + return getToken(CSharpParser.LT, 0); + } + + public List type_() { + return getRuleContexts(Type_Context.class); + } + + public Type_Context type_(int i) { + return getRuleContext(Type_Context.class, i); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Type_argument_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_argument_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterType_argument_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitType_argument_list(this); + } + } + + public final Type_argument_listContext type_argument_list() throws RecognitionException { + Type_argument_listContext _localctx = new Type_argument_listContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_type_argument_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(522); + match(LT); + setState(523); + type_(); + setState(528); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(524); + match(COMMA); + setState(525); + type_(); + } + } + setState(530); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(531); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Argument_listContext extends ParserRuleContext { + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Argument_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_argument_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterArgument_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitArgument_list(this); + } + } + + public final Argument_listContext argument_list() throws RecognitionException { + Argument_listContext _localctx = new Argument_listContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_argument_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(533); + argument(); + setState(538); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(534); + match(COMMA); + setState(535); + argument(); + } + } + setState(540); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgumentContext extends ParserRuleContext { + public Token refout; + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public TerminalNode VAR() { + return getToken(CSharpParser.VAR, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode OUT() { + return getToken(CSharpParser.OUT, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public ArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_argument; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterArgument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitArgument(this); + } + } + + public final ArgumentContext argument() throws RecognitionException { + ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_argument); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(544); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 19, _ctx)) { + case 1: { + setState(541); + identifier(); + setState(542); + match(COLON); + } + break; + } + setState(547); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 20, _ctx)) { + case 1: { + setState(546); + ((ArgumentContext) _localctx).refout = _input.LT(1); + _la = _input.LA(1); + if (!(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 67371009L) != 0))) { + ((ArgumentContext) _localctx).refout = (Token) _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(551); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 21, _ctx)) { + case 1: { + setState(549); + match(VAR); + } + break; + case 2: { + setState(550); + type_(); + } + break; + } + setState(553); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionContext extends ParserRuleContext { + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class, 0); + } + + public Non_assignment_expressionContext non_assignment_expression() { + return getRuleContext(Non_assignment_expressionContext.class, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_expression); + try { + setState(559); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 22, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(555); + assignment(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(556); + non_assignment_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(557); + match(REF); + setState(558); + non_assignment_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Non_assignment_expressionContext extends ParserRuleContext { + public Lambda_expressionContext lambda_expression() { + return getRuleContext(Lambda_expressionContext.class, 0); + } + + public Query_expressionContext query_expression() { + return getRuleContext(Query_expressionContext.class, 0); + } + + public Conditional_expressionContext conditional_expression() { + return getRuleContext(Conditional_expressionContext.class, 0); + } + + public Non_assignment_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_non_assignment_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNon_assignment_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNon_assignment_expression(this); + } + } + + public final Non_assignment_expressionContext non_assignment_expression() throws RecognitionException { + Non_assignment_expressionContext _localctx = new Non_assignment_expressionContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_non_assignment_expression); + try { + setState(564); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 23, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(561); + lambda_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(562); + query_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(563); + conditional_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssignmentContext extends ParserRuleContext { + public Unary_expressionContext unary_expression() { + return getRuleContext(Unary_expressionContext.class, 0); + } + + public Assignment_operatorContext assignment_operator() { + return getRuleContext(Assignment_operatorContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode OP_COALESCING_ASSIGNMENT() { + return getToken(CSharpParser.OP_COALESCING_ASSIGNMENT, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assignment; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAssignment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAssignment(this); + } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_assignment); + try { + setState(574); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 24, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(566); + unary_expression(); + setState(567); + assignment_operator(); + setState(568); + expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(570); + unary_expression(); + setState(571); + match(OP_COALESCING_ASSIGNMENT); + setState(572); + throwable_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assignment_operatorContext extends ParserRuleContext { + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public TerminalNode OP_ADD_ASSIGNMENT() { + return getToken(CSharpParser.OP_ADD_ASSIGNMENT, 0); + } + + public TerminalNode OP_SUB_ASSIGNMENT() { + return getToken(CSharpParser.OP_SUB_ASSIGNMENT, 0); + } + + public TerminalNode OP_MULT_ASSIGNMENT() { + return getToken(CSharpParser.OP_MULT_ASSIGNMENT, 0); + } + + public TerminalNode OP_DIV_ASSIGNMENT() { + return getToken(CSharpParser.OP_DIV_ASSIGNMENT, 0); + } + + public TerminalNode OP_MOD_ASSIGNMENT() { + return getToken(CSharpParser.OP_MOD_ASSIGNMENT, 0); + } + + public TerminalNode OP_AND_ASSIGNMENT() { + return getToken(CSharpParser.OP_AND_ASSIGNMENT, 0); + } + + public TerminalNode OP_OR_ASSIGNMENT() { + return getToken(CSharpParser.OP_OR_ASSIGNMENT, 0); + } + + public TerminalNode OP_XOR_ASSIGNMENT() { + return getToken(CSharpParser.OP_XOR_ASSIGNMENT, 0); + } + + public TerminalNode OP_LEFT_SHIFT_ASSIGNMENT() { + return getToken(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT, 0); + } + + public Right_shift_assignmentContext right_shift_assignment() { + return getRuleContext(Right_shift_assignmentContext.class, 0); + } + + public Assignment_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assignment_operator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAssignment_operator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAssignment_operator(this); + } + } + + public final Assignment_operatorContext assignment_operator() throws RecognitionException { + Assignment_operatorContext _localctx = new Assignment_operatorContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_assignment_operator); + try { + setState(587); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASSIGNMENT: + enterOuterAlt(_localctx, 1); + { + setState(576); + match(ASSIGNMENT); + } + break; + case OP_ADD_ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(577); + match(OP_ADD_ASSIGNMENT); + } + break; + case OP_SUB_ASSIGNMENT: + enterOuterAlt(_localctx, 3); + { + setState(578); + match(OP_SUB_ASSIGNMENT); + } + break; + case OP_MULT_ASSIGNMENT: + enterOuterAlt(_localctx, 4); + { + setState(579); + match(OP_MULT_ASSIGNMENT); + } + break; + case OP_DIV_ASSIGNMENT: + enterOuterAlt(_localctx, 5); + { + setState(580); + match(OP_DIV_ASSIGNMENT); + } + break; + case OP_MOD_ASSIGNMENT: + enterOuterAlt(_localctx, 6); + { + setState(581); + match(OP_MOD_ASSIGNMENT); + } + break; + case OP_AND_ASSIGNMENT: + enterOuterAlt(_localctx, 7); + { + setState(582); + match(OP_AND_ASSIGNMENT); + } + break; + case OP_OR_ASSIGNMENT: + enterOuterAlt(_localctx, 8); + { + setState(583); + match(OP_OR_ASSIGNMENT); + } + break; + case OP_XOR_ASSIGNMENT: + enterOuterAlt(_localctx, 9); + { + setState(584); + match(OP_XOR_ASSIGNMENT); + } + break; + case OP_LEFT_SHIFT_ASSIGNMENT: + enterOuterAlt(_localctx, 10); + { + setState(585); + match(OP_LEFT_SHIFT_ASSIGNMENT); + } + break; + case GT: + enterOuterAlt(_localctx, 11); + { + setState(586); + right_shift_assignment(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Conditional_expressionContext extends ParserRuleContext { + public Null_coalescing_expressionContext null_coalescing_expression() { + return getRuleContext(Null_coalescing_expressionContext.class, 0); + } + + public TerminalNode INTERR() { + return getToken(CSharpParser.INTERR, 0); + } + + public List throwable_expression() { + return getRuleContexts(Throwable_expressionContext.class); + } + + public Throwable_expressionContext throwable_expression(int i) { + return getRuleContext(Throwable_expressionContext.class, i); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Conditional_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conditional_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConditional_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConditional_expression(this); + } + } + + public final Conditional_expressionContext conditional_expression() throws RecognitionException { + Conditional_expressionContext _localctx = new Conditional_expressionContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_conditional_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(589); + null_coalescing_expression(); + setState(595); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 26, _ctx)) { + case 1: { + setState(590); + match(INTERR); + setState(591); + throwable_expression(); + setState(592); + match(COLON); + setState(593); + throwable_expression(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Null_coalescing_expressionContext extends ParserRuleContext { + public Conditional_or_expressionContext conditional_or_expression() { + return getRuleContext(Conditional_or_expressionContext.class, 0); + } + + public TerminalNode OP_COALESCING() { + return getToken(CSharpParser.OP_COALESCING, 0); + } + + public Null_coalescing_expressionContext null_coalescing_expression() { + return getRuleContext(Null_coalescing_expressionContext.class, 0); + } + + public Throw_expressionContext throw_expression() { + return getRuleContext(Throw_expressionContext.class, 0); + } + + public Null_coalescing_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_null_coalescing_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNull_coalescing_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNull_coalescing_expression(this); + } + } + + public final Null_coalescing_expressionContext null_coalescing_expression() throws RecognitionException { + Null_coalescing_expressionContext _localctx = new Null_coalescing_expressionContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_null_coalescing_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(597); + conditional_or_expression(); + setState(603); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OP_COALESCING) { + { + setState(598); + match(OP_COALESCING); + setState(601); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: { + setState(599); + null_coalescing_expression(); + } + break; + case THROW: { + setState(600); + throw_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Conditional_or_expressionContext extends ParserRuleContext { + public List conditional_and_expression() { + return getRuleContexts(Conditional_and_expressionContext.class); + } + + public Conditional_and_expressionContext conditional_and_expression(int i) { + return getRuleContext(Conditional_and_expressionContext.class, i); + } + + public List OP_OR() { + return getTokens(CSharpParser.OP_OR); + } + + public TerminalNode OP_OR(int i) { + return getToken(CSharpParser.OP_OR, i); + } + + public Conditional_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conditional_or_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConditional_or_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConditional_or_expression(this); + } + } + + public final Conditional_or_expressionContext conditional_or_expression() throws RecognitionException { + Conditional_or_expressionContext _localctx = new Conditional_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_conditional_or_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(605); + conditional_and_expression(); + setState(610); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OP_OR) { + { + { + setState(606); + match(OP_OR); + setState(607); + conditional_and_expression(); + } + } + setState(612); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Conditional_and_expressionContext extends ParserRuleContext { + public List inclusive_or_expression() { + return getRuleContexts(Inclusive_or_expressionContext.class); + } + + public Inclusive_or_expressionContext inclusive_or_expression(int i) { + return getRuleContext(Inclusive_or_expressionContext.class, i); + } + + public List OP_AND() { + return getTokens(CSharpParser.OP_AND); + } + + public TerminalNode OP_AND(int i) { + return getToken(CSharpParser.OP_AND, i); + } + + public Conditional_and_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conditional_and_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConditional_and_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConditional_and_expression(this); + } + } + + public final Conditional_and_expressionContext conditional_and_expression() throws RecognitionException { + Conditional_and_expressionContext _localctx = new Conditional_and_expressionContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_conditional_and_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(613); + inclusive_or_expression(); + setState(618); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OP_AND) { + { + { + setState(614); + match(OP_AND); + setState(615); + inclusive_or_expression(); + } + } + setState(620); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Inclusive_or_expressionContext extends ParserRuleContext { + public List exclusive_or_expression() { + return getRuleContexts(Exclusive_or_expressionContext.class); + } + + public Exclusive_or_expressionContext exclusive_or_expression(int i) { + return getRuleContext(Exclusive_or_expressionContext.class, i); + } + + public List BITWISE_OR() { + return getTokens(CSharpParser.BITWISE_OR); + } + + public TerminalNode BITWISE_OR(int i) { + return getToken(CSharpParser.BITWISE_OR, i); + } + + public Inclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_inclusive_or_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInclusive_or_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInclusive_or_expression(this); + } + } + + public final Inclusive_or_expressionContext inclusive_or_expression() throws RecognitionException { + Inclusive_or_expressionContext _localctx = new Inclusive_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_inclusive_or_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + exclusive_or_expression(); + setState(626); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == BITWISE_OR) { + { + { + setState(622); + match(BITWISE_OR); + setState(623); + exclusive_or_expression(); + } + } + setState(628); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Exclusive_or_expressionContext extends ParserRuleContext { + public List and_expression() { + return getRuleContexts(And_expressionContext.class); + } + + public And_expressionContext and_expression(int i) { + return getRuleContext(And_expressionContext.class, i); + } + + public List CARET() { + return getTokens(CSharpParser.CARET); + } + + public TerminalNode CARET(int i) { + return getToken(CSharpParser.CARET, i); + } + + public Exclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_exclusive_or_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExclusive_or_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExclusive_or_expression(this); + } + } + + public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException { + Exclusive_or_expressionContext _localctx = new Exclusive_or_expressionContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_exclusive_or_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(629); + and_expression(); + setState(634); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(630); + match(CARET); + setState(631); + and_expression(); + } + } + } + setState(636); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class And_expressionContext extends ParserRuleContext { + public List equality_expression() { + return getRuleContexts(Equality_expressionContext.class); + } + + public Equality_expressionContext equality_expression(int i) { + return getRuleContext(Equality_expressionContext.class, i); + } + + public List AMP() { + return getTokens(CSharpParser.AMP); + } + + public TerminalNode AMP(int i) { + return getToken(CSharpParser.AMP, i); + } + + public And_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_and_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAnd_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAnd_expression(this); + } + } + + public final And_expressionContext and_expression() throws RecognitionException { + And_expressionContext _localctx = new And_expressionContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_and_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(637); + equality_expression(); + setState(642); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 33, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(638); + match(AMP); + setState(639); + equality_expression(); + } + } + } + setState(644); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 33, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Equality_expressionContext extends ParserRuleContext { + public List relational_expression() { + return getRuleContexts(Relational_expressionContext.class); + } + + public Relational_expressionContext relational_expression(int i) { + return getRuleContext(Relational_expressionContext.class, i); + } + + public List OP_EQ() { + return getTokens(CSharpParser.OP_EQ); + } + + public TerminalNode OP_EQ(int i) { + return getToken(CSharpParser.OP_EQ, i); + } + + public List OP_NE() { + return getTokens(CSharpParser.OP_NE); + } + + public TerminalNode OP_NE(int i) { + return getToken(CSharpParser.OP_NE, i); + } + + public Equality_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_equality_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterEquality_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitEquality_expression(this); + } + } + + public final Equality_expressionContext equality_expression() throws RecognitionException { + Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_equality_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(645); + relational_expression(); + setState(650); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OP_EQ || _la == OP_NE) { + { + { + setState(646); + _la = _input.LA(1); + if (!(_la == OP_EQ || _la == OP_NE)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(647); + relational_expression(); + } + } + setState(652); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Relational_expressionContext extends ParserRuleContext { + public List shift_expression() { + return getRuleContexts(Shift_expressionContext.class); + } + + public Shift_expressionContext shift_expression(int i) { + return getRuleContext(Shift_expressionContext.class, i); + } + + public List IS() { + return getTokens(CSharpParser.IS); + } + + public TerminalNode IS(int i) { + return getToken(CSharpParser.IS, i); + } + + public List isType() { + return getRuleContexts(IsTypeContext.class); + } + + public IsTypeContext isType(int i) { + return getRuleContext(IsTypeContext.class, i); + } + + public List AS() { + return getTokens(CSharpParser.AS); + } + + public TerminalNode AS(int i) { + return getToken(CSharpParser.AS, i); + } + + public List type_() { + return getRuleContexts(Type_Context.class); + } + + public Type_Context type_(int i) { + return getRuleContext(Type_Context.class, i); + } + + public List LT() { + return getTokens(CSharpParser.LT); + } + + public TerminalNode LT(int i) { + return getToken(CSharpParser.LT, i); + } + + public List GT() { + return getTokens(CSharpParser.GT); + } + + public TerminalNode GT(int i) { + return getToken(CSharpParser.GT, i); + } + + public List OP_LE() { + return getTokens(CSharpParser.OP_LE); + } + + public TerminalNode OP_LE(int i) { + return getToken(CSharpParser.OP_LE, i); + } + + public List OP_GE() { + return getTokens(CSharpParser.OP_GE); + } + + public TerminalNode OP_GE(int i) { + return getToken(CSharpParser.OP_GE, i); + } + + public Relational_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_relational_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterRelational_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitRelational_expression(this); + } + } + + public final Relational_expressionContext relational_expression() throws RecognitionException { + Relational_expressionContext _localctx = new Relational_expressionContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_relational_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(653); + shift_expression(); + setState(662); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AS || _la == IS || ((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & 12291L) != 0)) { + { + setState(660); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LT: + case GT: + case OP_LE: + case OP_GE: { + setState(654); + _la = _input.LA(1); + if (!(((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & 12291L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(655); + shift_expression(); + } + break; + case IS: { + setState(656); + match(IS); + setState(657); + isType(); + } + break; + case AS: { + setState(658); + match(AS); + setState(659); + type_(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(664); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Shift_expressionContext extends ParserRuleContext { + public List additive_expression() { + return getRuleContexts(Additive_expressionContext.class); + } + + public Additive_expressionContext additive_expression(int i) { + return getRuleContext(Additive_expressionContext.class, i); + } + + public List OP_LEFT_SHIFT() { + return getTokens(CSharpParser.OP_LEFT_SHIFT); + } + + public TerminalNode OP_LEFT_SHIFT(int i) { + return getToken(CSharpParser.OP_LEFT_SHIFT, i); + } + + public List right_shift() { + return getRuleContexts(Right_shiftContext.class); + } + + public Right_shiftContext right_shift(int i) { + return getRuleContext(Right_shiftContext.class, i); + } + + public Shift_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_shift_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterShift_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitShift_expression(this); + } + } + + public final Shift_expressionContext shift_expression() throws RecognitionException { + Shift_expressionContext _localctx = new Shift_expressionContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_shift_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(665); + additive_expression(); + setState(673); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 38, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(668); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OP_LEFT_SHIFT: { + setState(666); + match(OP_LEFT_SHIFT); + } + break; + case GT: { + setState(667); + right_shift(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(670); + additive_expression(); + } + } + } + setState(675); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 38, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Additive_expressionContext extends ParserRuleContext { + public List multiplicative_expression() { + return getRuleContexts(Multiplicative_expressionContext.class); + } + + public Multiplicative_expressionContext multiplicative_expression(int i) { + return getRuleContext(Multiplicative_expressionContext.class, i); + } + + public List PLUS() { + return getTokens(CSharpParser.PLUS); + } + + public TerminalNode PLUS(int i) { + return getToken(CSharpParser.PLUS, i); + } + + public List MINUS() { + return getTokens(CSharpParser.MINUS); + } + + public TerminalNode MINUS(int i) { + return getToken(CSharpParser.MINUS, i); + } + + public Additive_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_additive_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAdditive_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAdditive_expression(this); + } + } + + public final Additive_expressionContext additive_expression() throws RecognitionException { + Additive_expressionContext _localctx = new Additive_expressionContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_additive_expression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(676); + multiplicative_expression(); + setState(681); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 39, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(677); + _la = _input.LA(1); + if (!(_la == PLUS || _la == MINUS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(678); + multiplicative_expression(); + } + } + } + setState(683); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 39, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Multiplicative_expressionContext extends ParserRuleContext { + public List switch_expression() { + return getRuleContexts(Switch_expressionContext.class); + } + + public Switch_expressionContext switch_expression(int i) { + return getRuleContext(Switch_expressionContext.class, i); + } + + public List STAR() { + return getTokens(CSharpParser.STAR); + } + + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + + public List DIV() { + return getTokens(CSharpParser.DIV); + } + + public TerminalNode DIV(int i) { + return getToken(CSharpParser.DIV, i); + } + + public List PERCENT() { + return getTokens(CSharpParser.PERCENT); + } + + public TerminalNode PERCENT(int i) { + return getToken(CSharpParser.PERCENT, i); + } + + public Multiplicative_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicative_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMultiplicative_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMultiplicative_expression(this); + } + } + + public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException { + Multiplicative_expressionContext _localctx = new Multiplicative_expressionContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_multiplicative_expression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(684); + switch_expression(); + setState(689); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 40, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(685); + _la = _input.LA(1); + if (!(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & 7L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(686); + switch_expression(); + } + } + } + setState(691); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 40, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Switch_expressionContext extends ParserRuleContext { + public Range_expressionContext range_expression() { + return getRuleContext(Range_expressionContext.class, 0); + } + + public TerminalNode SWITCH() { + return getToken(CSharpParser.SWITCH, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Switch_expression_armsContext switch_expression_arms() { + return getRuleContext(Switch_expression_armsContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Switch_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_switch_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSwitch_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSwitch_expression(this); + } + } + + public final Switch_expressionContext switch_expression() throws RecognitionException { + Switch_expressionContext _localctx = new Switch_expressionContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_switch_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(692); + range_expression(); + setState(702); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SWITCH) { + { + setState(693); + match(SWITCH); + setState(694); + match(OPEN_BRACE); + setState(699); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(695); + switch_expression_arms(); + setState(697); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(696); + match(COMMA); + } + } + + } + } + + setState(701); + match(CLOSE_BRACE); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Switch_expression_armsContext extends ParserRuleContext { + public List switch_expression_arm() { + return getRuleContexts(Switch_expression_armContext.class); + } + + public Switch_expression_armContext switch_expression_arm(int i) { + return getRuleContext(Switch_expression_armContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Switch_expression_armsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_switch_expression_arms; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSwitch_expression_arms(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSwitch_expression_arms(this); + } + } + + public final Switch_expression_armsContext switch_expression_arms() throws RecognitionException { + Switch_expression_armsContext _localctx = new Switch_expression_armsContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_switch_expression_arms); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(704); + switch_expression_arm(); + setState(709); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 44, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(705); + match(COMMA); + setState(706); + switch_expression_arm(); + } + } + } + setState(711); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 44, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Switch_expression_armContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public Case_guardContext case_guard() { + return getRuleContext(Case_guardContext.class, 0); + } + + public Switch_expression_armContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_switch_expression_arm; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSwitch_expression_arm(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSwitch_expression_arm(this); + } + } + + public final Switch_expression_armContext switch_expression_arm() throws RecognitionException { + Switch_expression_armContext _localctx = new Switch_expression_armContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_switch_expression_arm); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(712); + expression(); + setState(714); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHEN) { + { + setState(713); + case_guard(); + } + } + + setState(716); + right_arrow(); + setState(717); + throwable_expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Range_expressionContext extends ParserRuleContext { + public List unary_expression() { + return getRuleContexts(Unary_expressionContext.class); + } + + public Unary_expressionContext unary_expression(int i) { + return getRuleContext(Unary_expressionContext.class, i); + } + + public TerminalNode OP_RANGE() { + return getToken(CSharpParser.OP_RANGE, 0); + } + + public Range_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_range_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterRange_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitRange_expression(this); + } + } + + public final Range_expressionContext range_expression() throws RecognitionException { + Range_expressionContext _localctx = new Range_expressionContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_range_expression); + int _la; + try { + setState(727); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 48, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(719); + unary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(721); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161930941L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 12642753L) != 0)) { + { + setState(720); + unary_expression(); + } + } + + setState(723); + match(OP_RANGE); + setState(725); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 47, _ctx)) { + case 1: { + setState(724); + unary_expression(); + } + break; + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unary_expressionContext extends ParserRuleContext { + public Primary_expressionContext primary_expression() { + return getRuleContext(Primary_expressionContext.class, 0); + } + + public TerminalNode PLUS() { + return getToken(CSharpParser.PLUS, 0); + } + + public Unary_expressionContext unary_expression() { + return getRuleContext(Unary_expressionContext.class, 0); + } + + public TerminalNode MINUS() { + return getToken(CSharpParser.MINUS, 0); + } + + public TerminalNode BANG() { + return getToken(CSharpParser.BANG, 0); + } + + public TerminalNode TILDE() { + return getToken(CSharpParser.TILDE, 0); + } + + public TerminalNode OP_INC() { + return getToken(CSharpParser.OP_INC, 0); + } + + public TerminalNode OP_DEC() { + return getToken(CSharpParser.OP_DEC, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode AWAIT() { + return getToken(CSharpParser.AWAIT, 0); + } + + public TerminalNode AMP() { + return getToken(CSharpParser.AMP, 0); + } + + public TerminalNode STAR() { + return getToken(CSharpParser.STAR, 0); + } + + public TerminalNode CARET() { + return getToken(CSharpParser.CARET, 0); + } + + public Unary_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_unary_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterUnary_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitUnary_expression(this); + } + } + + public final Unary_expressionContext unary_expression() throws RecognitionException { + Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_unary_expression); + try { + setState(755); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 49, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(729); + primary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(730); + match(PLUS); + setState(731); + unary_expression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(732); + match(MINUS); + setState(733); + unary_expression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(734); + match(BANG); + setState(735); + unary_expression(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(736); + match(TILDE); + setState(737); + unary_expression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(738); + match(OP_INC); + setState(739); + unary_expression(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(740); + match(OP_DEC); + setState(741); + unary_expression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(742); + match(OPEN_PARENS); + setState(743); + type_(); + setState(744); + match(CLOSE_PARENS); + setState(745); + unary_expression(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(747); + match(AWAIT); + setState(748); + unary_expression(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(749); + match(AMP); + setState(750); + unary_expression(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(751); + match(STAR); + setState(752); + unary_expression(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(753); + match(CARET); + setState(754); + unary_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Primary_expressionContext extends ParserRuleContext { + public Primary_expression_startContext pe; + + public Primary_expression_startContext primary_expression_start() { + return getRuleContext(Primary_expression_startContext.class, 0); + } + + public List BANG() { + return getTokens(CSharpParser.BANG); + } + + public TerminalNode BANG(int i) { + return getToken(CSharpParser.BANG, i); + } + + public List bracket_expression() { + return getRuleContexts(Bracket_expressionContext.class); + } + + public Bracket_expressionContext bracket_expression(int i) { + return getRuleContext(Bracket_expressionContext.class, i); + } + + public List member_access() { + return getRuleContexts(Member_accessContext.class); + } + + public Member_accessContext member_access(int i) { + return getRuleContext(Member_accessContext.class, i); + } + + public List method_invocation() { + return getRuleContexts(Method_invocationContext.class); + } + + public Method_invocationContext method_invocation(int i) { + return getRuleContext(Method_invocationContext.class, i); + } + + public List OP_INC() { + return getTokens(CSharpParser.OP_INC); + } + + public TerminalNode OP_INC(int i) { + return getToken(CSharpParser.OP_INC, i); + } + + public List OP_DEC() { + return getTokens(CSharpParser.OP_DEC); + } + + public TerminalNode OP_DEC(int i) { + return getToken(CSharpParser.OP_DEC, i); + } + + public List OP_PTR() { + return getTokens(CSharpParser.OP_PTR); + } + + public TerminalNode OP_PTR(int i) { + return getToken(CSharpParser.OP_PTR, i); + } + + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public Primary_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_primary_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterPrimary_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitPrimary_expression(this); + } + } + + public final Primary_expressionContext primary_expression() throws RecognitionException { + Primary_expressionContext _localctx = new Primary_expressionContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_primary_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(757); + ((Primary_expressionContext) _localctx).pe = primary_expression_start(); + setState(759); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 50, _ctx)) { + case 1: { + setState(758); + match(BANG); + } + break; + } + setState(764); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 51, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(761); + bracket_expression(); + } + } + } + setState(766); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 51, _ctx); + } + setState(768); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 52, _ctx)) { + case 1: { + setState(767); + match(BANG); + } + break; + } + setState(792); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 57, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + { + setState(776); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + case INTERR: { + setState(770); + member_access(); + } + break; + case OPEN_PARENS: { + setState(771); + method_invocation(); + } + break; + case OP_INC: { + setState(772); + match(OP_INC); + } + break; + case OP_DEC: { + setState(773); + match(OP_DEC); + } + break; + case OP_PTR: { + setState(774); + match(OP_PTR); + setState(775); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(779); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 54, _ctx)) { + case 1: { + setState(778); + match(BANG); + } + break; + } + } + setState(784); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 55, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(781); + bracket_expression(); + } + } + } + setState(786); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 55, _ctx); + } + setState(788); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 56, _ctx)) { + case 1: { + setState(787); + match(BANG); + } + break; + } + } + } + } + setState(794); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 57, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Primary_expression_startContext extends ParserRuleContext { + public Primary_expression_startContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_primary_expression_start; + } + + public Primary_expression_startContext() { + } + + public void copyFrom(Primary_expression_startContext ctx) { + super.copyFrom(ctx); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralAccessExpressionContext extends Primary_expression_startContext { + public TerminalNode LITERAL_ACCESS() { + return getToken(CSharpParser.LITERAL_ACCESS, 0); + } + + public LiteralAccessExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLiteralAccessExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLiteralAccessExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class DefaultValueExpressionContext extends Primary_expression_startContext { + public TerminalNode DEFAULT() { + return getToken(CSharpParser.DEFAULT, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public DefaultValueExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterDefaultValueExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitDefaultValueExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class BaseAccessExpressionContext extends Primary_expression_startContext { + public TerminalNode BASE() { + return getToken(CSharpParser.BASE, 0); + } + + public TerminalNode DOT() { + return getToken(CSharpParser.DOT, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class, 0); + } + + public BaseAccessExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterBaseAccessExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitBaseAccessExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class SizeofExpressionContext extends Primary_expression_startContext { + public TerminalNode SIZEOF() { + return getToken(CSharpParser.SIZEOF, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public SizeofExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterSizeofExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSizeofExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ParenthesisExpressionsContext extends Primary_expression_startContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public ParenthesisExpressionsContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterParenthesisExpressions(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitParenthesisExpressions(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ThisReferenceExpressionContext extends Primary_expression_startContext { + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public ThisReferenceExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterThisReferenceExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitThisReferenceExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ObjectCreationExpressionContext extends Primary_expression_startContext { + public TerminalNode NEW() { + return getToken(CSharpParser.NEW, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Anonymous_object_initializerContext anonymous_object_initializer() { + return getRuleContext(Anonymous_object_initializerContext.class, 0); + } + + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class, i); + } + + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class, 0); + } + + public Object_creation_expressionContext object_creation_expression() { + return getRuleContext(Object_creation_expressionContext.class, 0); + } + + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public ObjectCreationExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterObjectCreationExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitObjectCreationExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class AnonymousMethodExpressionContext extends Primary_expression_startContext { + public TerminalNode DELEGATE() { + return getToken(CSharpParser.DELEGATE, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASYNC() { + return getToken(CSharpParser.ASYNC, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { + return getRuleContext(Explicit_anonymous_function_parameter_listContext.class, 0); + } + + public AnonymousMethodExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAnonymousMethodExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAnonymousMethodExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeofExpressionContext extends Primary_expression_startContext { + public TerminalNode TYPEOF() { + return getToken(CSharpParser.TYPEOF, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Unbound_type_nameContext unbound_type_name() { + return getRuleContext(Unbound_type_nameContext.class, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public TypeofExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterTypeofExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTypeofExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleExpressionContext extends Primary_expression_startContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class, i); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public TupleExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterTupleExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTupleExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UncheckedExpressionContext extends Primary_expression_startContext { + public TerminalNode UNCHECKED() { + return getToken(CSharpParser.UNCHECKED, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public UncheckedExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUncheckedExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitUncheckedExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleNameExpressionContext extends Primary_expression_startContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class, 0); + } + + public SimpleNameExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSimpleNameExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSimpleNameExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class MemberAccessExpressionContext extends Primary_expression_startContext { + public Predefined_typeContext predefined_type() { + return getRuleContext(Predefined_typeContext.class, 0); + } + + public Qualified_alias_memberContext qualified_alias_member() { + return getRuleContext(Qualified_alias_memberContext.class, 0); + } + + public MemberAccessExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMemberAccessExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMemberAccessExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class CheckedExpressionContext extends Primary_expression_startContext { + public TerminalNode CHECKED() { + return getToken(CSharpParser.CHECKED, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public CheckedExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterCheckedExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitCheckedExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralExpressionContext extends Primary_expression_startContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class, 0); + } + + public LiteralExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLiteralExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLiteralExpression(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class NameofExpressionContext extends Primary_expression_startContext { + public TerminalNode NAMEOF() { + return getToken(CSharpParser.NAMEOF, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public List DOT() { + return getTokens(CSharpParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + + public NameofExpressionContext(Primary_expression_startContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterNameofExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitNameofExpression(this); + } + } + + public final Primary_expression_startContext primary_expression_start() throws RecognitionException { + Primary_expression_startContext _localctx = new Primary_expression_startContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_primary_expression_start); + int _la; + try { + int _alt; + setState(916); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 73, _ctx)) { + case 1: + _localctx = new LiteralExpressionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(795); + literal(); + } + break; + case 2: + _localctx = new SimpleNameExpressionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(796); + identifier(); + setState(798); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 58, _ctx)) { + case 1: { + setState(797); + type_argument_list(); + } + break; + } + } + break; + case 3: + _localctx = new ParenthesisExpressionsContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(800); + match(OPEN_PARENS); + setState(801); + expression(); + setState(802); + match(CLOSE_PARENS); + } + break; + case 4: + _localctx = new MemberAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(804); + predefined_type(); + } + break; + case 5: + _localctx = new MemberAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(805); + qualified_alias_member(); + } + break; + case 6: + _localctx = new LiteralAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(806); + match(LITERAL_ACCESS); + } + break; + case 7: + _localctx = new ThisReferenceExpressionContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(807); + match(THIS); + } + break; + case 8: + _localctx = new BaseAccessExpressionContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(808); + match(BASE); + setState(818); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: { + setState(809); + match(DOT); + setState(810); + identifier(); + setState(812); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 59, _ctx)) { + case 1: { + setState(811); + type_argument_list(); + } + break; + } + } + break; + case OPEN_BRACKET: { + setState(814); + match(OPEN_BRACKET); + setState(815); + expression_list(); + setState(816); + match(CLOSE_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 9: + _localctx = new ObjectCreationExpressionContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(820); + match(NEW); + setState(849); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: { + setState(821); + type_(); + setState(843); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 64, _ctx)) { + case 1: { + setState(822); + object_creation_expression(); + } + break; + case 2: { + setState(823); + object_or_collection_initializer(); + } + break; + case 3: { + setState(824); + match(OPEN_BRACKET); + setState(825); + expression_list(); + setState(826); + match(CLOSE_BRACKET); + setState(830); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 61, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(827); + rank_specifier(); + } + } + } + setState(832); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 61, _ctx); + } + setState(834); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACE) { + { + setState(833); + array_initializer(); + } + } + + } + break; + case 4: { + setState(837); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(836); + rank_specifier(); + } + } + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == OPEN_BRACKET); + setState(841); + array_initializer(); + } + break; + } + } + break; + case OPEN_BRACE: { + setState(845); + anonymous_object_initializer(); + } + break; + case OPEN_BRACKET: { + setState(846); + rank_specifier(); + setState(847); + array_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 10: + _localctx = new TupleExpressionContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(851); + match(OPEN_PARENS); + setState(852); + argument(); + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(853); + match(COMMA); + setState(854); + argument(); + } + } + setState(857); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == COMMA); + setState(859); + match(CLOSE_PARENS); + } + break; + case 11: + _localctx = new TypeofExpressionContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(861); + match(TYPEOF); + setState(862); + match(OPEN_PARENS); + setState(866); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 67, _ctx)) { + case 1: { + setState(863); + unbound_type_name(); + } + break; + case 2: { + setState(864); + type_(); + } + break; + case 3: { + setState(865); + match(VOID); + } + break; + } + setState(868); + match(CLOSE_PARENS); + } + break; + case 12: + _localctx = new CheckedExpressionContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(869); + match(CHECKED); + setState(870); + match(OPEN_PARENS); + setState(871); + expression(); + setState(872); + match(CLOSE_PARENS); + } + break; + case 13: + _localctx = new UncheckedExpressionContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(874); + match(UNCHECKED); + setState(875); + match(OPEN_PARENS); + setState(876); + expression(); + setState(877); + match(CLOSE_PARENS); + } + break; + case 14: + _localctx = new DefaultValueExpressionContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(879); + match(DEFAULT); + setState(884); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 68, _ctx)) { + case 1: { + setState(880); + match(OPEN_PARENS); + setState(881); + type_(); + setState(882); + match(CLOSE_PARENS); + } + break; + } + } + break; + case 15: + _localctx = new AnonymousMethodExpressionContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(887); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASYNC) { + { + setState(886); + match(ASYNC); + } + } + + setState(889); + match(DELEGATE); + setState(895); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_PARENS) { + { + setState(890); + match(OPEN_PARENS); + setState(892); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & 18015337681329505L) != 0)) { + { + setState(891); + explicit_anonymous_function_parameter_list(); + } + } + + setState(894); + match(CLOSE_PARENS); + } + } + + setState(897); + block(); + } + break; + case 16: + _localctx = new SizeofExpressionContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(898); + match(SIZEOF); + setState(899); + match(OPEN_PARENS); + setState(900); + type_(); + setState(901); + match(CLOSE_PARENS); + } + break; + case 17: + _localctx = new NameofExpressionContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(903); + match(NAMEOF); + setState(904); + match(OPEN_PARENS); + setState(910); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 72, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(905); + identifier(); + setState(906); + match(DOT); + } + } + } + setState(912); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 72, _ctx); + } + setState(913); + identifier(); + setState(914); + match(CLOSE_PARENS); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Throwable_expressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Throw_expressionContext throw_expression() { + return getRuleContext(Throw_expressionContext.class, 0); + } + + public Throwable_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_throwable_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterThrowable_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitThrowable_expression(this); + } + } + + public final Throwable_expressionContext throwable_expression() throws RecognitionException { + Throwable_expressionContext _localctx = new Throwable_expressionContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_throwable_expression); + try { + setState(920); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(918); + expression(); + } + break; + case THROW: + enterOuterAlt(_localctx, 2); + { + setState(919); + throw_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Throw_expressionContext extends ParserRuleContext { + public TerminalNode THROW() { + return getToken(CSharpParser.THROW, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Throw_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_throw_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterThrow_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitThrow_expression(this); + } + } + + public final Throw_expressionContext throw_expression() throws RecognitionException { + Throw_expressionContext _localctx = new Throw_expressionContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_throw_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(922); + match(THROW); + setState(923); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_accessContext extends ParserRuleContext { + public TerminalNode DOT() { + return getToken(CSharpParser.DOT, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode INTERR() { + return getToken(CSharpParser.INTERR, 0); + } + + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class, 0); + } + + public Member_accessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_access; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterMember_access(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitMember_access(this); + } + } + + public final Member_accessContext member_access() throws RecognitionException { + Member_accessContext _localctx = new Member_accessContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_member_access); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(926); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == INTERR) { + { + setState(925); + match(INTERR); + } + } + + setState(928); + match(DOT); + setState(929); + identifier(); + setState(931); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 76, _ctx)) { + case 1: { + setState(930); + type_argument_list(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Bracket_expressionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public List indexer_argument() { + return getRuleContexts(Indexer_argumentContext.class); + } + + public Indexer_argumentContext indexer_argument(int i) { + return getRuleContext(Indexer_argumentContext.class, i); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public TerminalNode INTERR() { + return getToken(CSharpParser.INTERR, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Bracket_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_bracket_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterBracket_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitBracket_expression(this); + } + } + + public final Bracket_expressionContext bracket_expression() throws RecognitionException { + Bracket_expressionContext _localctx = new Bracket_expressionContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_bracket_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(934); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == INTERR) { + { + setState(933); + match(INTERR); + } + } + + setState(936); + match(OPEN_BRACKET); + setState(937); + indexer_argument(); + setState(942); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(938); + match(COMMA); + setState(939); + indexer_argument(); + } + } + setState(944); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(945); + match(CLOSE_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Indexer_argumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Indexer_argumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_indexer_argument; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIndexer_argument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIndexer_argument(this); + } + } + + public final Indexer_argumentContext indexer_argument() throws RecognitionException { + Indexer_argumentContext _localctx = new Indexer_argumentContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_indexer_argument); + try { + enterOuterAlt(_localctx, 1); + { + setState(950); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 79, _ctx)) { + case 1: { + setState(947); + identifier(); + setState(948); + match(COLON); + } + break; + } + setState(952); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Predefined_typeContext extends ParserRuleContext { + public TerminalNode BOOL() { + return getToken(CSharpParser.BOOL, 0); + } + + public TerminalNode BYTE() { + return getToken(CSharpParser.BYTE, 0); + } + + public TerminalNode CHAR() { + return getToken(CSharpParser.CHAR, 0); + } + + public TerminalNode DECIMAL() { + return getToken(CSharpParser.DECIMAL, 0); + } + + public TerminalNode DOUBLE() { + return getToken(CSharpParser.DOUBLE, 0); + } + + public TerminalNode FLOAT() { + return getToken(CSharpParser.FLOAT, 0); + } + + public TerminalNode INT() { + return getToken(CSharpParser.INT, 0); + } + + public TerminalNode LONG() { + return getToken(CSharpParser.LONG, 0); + } + + public TerminalNode OBJECT() { + return getToken(CSharpParser.OBJECT, 0); + } + + public TerminalNode SBYTE() { + return getToken(CSharpParser.SBYTE, 0); + } + + public TerminalNode SHORT() { + return getToken(CSharpParser.SHORT, 0); + } + + public TerminalNode STRING() { + return getToken(CSharpParser.STRING, 0); + } + + public TerminalNode UINT() { + return getToken(CSharpParser.UINT, 0); + } + + public TerminalNode ULONG() { + return getToken(CSharpParser.ULONG, 0); + } + + public TerminalNode USHORT() { + return getToken(CSharpParser.USHORT, 0); + } + + public Predefined_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_predefined_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterPredefined_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitPredefined_type(this); + } + } + + public final Predefined_typeContext predefined_type() throws RecognitionException { + Predefined_typeContext _localctx = new Predefined_typeContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_predefined_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(954); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & -9187308037727846400L) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 75170873345L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Expression_listContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Expression_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_expression_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterExpression_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitExpression_list(this); + } + } + + public final Expression_listContext expression_list() throws RecognitionException { + Expression_listContext _localctx = new Expression_listContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_expression_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(956); + expression(); + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(957); + match(COMMA); + setState(958); + expression(); + } + } + setState(963); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_or_collection_initializerContext extends ParserRuleContext { + public Object_initializerContext object_initializer() { + return getRuleContext(Object_initializerContext.class, 0); + } + + public Collection_initializerContext collection_initializer() { + return getRuleContext(Collection_initializerContext.class, 0); + } + + public Object_or_collection_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_object_or_collection_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterObject_or_collection_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitObject_or_collection_initializer(this); + } + } + + public final Object_or_collection_initializerContext object_or_collection_initializer() throws RecognitionException { + Object_or_collection_initializerContext _localctx = new Object_or_collection_initializerContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_object_or_collection_initializer); + try { + setState(966); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 81, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(964); + object_initializer(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(965); + collection_initializer(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Member_initializer_listContext member_initializer_list() { + return getRuleContext(Member_initializer_listContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Object_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_object_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterObject_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitObject_initializer(this); + } + } + + public final Object_initializerContext object_initializer() throws RecognitionException { + Object_initializerContext _localctx = new Object_initializerContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_object_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(968); + match(OPEN_BRACE); + setState(973); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -9221467407831136095L) != 0)) { + { + setState(969); + member_initializer_list(); + setState(971); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(970); + match(COMMA); + } + } + + } + } + + setState(975); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_initializer_listContext extends ParserRuleContext { + public List member_initializer() { + return getRuleContexts(Member_initializerContext.class); + } + + public Member_initializerContext member_initializer(int i) { + return getRuleContext(Member_initializerContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Member_initializer_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_initializer_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMember_initializer_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMember_initializer_list(this); + } + } + + public final Member_initializer_listContext member_initializer_list() throws RecognitionException { + Member_initializer_listContext _localctx = new Member_initializer_listContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_member_initializer_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(977); + member_initializer(); + setState(982); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 84, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(978); + match(COMMA); + setState(979); + member_initializer(); + } + } + } + setState(984); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 84, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_initializerContext extends ParserRuleContext { + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Initializer_valueContext initializer_value() { + return getRuleContext(Initializer_valueContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public Member_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMember_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMember_initializer(this); + } + } + + public final Member_initializerContext member_initializer() throws RecognitionException { + Member_initializerContext _localctx = new Member_initializerContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_member_initializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(990); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: { + setState(985); + identifier(); + } + break; + case OPEN_BRACKET: { + setState(986); + match(OPEN_BRACKET); + setState(987); + expression(); + setState(988); + match(CLOSE_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + setState(992); + match(ASSIGNMENT); + setState(993); + initializer_value(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Initializer_valueContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class, 0); + } + + public Initializer_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_initializer_value; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInitializer_value(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitInitializer_value(this); + } + } + + public final Initializer_valueContext initializer_value() throws RecognitionException { + Initializer_valueContext _localctx = new Initializer_valueContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_initializer_value); + try { + setState(997); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(995); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(996); + object_or_collection_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Collection_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public List element_initializer() { + return getRuleContexts(Element_initializerContext.class); + } + + public Element_initializerContext element_initializer(int i) { + return getRuleContext(Element_initializerContext.class, i); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Collection_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_collection_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterCollection_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitCollection_initializer(this); + } + } + + public final Collection_initializerContext collection_initializer() throws RecognitionException { + Collection_initializerContext _localctx = new Collection_initializerContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_collection_initializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(999); + match(OPEN_BRACE); + setState(1000); + element_initializer(); + setState(1005); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 87, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1001); + match(COMMA); + setState(1002); + element_initializer(); + } + } + } + setState(1007); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 87, _ctx); + } + setState(1009); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1008); + match(COMMA); + } + } + + setState(1011); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Element_initializerContext extends ParserRuleContext { + public Non_assignment_expressionContext non_assignment_expression() { + return getRuleContext(Non_assignment_expressionContext.class, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Element_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_element_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterElement_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitElement_initializer(this); + } + } + + public final Element_initializerContext element_initializer() throws RecognitionException { + Element_initializerContext _localctx = new Element_initializerContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_element_initializer); + try { + setState(1018); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1013); + non_assignment_expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1014); + match(OPEN_BRACE); + setState(1015); + expression_list(); + setState(1016); + match(CLOSE_BRACE); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Anonymous_object_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Member_declarator_listContext member_declarator_list() { + return getRuleContext(Member_declarator_listContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Anonymous_object_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_anonymous_object_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAnonymous_object_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAnonymous_object_initializer(this); + } + } + + public final Anonymous_object_initializerContext anonymous_object_initializer() throws RecognitionException { + Anonymous_object_initializerContext _localctx = new Anonymous_object_initializerContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_anonymous_object_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1020); + match(OPEN_BRACE); + setState(1025); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 3417425939254529527L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & 19140129564736833L) != 0)) { + { + setState(1021); + member_declarator_list(); + setState(1023); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1022); + match(COMMA); + } + } + + } + } + + setState(1027); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_declarator_listContext extends ParserRuleContext { + public List member_declarator() { + return getRuleContexts(Member_declaratorContext.class); + } + + public Member_declaratorContext member_declarator(int i) { + return getRuleContext(Member_declaratorContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Member_declarator_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_declarator_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMember_declarator_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMember_declarator_list(this); + } + } + + public final Member_declarator_listContext member_declarator_list() throws RecognitionException { + Member_declarator_listContext _localctx = new Member_declarator_listContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_member_declarator_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1029); + member_declarator(); + setState(1034); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 92, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1030); + match(COMMA); + setState(1031); + member_declarator(); + } + } + } + setState(1036); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 92, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_declaratorContext extends ParserRuleContext { + public Primary_expressionContext primary_expression() { + return getRuleContext(Primary_expressionContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Member_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMember_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitMember_declarator(this); + } + } + + public final Member_declaratorContext member_declarator() throws RecognitionException { + Member_declaratorContext _localctx = new Member_declaratorContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_member_declarator); + try { + setState(1042); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 93, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1037); + primary_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1038); + identifier(); + setState(1039); + match(ASSIGNMENT); + setState(1040); + expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unbound_type_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public TerminalNode DOUBLE_COLON() { + return getToken(CSharpParser.DOUBLE_COLON, 0); + } + + public List DOT() { + return getTokens(CSharpParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + + public List generic_dimension_specifier() { + return getRuleContexts(Generic_dimension_specifierContext.class); + } + + public Generic_dimension_specifierContext generic_dimension_specifier(int i) { + return getRuleContext(Generic_dimension_specifierContext.class, i); + } + + public Unbound_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_unbound_type_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUnbound_type_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitUnbound_type_name(this); + } + } + + public final Unbound_type_nameContext unbound_type_name() throws RecognitionException { + Unbound_type_nameContext _localctx = new Unbound_type_nameContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_unbound_type_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1044); + identifier(); + setState(1053); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLOSE_PARENS: + case DOT: + case LT: { + setState(1046); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1045); + generic_dimension_specifier(); + } + } + + } + break; + case DOUBLE_COLON: { + setState(1048); + match(DOUBLE_COLON); + setState(1049); + identifier(); + setState(1051); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1050); + generic_dimension_specifier(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(1062); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == DOT) { + { + { + setState(1055); + match(DOT); + setState(1056); + identifier(); + setState(1058); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1057); + generic_dimension_specifier(); + } + } + + } + } + setState(1064); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_dimension_specifierContext extends ParserRuleContext { + public TerminalNode LT() { + return getToken(CSharpParser.LT, 0); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Generic_dimension_specifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_generic_dimension_specifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterGeneric_dimension_specifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitGeneric_dimension_specifier(this); + } + } + + public final Generic_dimension_specifierContext generic_dimension_specifier() throws RecognitionException { + Generic_dimension_specifierContext _localctx = new Generic_dimension_specifierContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_generic_dimension_specifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1065); + match(LT); + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1066); + match(COMMA); + } + } + setState(1071); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1072); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IsTypeContext extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class, 0); + } + + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class, i); + } + + public List STAR() { + return getTokens(CSharpParser.STAR); + } + + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + + public TerminalNode INTERR() { + return getToken(CSharpParser.INTERR, 0); + } + + public IsTypePatternArmsContext isTypePatternArms() { + return getRuleContext(IsTypePatternArmsContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public IsTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_isType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIsType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIsType(this); + } + } + + public final IsTypeContext isType() throws RecognitionException { + IsTypeContext _localctx = new IsTypeContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_isType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1074); + base_type(); + setState(1079); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 101, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + setState(1077); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACKET: { + setState(1075); + rank_specifier(); + } + break; + case STAR: { + setState(1076); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(1081); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 101, _ctx); + } + setState(1083); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 102, _ctx)) { + case 1: { + setState(1082); + match(INTERR); + } + break; + } + setState(1086); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACE) { + { + setState(1085); + isTypePatternArms(); + } + } + + setState(1089); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 104, _ctx)) { + case 1: { + setState(1088); + identifier(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IsTypePatternArmsContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public List isTypePatternArm() { + return getRuleContexts(IsTypePatternArmContext.class); + } + + public IsTypePatternArmContext isTypePatternArm(int i) { + return getRuleContext(IsTypePatternArmContext.class, i); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public IsTypePatternArmsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_isTypePatternArms; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterIsTypePatternArms(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIsTypePatternArms(this); + } + } + + public final IsTypePatternArmsContext isTypePatternArms() throws RecognitionException { + IsTypePatternArmsContext _localctx = new IsTypePatternArmsContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_isTypePatternArms); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1091); + match(OPEN_BRACE); + setState(1092); + isTypePatternArm(); + setState(1097); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1093); + match(COMMA); + setState(1094); + isTypePatternArm(); + } + } + setState(1099); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1100); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IsTypePatternArmContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public IsTypePatternArmContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_isTypePatternArm; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIsTypePatternArm(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIsTypePatternArm(this); + } + } + + public final IsTypePatternArmContext isTypePatternArm() throws RecognitionException { + IsTypePatternArmContext _localctx = new IsTypePatternArmContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_isTypePatternArm); + try { + enterOuterAlt(_localctx, 1); + { + setState(1102); + identifier(); + setState(1103); + match(COLON); + setState(1104); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_expressionContext extends ParserRuleContext { + public Anonymous_function_signatureContext anonymous_function_signature() { + return getRuleContext(Anonymous_function_signatureContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Anonymous_function_bodyContext anonymous_function_body() { + return getRuleContext(Anonymous_function_bodyContext.class, 0); + } + + public TerminalNode ASYNC() { + return getToken(CSharpParser.ASYNC, 0); + } + + public Lambda_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLambda_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLambda_expression(this); + } + } + + public final Lambda_expressionContext lambda_expression() throws RecognitionException { + Lambda_expressionContext _localctx = new Lambda_expressionContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_lambda_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1107); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 106, _ctx)) { + case 1: { + setState(1106); + match(ASYNC); + } + break; + } + setState(1109); + anonymous_function_signature(); + setState(1110); + right_arrow(); + setState(1111); + anonymous_function_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Anonymous_function_signatureContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { + return getRuleContext(Explicit_anonymous_function_parameter_listContext.class, 0); + } + + public Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() { + return getRuleContext(Implicit_anonymous_function_parameter_listContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Anonymous_function_signatureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_anonymous_function_signature; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAnonymous_function_signature(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAnonymous_function_signature(this); + } + } + + public final Anonymous_function_signatureContext anonymous_function_signature() throws RecognitionException { + Anonymous_function_signatureContext _localctx = new Anonymous_function_signatureContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_anonymous_function_signature); + try { + setState(1124); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 107, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1113); + match(OPEN_PARENS); + setState(1114); + match(CLOSE_PARENS); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1115); + match(OPEN_PARENS); + setState(1116); + explicit_anonymous_function_parameter_list(); + setState(1117); + match(CLOSE_PARENS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1119); + match(OPEN_PARENS); + setState(1120); + implicit_anonymous_function_parameter_list(); + setState(1121); + match(CLOSE_PARENS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1123); + identifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explicit_anonymous_function_parameter_listContext extends ParserRuleContext { + public List explicit_anonymous_function_parameter() { + return getRuleContexts(Explicit_anonymous_function_parameterContext.class); + } + + public Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter(int i) { + return getRuleContext(Explicit_anonymous_function_parameterContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Explicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_explicit_anonymous_function_parameter_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExplicit_anonymous_function_parameter_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExplicit_anonymous_function_parameter_list(this); + } + } + + public final Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() throws RecognitionException { + Explicit_anonymous_function_parameter_listContext _localctx = new Explicit_anonymous_function_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_explicit_anonymous_function_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1126); + explicit_anonymous_function_parameter(); + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1127); + match(COMMA); + setState(1128); + explicit_anonymous_function_parameter(); + } + } + setState(1133); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explicit_anonymous_function_parameterContext extends ParserRuleContext { + public Token refout; + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode OUT() { + return getToken(CSharpParser.OUT, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public Explicit_anonymous_function_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_explicit_anonymous_function_parameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExplicit_anonymous_function_parameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExplicit_anonymous_function_parameter(this); + } + } + + public final Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter() throws RecognitionException { + Explicit_anonymous_function_parameterContext _localctx = new Explicit_anonymous_function_parameterContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_explicit_anonymous_function_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1135); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 67371009L) != 0)) { + { + setState(1134); + ((Explicit_anonymous_function_parameterContext) _localctx).refout = _input.LT(1); + _la = _input.LA(1); + if (!(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 67371009L) != 0))) { + ((Explicit_anonymous_function_parameterContext) _localctx).refout = (Token) _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1137); + type_(); + setState(1138); + identifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Implicit_anonymous_function_parameter_listContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Implicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_implicit_anonymous_function_parameter_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterImplicit_anonymous_function_parameter_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitImplicit_anonymous_function_parameter_list(this); + } + } + + public final Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() throws RecognitionException { + Implicit_anonymous_function_parameter_listContext _localctx = new Implicit_anonymous_function_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_implicit_anonymous_function_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1140); + identifier(); + setState(1145); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1141); + match(COMMA); + setState(1142); + identifier(); + } + } + setState(1147); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Anonymous_function_bodyContext extends ParserRuleContext { + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Anonymous_function_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_anonymous_function_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAnonymous_function_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAnonymous_function_body(this); + } + } + + public final Anonymous_function_bodyContext anonymous_function_body() throws RecognitionException { + Anonymous_function_bodyContext _localctx = new Anonymous_function_bodyContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_anonymous_function_body); + try { + setState(1150); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case THROW: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1148); + throwable_expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1149); + block(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Query_expressionContext extends ParserRuleContext { + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class, 0); + } + + public Query_bodyContext query_body() { + return getRuleContext(Query_bodyContext.class, 0); + } + + public Query_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_query_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterQuery_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitQuery_expression(this); + } + } + + public final Query_expressionContext query_expression() throws RecognitionException { + Query_expressionContext _localctx = new Query_expressionContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_query_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1152); + from_clause(); + setState(1153); + query_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class From_clauseContext extends ParserRuleContext { + public TerminalNode FROM() { + return getToken(CSharpParser.FROM, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public From_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_from_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFrom_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFrom_clause(this); + } + } + + public final From_clauseContext from_clause() throws RecognitionException { + From_clauseContext _localctx = new From_clauseContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_from_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1155); + match(FROM); + setState(1157); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 112, _ctx)) { + case 1: { + setState(1156); + type_(); + } + break; + } + setState(1159); + identifier(); + setState(1160); + match(IN); + setState(1161); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Query_bodyContext extends ParserRuleContext { + public Select_or_group_clauseContext select_or_group_clause() { + return getRuleContext(Select_or_group_clauseContext.class, 0); + } + + public List query_body_clause() { + return getRuleContexts(Query_body_clauseContext.class); + } + + public Query_body_clauseContext query_body_clause(int i) { + return getRuleContext(Query_body_clauseContext.class, i); + } + + public Query_continuationContext query_continuation() { + return getRuleContext(Query_continuationContext.class, 0); + } + + public Query_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_query_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterQuery_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitQuery_body(this); + } + } + + public final Query_bodyContext query_body() throws RecognitionException { + Query_bodyContext _localctx = new Query_bodyContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_query_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1166); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 48)) & ~0x3f) == 0 && ((1L << (_la - 48)) & -9223372036846374911L) != 0)) { + { + { + setState(1163); + query_body_clause(); + } + } + setState(1168); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1169); + select_or_group_clause(); + setState(1171); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 114, _ctx)) { + case 1: { + setState(1170); + query_continuation(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Query_body_clauseContext extends ParserRuleContext { + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class, 0); + } + + public Let_clauseContext let_clause() { + return getRuleContext(Let_clauseContext.class, 0); + } + + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class, 0); + } + + public Combined_join_clauseContext combined_join_clause() { + return getRuleContext(Combined_join_clauseContext.class, 0); + } + + public Orderby_clauseContext orderby_clause() { + return getRuleContext(Orderby_clauseContext.class, 0); + } + + public Query_body_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_query_body_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterQuery_body_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitQuery_body_clause(this); + } + } + + public final Query_body_clauseContext query_body_clause() throws RecognitionException { + Query_body_clauseContext _localctx = new Query_body_clauseContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_query_body_clause); + try { + setState(1178); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + enterOuterAlt(_localctx, 1); + { + setState(1173); + from_clause(); + } + break; + case LET: + enterOuterAlt(_localctx, 2); + { + setState(1174); + let_clause(); + } + break; + case WHERE: + enterOuterAlt(_localctx, 3); + { + setState(1175); + where_clause(); + } + break; + case JOIN: + enterOuterAlt(_localctx, 4); + { + setState(1176); + combined_join_clause(); + } + break; + case ORDERBY: + enterOuterAlt(_localctx, 5); + { + setState(1177); + orderby_clause(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Let_clauseContext extends ParserRuleContext { + public TerminalNode LET() { + return getToken(CSharpParser.LET, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Let_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_let_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterLet_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLet_clause(this); + } + } + + public final Let_clauseContext let_clause() throws RecognitionException { + Let_clauseContext _localctx = new Let_clauseContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_let_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1180); + match(LET); + setState(1181); + identifier(); + setState(1182); + match(ASSIGNMENT); + setState(1183); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Where_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { + return getToken(CSharpParser.WHERE, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Where_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_where_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterWhere_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitWhere_clause(this); + } + } + + public final Where_clauseContext where_clause() throws RecognitionException { + Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_where_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1185); + match(WHERE); + setState(1186); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Combined_join_clauseContext extends ParserRuleContext { + public TerminalNode JOIN() { + return getToken(CSharpParser.JOIN, 0); + } + + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode ON() { + return getToken(CSharpParser.ON, 0); + } + + public TerminalNode EQUALS() { + return getToken(CSharpParser.EQUALS, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode INTO() { + return getToken(CSharpParser.INTO, 0); + } + + public Combined_join_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_combined_join_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterCombined_join_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitCombined_join_clause(this); + } + } + + public final Combined_join_clauseContext combined_join_clause() throws RecognitionException { + Combined_join_clauseContext _localctx = new Combined_join_clauseContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_combined_join_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1188); + match(JOIN); + setState(1190); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 116, _ctx)) { + case 1: { + setState(1189); + type_(); + } + break; + } + setState(1192); + identifier(); + setState(1193); + match(IN); + setState(1194); + expression(); + setState(1195); + match(ON); + setState(1196); + expression(); + setState(1197); + match(EQUALS); + setState(1198); + expression(); + setState(1201); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == INTO) { + { + setState(1199); + match(INTO); + setState(1200); + identifier(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Orderby_clauseContext extends ParserRuleContext { + public TerminalNode ORDERBY() { + return getToken(CSharpParser.ORDERBY, 0); + } + + public List ordering() { + return getRuleContexts(OrderingContext.class); + } + + public OrderingContext ordering(int i) { + return getRuleContext(OrderingContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Orderby_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_orderby_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterOrderby_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitOrderby_clause(this); + } + } + + public final Orderby_clauseContext orderby_clause() throws RecognitionException { + Orderby_clauseContext _localctx = new Orderby_clauseContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_orderby_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1203); + match(ORDERBY); + setState(1204); + ordering(); + setState(1209); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1205); + match(COMMA); + setState(1206); + ordering(); + } + } + setState(1211); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OrderingContext extends ParserRuleContext { + public Token dir; + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode ASCENDING() { + return getToken(CSharpParser.ASCENDING, 0); + } + + public TerminalNode DESCENDING() { + return getToken(CSharpParser.DESCENDING, 0); + } + + public OrderingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_ordering; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterOrdering(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitOrdering(this); + } + } + + public final OrderingContext ordering() throws RecognitionException { + OrderingContext _localctx = new OrderingContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_ordering); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1212); + expression(); + setState(1214); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASCENDING || _la == DESCENDING) { + { + setState(1213); + ((OrderingContext) _localctx).dir = _input.LT(1); + _la = _input.LA(1); + if (!(_la == ASCENDING || _la == DESCENDING)) { + ((OrderingContext) _localctx).dir = (Token) _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_or_group_clauseContext extends ParserRuleContext { + public TerminalNode SELECT() { + return getToken(CSharpParser.SELECT, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode GROUP() { + return getToken(CSharpParser.GROUP, 0); + } + + public TerminalNode BY() { + return getToken(CSharpParser.BY, 0); + } + + public Select_or_group_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_select_or_group_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSelect_or_group_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSelect_or_group_clause(this); + } + } + + public final Select_or_group_clauseContext select_or_group_clause() throws RecognitionException { + Select_or_group_clauseContext _localctx = new Select_or_group_clauseContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_select_or_group_clause); + try { + setState(1223); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + enterOuterAlt(_localctx, 1); + { + setState(1216); + match(SELECT); + setState(1217); + expression(); + } + break; + case GROUP: + enterOuterAlt(_localctx, 2); + { + setState(1218); + match(GROUP); + setState(1219); + expression(); + setState(1220); + match(BY); + setState(1221); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Query_continuationContext extends ParserRuleContext { + public TerminalNode INTO() { + return getToken(CSharpParser.INTO, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Query_bodyContext query_body() { + return getRuleContext(Query_bodyContext.class, 0); + } + + public Query_continuationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_query_continuation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterQuery_continuation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitQuery_continuation(this); + } + } + + public final Query_continuationContext query_continuation() throws RecognitionException { + Query_continuationContext _localctx = new Query_continuationContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_query_continuation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1225); + match(INTO); + setState(1226); + identifier(); + setState(1227); + query_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementContext extends ParserRuleContext { + public Labeled_StatementContext labeled_Statement() { + return getRuleContext(Labeled_StatementContext.class, 0); + } + + public DeclarationStatementContext declarationStatement() { + return getRuleContext(DeclarationStatementContext.class, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitStatement(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_statement); + try { + setState(1232); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 121, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1229); + labeled_Statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1230); + declarationStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1231); + embedded_statement(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclarationStatementContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Local_constant_declarationContext local_constant_declaration() { + return getRuleContext(Local_constant_declarationContext.class, 0); + } + + public Local_function_declarationContext local_function_declaration() { + return getRuleContext(Local_function_declarationContext.class, 0); + } + + public DeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_declarationStatement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterDeclarationStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitDeclarationStatement(this); + } + } + + public final DeclarationStatementContext declarationStatement() throws RecognitionException { + DeclarationStatementContext _localctx = new DeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_declarationStatement); + try { + setState(1241); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 122, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1234); + local_variable_declaration(); + setState(1235); + match(SEMICOLON); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1237); + local_constant_declaration(); + setState(1238); + match(SEMICOLON); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1240); + local_function_declaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_function_declarationContext extends ParserRuleContext { + public Local_function_headerContext local_function_header() { + return getRuleContext(Local_function_headerContext.class, 0); + } + + public Local_function_bodyContext local_function_body() { + return getRuleContext(Local_function_bodyContext.class, 0); + } + + public Local_function_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_function_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_function_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_function_declaration(this); + } + } + + public final Local_function_declarationContext local_function_declaration() throws RecognitionException { + Local_function_declarationContext _localctx = new Local_function_declarationContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_local_function_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1243); + local_function_header(); + setState(1244); + local_function_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_function_headerContext extends ParserRuleContext { + public Return_typeContext return_type() { + return getRuleContext(Return_typeContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Local_function_modifiersContext local_function_modifiers() { + return getRuleContext(Local_function_modifiersContext.class, 0); + } + + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public Local_function_headerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_function_header; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_function_header(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_function_header(this); + } + } + + public final Local_function_headerContext local_function_header() throws RecognitionException { + Local_function_headerContext _localctx = new Local_function_headerContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_local_function_header); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1247); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 123, _ctx)) { + case 1: { + setState(1246); + local_function_modifiers(); + } + break; + } + setState(1249); + return_type(); + setState(1250); + identifier(); + setState(1252); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1251); + type_parameter_list(); + } + } + + setState(1254); + match(OPEN_PARENS); + setState(1256); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(1255); + formal_parameter_list(); + } + } + + setState(1258); + match(CLOSE_PARENS); + setState(1260); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(1259); + type_parameter_constraints_clauses(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_function_modifiersContext extends ParserRuleContext { + public TerminalNode ASYNC() { + return getToken(CSharpParser.ASYNC, 0); + } + + public TerminalNode UNSAFE() { + return getToken(CSharpParser.UNSAFE, 0); + } + + public TerminalNode STATIC() { + return getToken(CSharpParser.STATIC, 0); + } + + public Local_function_modifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_function_modifiers; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_function_modifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_function_modifiers(this); + } + } + + public final Local_function_modifiersContext local_function_modifiers() throws RecognitionException { + Local_function_modifiersContext _localctx = new Local_function_modifiersContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_local_function_modifiers); + int _la; + try { + setState(1268); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASYNC: + case UNSAFE: + enterOuterAlt(_localctx, 1); + { + setState(1262); + _la = _input.LA(1); + if (!(_la == ASYNC || _la == UNSAFE)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1264); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STATIC) { + { + setState(1263); + match(STATIC); + } + } + + } + break; + case STATIC: + enterOuterAlt(_localctx, 2); + { + setState(1266); + match(STATIC); + setState(1267); + _la = _input.LA(1); + if (!(_la == ASYNC || _la == UNSAFE)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_function_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Local_function_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_function_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_function_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_function_body(this); + } + } + + public final Local_function_bodyContext local_function_body() throws RecognitionException { + Local_function_bodyContext _localctx = new Local_function_bodyContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_local_function_body); + try { + setState(1275); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1270); + block(); + } + break; + case ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(1271); + right_arrow(); + setState(1272); + throwable_expression(); + setState(1273); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Labeled_StatementContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public StatementContext statement() { + return getRuleContext(StatementContext.class, 0); + } + + public Labeled_StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_labeled_Statement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLabeled_Statement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLabeled_Statement(this); + } + } + + public final Labeled_StatementContext labeled_Statement() throws RecognitionException { + Labeled_StatementContext _localctx = new Labeled_StatementContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_labeled_Statement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1277); + identifier(); + setState(1278); + match(COLON); + setState(1279); + statement(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Embedded_statementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Simple_embedded_statementContext simple_embedded_statement() { + return getRuleContext(Simple_embedded_statementContext.class, 0); + } + + public Embedded_statementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_embedded_statement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterEmbedded_statement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitEmbedded_statement(this); + } + } + + public final Embedded_statementContext embedded_statement() throws RecognitionException { + Embedded_statementContext _localctx = new Embedded_statementContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_embedded_statement); + try { + setState(1283); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1281); + block(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BREAK: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case CONTINUE: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DO: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FIXED: + case FLOAT: + case FOR: + case FOREACH: + case FROM: + case GET: + case GOTO: + case GROUP: + case IF: + case INT: + case INTO: + case JOIN: + case LET: + case LOCK: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case RETURN: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case SWITCH: + case THIS: + case THROW: + case TRUE: + case TRY: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case UNSAFE: + case USHORT: + case USING: + case VAR: + case WHEN: + case WHERE: + case WHILE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case SEMICOLON: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 2); + { + setState(1282); + simple_embedded_statement(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_embedded_statementContext extends ParserRuleContext { + public Simple_embedded_statementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simple_embedded_statement; + } + + public Simple_embedded_statementContext() { + } + + public void copyFrom(Simple_embedded_statementContext ctx) { + super.copyFrom(ctx); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class TryStatementContext extends Simple_embedded_statementContext { + public TerminalNode TRY() { + return getToken(CSharpParser.TRY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Catch_clausesContext catch_clauses() { + return getRuleContext(Catch_clausesContext.class, 0); + } + + public Finally_clauseContext finally_clause() { + return getRuleContext(Finally_clauseContext.class, 0); + } + + public TryStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterTryStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTryStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class CheckedStatementContext extends Simple_embedded_statementContext { + public TerminalNode CHECKED() { + return getToken(CSharpParser.CHECKED, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public CheckedStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterCheckedStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitCheckedStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ThrowStatementContext extends Simple_embedded_statementContext { + public TerminalNode THROW() { + return getToken(CSharpParser.THROW, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public ThrowStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterThrowStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitThrowStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class TheEmptyStatementContext extends Simple_embedded_statementContext { + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public TheEmptyStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterTheEmptyStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitTheEmptyStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UnsafeStatementContext extends Simple_embedded_statementContext { + public TerminalNode UNSAFE() { + return getToken(CSharpParser.UNSAFE, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public UnsafeStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterUnsafeStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitUnsafeStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ForStatementContext extends Simple_embedded_statementContext { + public TerminalNode FOR() { + return getToken(CSharpParser.FOR, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public List SEMICOLON() { + return getTokens(CSharpParser.SEMICOLON); + } + + public TerminalNode SEMICOLON(int i) { + return getToken(CSharpParser.SEMICOLON, i); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public For_initializerContext for_initializer() { + return getRuleContext(For_initializerContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public For_iteratorContext for_iterator() { + return getRuleContext(For_iteratorContext.class, 0); + } + + public ForStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterForStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitForStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class BreakStatementContext extends Simple_embedded_statementContext { + public TerminalNode BREAK() { + return getToken(CSharpParser.BREAK, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public BreakStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterBreakStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitBreakStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class IfStatementContext extends Simple_embedded_statementContext { + public TerminalNode IF() { + return getToken(CSharpParser.IF, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public List if_body() { + return getRuleContexts(If_bodyContext.class); + } + + public If_bodyContext if_body(int i) { + return getRuleContext(If_bodyContext.class, i); + } + + public TerminalNode ELSE() { + return getToken(CSharpParser.ELSE, 0); + } + + public IfStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIfStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIfStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ReturnStatementContext extends Simple_embedded_statementContext { + public TerminalNode RETURN() { + return getToken(CSharpParser.RETURN, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public ReturnStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterReturnStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitReturnStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class GotoStatementContext extends Simple_embedded_statementContext { + public TerminalNode GOTO() { + return getToken(CSharpParser.GOTO, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode CASE() { + return getToken(CSharpParser.CASE, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode DEFAULT() { + return getToken(CSharpParser.DEFAULT, 0); + } + + public GotoStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterGotoStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitGotoStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class SwitchStatementContext extends Simple_embedded_statementContext { + public TerminalNode SWITCH() { + return getToken(CSharpParser.SWITCH, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List switch_section() { + return getRuleContexts(Switch_sectionContext.class); + } + + public Switch_sectionContext switch_section(int i) { + return getRuleContext(Switch_sectionContext.class, i); + } + + public SwitchStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterSwitchStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSwitchStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class FixedStatementContext extends Simple_embedded_statementContext { + public TerminalNode FIXED() { + return getToken(CSharpParser.FIXED, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Pointer_typeContext pointer_type() { + return getRuleContext(Pointer_typeContext.class, 0); + } + + public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { + return getRuleContext(Fixed_pointer_declaratorsContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public FixedStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFixedStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFixedStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class WhileStatementContext extends Simple_embedded_statementContext { + public TerminalNode WHILE() { + return getToken(CSharpParser.WHILE, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public WhileStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterWhileStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitWhileStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class DoStatementContext extends Simple_embedded_statementContext { + public TerminalNode DO() { + return getToken(CSharpParser.DO, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public TerminalNode WHILE() { + return getToken(CSharpParser.WHILE, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public DoStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterDoStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitDoStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ForeachStatementContext extends Simple_embedded_statementContext { + public TerminalNode FOREACH() { + return getToken(CSharpParser.FOREACH, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Local_variable_typeContext local_variable_type() { + return getRuleContext(Local_variable_typeContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public TerminalNode AWAIT() { + return getToken(CSharpParser.AWAIT, 0); + } + + public ForeachStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterForeachStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitForeachStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UncheckedStatementContext extends Simple_embedded_statementContext { + public TerminalNode UNCHECKED() { + return getToken(CSharpParser.UNCHECKED, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public UncheckedStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUncheckedStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitUncheckedStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionStatementContext extends Simple_embedded_statementContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public ExpressionStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExpressionStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExpressionStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class ContinueStatementContext extends Simple_embedded_statementContext { + public TerminalNode CONTINUE() { + return getToken(CSharpParser.CONTINUE, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public ContinueStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterContinueStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitContinueStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UsingStatementContext extends Simple_embedded_statementContext { + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Resource_acquisitionContext resource_acquisition() { + return getRuleContext(Resource_acquisitionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public UsingStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterUsingStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitUsingStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class LockStatementContext extends Simple_embedded_statementContext { + public TerminalNode LOCK() { + return getToken(CSharpParser.LOCK, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Embedded_statementContext embedded_statement() { + return getRuleContext(Embedded_statementContext.class, 0); + } + + public LockStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterLockStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLockStatement(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class YieldStatementContext extends Simple_embedded_statementContext { + public TerminalNode YIELD() { + return getToken(CSharpParser.YIELD, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public TerminalNode RETURN() { + return getToken(CSharpParser.RETURN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode BREAK() { + return getToken(CSharpParser.BREAK, 0); + } + + public YieldStatementContext(Simple_embedded_statementContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterYieldStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitYieldStatement(this); + } + } + + public final Simple_embedded_statementContext simple_embedded_statement() throws RecognitionException { + Simple_embedded_statementContext _localctx = new Simple_embedded_statementContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_simple_embedded_statement); + int _la; + try { + setState(1415); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 143, _ctx)) { + case 1: + _localctx = new TheEmptyStatementContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1285); + match(SEMICOLON); + } + break; + case 2: + _localctx = new ExpressionStatementContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1286); + expression(); + setState(1287); + match(SEMICOLON); + } + break; + case 3: + _localctx = new IfStatementContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1289); + match(IF); + setState(1290); + match(OPEN_PARENS); + setState(1291); + expression(); + setState(1292); + match(CLOSE_PARENS); + setState(1293); + if_body(); + setState(1296); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 131, _ctx)) { + case 1: { + setState(1294); + match(ELSE); + setState(1295); + if_body(); + } + break; + } + } + break; + case 4: + _localctx = new SwitchStatementContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1298); + match(SWITCH); + setState(1299); + match(OPEN_PARENS); + setState(1300); + expression(); + setState(1301); + match(CLOSE_PARENS); + setState(1302); + match(OPEN_BRACE); + setState(1306); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == CASE || _la == DEFAULT) { + { + { + setState(1303); + switch_section(); + } + } + setState(1308); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1309); + match(CLOSE_BRACE); + } + break; + case 5: + _localctx = new WhileStatementContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1311); + match(WHILE); + setState(1312); + match(OPEN_PARENS); + setState(1313); + expression(); + setState(1314); + match(CLOSE_PARENS); + setState(1315); + embedded_statement(); + } + break; + case 6: + _localctx = new DoStatementContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(1317); + match(DO); + setState(1318); + embedded_statement(); + setState(1319); + match(WHILE); + setState(1320); + match(OPEN_PARENS); + setState(1321); + expression(); + setState(1322); + match(CLOSE_PARENS); + setState(1323); + match(SEMICOLON); + } + break; + case 7: + _localctx = new ForStatementContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(1325); + match(FOR); + setState(1326); + match(OPEN_PARENS); + setState(1328); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437194615990526976L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305516992371296445L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1327); + for_initializer(); + } + } + + setState(1330); + match(SEMICOLON); + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1331); + expression(); + } + } + + setState(1334); + match(SEMICOLON); + setState(1336); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1335); + for_iterator(); + } + } + + setState(1338); + match(CLOSE_PARENS); + setState(1339); + embedded_statement(); + } + break; + case 8: + _localctx = new ForeachStatementContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(1341); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AWAIT) { + { + setState(1340); + match(AWAIT); + } + } + + setState(1343); + match(FOREACH); + setState(1344); + match(OPEN_PARENS); + setState(1345); + local_variable_type(); + setState(1346); + identifier(); + setState(1347); + match(IN); + setState(1348); + expression(); + setState(1349); + match(CLOSE_PARENS); + setState(1350); + embedded_statement(); + } + break; + case 9: + _localctx = new BreakStatementContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(1352); + match(BREAK); + setState(1353); + match(SEMICOLON); + } + break; + case 10: + _localctx = new ContinueStatementContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(1354); + match(CONTINUE); + setState(1355); + match(SEMICOLON); + } + break; + case 11: + _localctx = new GotoStatementContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(1356); + match(GOTO); + setState(1361); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: { + setState(1357); + identifier(); + } + break; + case CASE: { + setState(1358); + match(CASE); + setState(1359); + expression(); + } + break; + case DEFAULT: { + setState(1360); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1363); + match(SEMICOLON); + } + break; + case 12: + _localctx = new ReturnStatementContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(1364); + match(RETURN); + setState(1366); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1365); + expression(); + } + } + + setState(1368); + match(SEMICOLON); + } + break; + case 13: + _localctx = new ThrowStatementContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(1369); + match(THROW); + setState(1371); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1370); + expression(); + } + } + + setState(1373); + match(SEMICOLON); + } + break; + case 14: + _localctx = new TryStatementContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(1374); + match(TRY); + setState(1375); + block(); + setState(1381); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CATCH: { + setState(1376); + catch_clauses(); + setState(1378); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == FINALLY) { + { + setState(1377); + finally_clause(); + } + } + + } + break; + case FINALLY: { + setState(1380); + finally_clause(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 15: + _localctx = new CheckedStatementContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(1383); + match(CHECKED); + setState(1384); + block(); + } + break; + case 16: + _localctx = new UncheckedStatementContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(1385); + match(UNCHECKED); + setState(1386); + block(); + } + break; + case 17: + _localctx = new LockStatementContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(1387); + match(LOCK); + setState(1388); + match(OPEN_PARENS); + setState(1389); + expression(); + setState(1390); + match(CLOSE_PARENS); + setState(1391); + embedded_statement(); + } + break; + case 18: + _localctx = new UsingStatementContext(_localctx); + enterOuterAlt(_localctx, 18); + { + setState(1393); + match(USING); + setState(1394); + match(OPEN_PARENS); + setState(1395); + resource_acquisition(); + setState(1396); + match(CLOSE_PARENS); + setState(1397); + embedded_statement(); + } + break; + case 19: + _localctx = new YieldStatementContext(_localctx); + enterOuterAlt(_localctx, 19); + { + setState(1399); + match(YIELD); + setState(1403); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RETURN: { + setState(1400); + match(RETURN); + setState(1401); + expression(); + } + break; + case BREAK: { + setState(1402); + match(BREAK); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1405); + match(SEMICOLON); + } + break; + case 20: + _localctx = new UnsafeStatementContext(_localctx); + enterOuterAlt(_localctx, 20); + { + setState(1406); + match(UNSAFE); + setState(1407); + block(); + } + break; + case 21: + _localctx = new FixedStatementContext(_localctx); + enterOuterAlt(_localctx, 21); + { + setState(1408); + match(FIXED); + setState(1409); + match(OPEN_PARENS); + setState(1410); + pointer_type(); + setState(1411); + fixed_pointer_declarators(); + setState(1412); + match(CLOSE_PARENS); + setState(1413); + embedded_statement(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Statement_listContext statement_list() { + return getRuleContext(Statement_listContext.class, 0); + } + + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitBlock(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1417); + match(OPEN_BRACE); + setState(1419); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -819667982803280896L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4611642037659175101L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153889L) != 0)) { + { + setState(1418); + statement_list(); + } + } + + setState(1421); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_variable_declarationContext extends ParserRuleContext { + public Local_variable_typeContext local_variable_type() { + return getRuleContext(Local_variable_typeContext.class, 0); + } + + public List local_variable_declarator() { + return getRuleContexts(Local_variable_declaratorContext.class); + } + + public Local_variable_declaratorContext local_variable_declarator(int i) { + return getRuleContext(Local_variable_declaratorContext.class, i); + } + + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public TerminalNode FIXED() { + return getToken(CSharpParser.FIXED, 0); + } + + public Pointer_typeContext pointer_type() { + return getRuleContext(Pointer_typeContext.class, 0); + } + + public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { + return getRuleContext(Fixed_pointer_declaratorsContext.class, 0); + } + + public Local_variable_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_variable_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_variable_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_variable_declaration(this); + } + } + + public final Local_variable_declarationContext local_variable_declaration() throws RecognitionException { + Local_variable_declarationContext _localctx = new Local_variable_declarationContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_local_variable_declaration); + int _la; + try { + setState(1442); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case USING: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: + enterOuterAlt(_localctx, 1); + { + setState(1427); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 145, _ctx)) { + case 1: { + setState(1423); + match(USING); + } + break; + case 2: { + setState(1424); + match(REF); + } + break; + case 3: { + setState(1425); + match(REF); + setState(1426); + match(READONLY); + } + break; + } + setState(1429); + local_variable_type(); + setState(1430); + local_variable_declarator(); + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1431); + match(COMMA); + setState(1432); + local_variable_declarator(); + } + } + setState(1437); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case FIXED: + enterOuterAlt(_localctx, 2); + { + setState(1438); + match(FIXED); + setState(1439); + pointer_type(); + setState(1440); + fixed_pointer_declarators(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_variable_typeContext extends ParserRuleContext { + public TerminalNode VAR() { + return getToken(CSharpParser.VAR, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Local_variable_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_variable_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_variable_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_variable_type(this); + } + } + + public final Local_variable_typeContext local_variable_type() throws RecognitionException { + Local_variable_typeContext _localctx = new Local_variable_typeContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_local_variable_type); + try { + setState(1446); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1444); + match(VAR); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1445); + type_(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_variable_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Local_variable_initializerContext local_variable_initializer() { + return getRuleContext(Local_variable_initializerContext.class, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public Local_variable_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_variable_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_variable_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_variable_declarator(this); + } + } + + public final Local_variable_declaratorContext local_variable_declarator() throws RecognitionException { + Local_variable_declaratorContext _localctx = new Local_variable_declaratorContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_local_variable_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1448); + identifier(); + setState(1454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(1449); + match(ASSIGNMENT); + setState(1451); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 149, _ctx)) { + case 1: { + setState(1450); + match(REF); + } + break; + } + setState(1453); + local_variable_initializer(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_variable_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class, 0); + } + + public Stackalloc_initializerContext stackalloc_initializer() { + return getRuleContext(Stackalloc_initializerContext.class, 0); + } + + public Local_variable_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_variable_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_variable_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_variable_initializer(this); + } + } + + public final Local_variable_initializerContext local_variable_initializer() throws RecognitionException { + Local_variable_initializerContext _localctx = new Local_variable_initializerContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_local_variable_initializer); + try { + setState(1459); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1456); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1457); + array_initializer(); + } + break; + case STACKALLOC: + enterOuterAlt(_localctx, 3); + { + setState(1458); + stackalloc_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Local_constant_declarationContext extends ParserRuleContext { + public TerminalNode CONST() { + return getToken(CSharpParser.CONST, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Constant_declaratorsContext constant_declarators() { + return getRuleContext(Constant_declaratorsContext.class, 0); + } + + public Local_constant_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_local_constant_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterLocal_constant_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitLocal_constant_declaration(this); + } + } + + public final Local_constant_declarationContext local_constant_declaration() throws RecognitionException { + Local_constant_declarationContext _localctx = new Local_constant_declarationContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_local_constant_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1461); + match(CONST); + setState(1462); + type_(); + setState(1463); + constant_declarators(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class If_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Simple_embedded_statementContext simple_embedded_statement() { + return getRuleContext(Simple_embedded_statementContext.class, 0); + } + + public If_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_if_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIf_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIf_body(this); + } + } + + public final If_bodyContext if_body() throws RecognitionException { + If_bodyContext _localctx = new If_bodyContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_if_body); + try { + setState(1467); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1465); + block(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BREAK: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case CONTINUE: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DO: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FIXED: + case FLOAT: + case FOR: + case FOREACH: + case FROM: + case GET: + case GOTO: + case GROUP: + case IF: + case INT: + case INTO: + case JOIN: + case LET: + case LOCK: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case RETURN: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case SWITCH: + case THIS: + case THROW: + case TRUE: + case TRY: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case UNSAFE: + case USHORT: + case USING: + case VAR: + case WHEN: + case WHERE: + case WHILE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case SEMICOLON: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 2); + { + setState(1466); + simple_embedded_statement(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Switch_sectionContext extends ParserRuleContext { + public Statement_listContext statement_list() { + return getRuleContext(Statement_listContext.class, 0); + } + + public List switch_label() { + return getRuleContexts(Switch_labelContext.class); + } + + public Switch_labelContext switch_label(int i) { + return getRuleContext(Switch_labelContext.class, i); + } + + public Switch_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_switch_section; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterSwitch_section(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSwitch_section(this); + } + } + + public final Switch_sectionContext switch_section() throws RecognitionException { + Switch_sectionContext _localctx = new Switch_sectionContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_switch_section); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1470); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1469); + switch_label(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1472); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 153, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1474); + statement_list(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Switch_labelContext extends ParserRuleContext { + public TerminalNode CASE() { + return getToken(CSharpParser.CASE, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Case_guardContext case_guard() { + return getRuleContext(Case_guardContext.class, 0); + } + + public TerminalNode DEFAULT() { + return getToken(CSharpParser.DEFAULT, 0); + } + + public Switch_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_switch_label; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterSwitch_label(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitSwitch_label(this); + } + } + + public final Switch_labelContext switch_label() throws RecognitionException { + Switch_labelContext _localctx = new Switch_labelContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_switch_label); + int _la; + try { + setState(1485); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CASE: + enterOuterAlt(_localctx, 1); + { + setState(1476); + match(CASE); + setState(1477); + expression(); + setState(1479); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHEN) { + { + setState(1478); + case_guard(); + } + } + + setState(1481); + match(COLON); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(1483); + match(DEFAULT); + setState(1484); + match(COLON); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_guardContext extends ParserRuleContext { + public TerminalNode WHEN() { + return getToken(CSharpParser.WHEN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Case_guardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_case_guard; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterCase_guard(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitCase_guard(this); + } + } + + public final Case_guardContext case_guard() throws RecognitionException { + Case_guardContext _localctx = new Case_guardContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_case_guard); + try { + enterOuterAlt(_localctx, 1); + { + setState(1487); + match(WHEN); + setState(1488); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Statement_listContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public Statement_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statement_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterStatement_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitStatement_list(this); + } + } + + public final Statement_listContext statement_list() throws RecognitionException { + Statement_listContext _localctx = new Statement_listContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_statement_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1491); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1490); + statement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1493); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 156, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_initializerContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public For_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_for_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFor_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFor_initializer(this); + } + } + + public final For_initializerContext for_initializer() throws RecognitionException { + For_initializerContext _localctx = new For_initializerContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_for_initializer); + int _la; + try { + setState(1504); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 158, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1495); + local_variable_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1496); + expression(); + setState(1501); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1497); + match(COMMA); + setState(1498); + expression(); + } + } + setState(1503); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_iteratorContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public For_iteratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_for_iterator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFor_iterator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFor_iterator(this); + } + } + + public final For_iteratorContext for_iterator() throws RecognitionException { + For_iteratorContext _localctx = new For_iteratorContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_for_iterator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1506); + expression(); + setState(1511); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1507); + match(COMMA); + setState(1508); + expression(); + } + } + setState(1513); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Catch_clausesContext extends ParserRuleContext { + public List specific_catch_clause() { + return getRuleContexts(Specific_catch_clauseContext.class); + } + + public Specific_catch_clauseContext specific_catch_clause(int i) { + return getRuleContext(Specific_catch_clauseContext.class, i); + } + + public General_catch_clauseContext general_catch_clause() { + return getRuleContext(General_catch_clauseContext.class, 0); + } + + public Catch_clausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_catch_clauses; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterCatch_clauses(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitCatch_clauses(this); + } + } + + public final Catch_clausesContext catch_clauses() throws RecognitionException { + Catch_clausesContext _localctx = new Catch_clausesContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_catch_clauses); + int _la; + try { + int _alt; + setState(1525); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 162, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1514); + specific_catch_clause(); + setState(1518); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 160, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1515); + specific_catch_clause(); + } + } + } + setState(1520); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 160, _ctx); + } + setState(1522); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == CATCH) { + { + setState(1521); + general_catch_clause(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1524); + general_catch_clause(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Specific_catch_clauseContext extends ParserRuleContext { + public TerminalNode CATCH() { + return getToken(CSharpParser.CATCH, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Exception_filterContext exception_filter() { + return getRuleContext(Exception_filterContext.class, 0); + } + + public Specific_catch_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_specific_catch_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSpecific_catch_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSpecific_catch_clause(this); + } + } + + public final Specific_catch_clauseContext specific_catch_clause() throws RecognitionException { + Specific_catch_clauseContext _localctx = new Specific_catch_clauseContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_specific_catch_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1527); + match(CATCH); + setState(1528); + match(OPEN_PARENS); + setState(1529); + class_type(); + setState(1531); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1904629023639713L) != 0)) { + { + setState(1530); + identifier(); + } + } + + setState(1533); + match(CLOSE_PARENS); + setState(1535); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHEN) { + { + setState(1534); + exception_filter(); + } + } + + setState(1537); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class General_catch_clauseContext extends ParserRuleContext { + public TerminalNode CATCH() { + return getToken(CSharpParser.CATCH, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Exception_filterContext exception_filter() { + return getRuleContext(Exception_filterContext.class, 0); + } + + public General_catch_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_general_catch_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterGeneral_catch_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitGeneral_catch_clause(this); + } + } + + public final General_catch_clauseContext general_catch_clause() throws RecognitionException { + General_catch_clauseContext _localctx = new General_catch_clauseContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_general_catch_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1539); + match(CATCH); + setState(1541); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHEN) { + { + setState(1540); + exception_filter(); + } + } + + setState(1543); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Exception_filterContext extends ParserRuleContext { + public TerminalNode WHEN() { + return getToken(CSharpParser.WHEN, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Exception_filterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_exception_filter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterException_filter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitException_filter(this); + } + } + + public final Exception_filterContext exception_filter() throws RecognitionException { + Exception_filterContext _localctx = new Exception_filterContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_exception_filter); + try { + enterOuterAlt(_localctx, 1); + { + setState(1545); + match(WHEN); + setState(1546); + match(OPEN_PARENS); + setState(1547); + expression(); + setState(1548); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Finally_clauseContext extends ParserRuleContext { + public TerminalNode FINALLY() { + return getToken(CSharpParser.FINALLY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Finally_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_finally_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFinally_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFinally_clause(this); + } + } + + public final Finally_clauseContext finally_clause() throws RecognitionException { + Finally_clauseContext _localctx = new Finally_clauseContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_finally_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1550); + match(FINALLY); + setState(1551); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Resource_acquisitionContext extends ParserRuleContext { + public Local_variable_declarationContext local_variable_declaration() { + return getRuleContext(Local_variable_declarationContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Resource_acquisitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_resource_acquisition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterResource_acquisition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitResource_acquisition(this); + } + } + + public final Resource_acquisitionContext resource_acquisition() throws RecognitionException { + Resource_acquisitionContext _localctx = new Resource_acquisitionContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_resource_acquisition); + try { + setState(1555); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1553); + local_variable_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1554); + expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Namespace_declarationContext extends ParserRuleContext { + public Qualified_identifierContext qi; + + public TerminalNode NAMESPACE() { + return getToken(CSharpParser.NAMESPACE, 0); + } + + public Namespace_bodyContext namespace_body() { + return getRuleContext(Namespace_bodyContext.class, 0); + } + + public Qualified_identifierContext qualified_identifier() { + return getRuleContext(Qualified_identifierContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Namespace_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namespace_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNamespace_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNamespace_declaration(this); + } + } + + public final Namespace_declarationContext namespace_declaration() throws RecognitionException { + Namespace_declarationContext _localctx = new Namespace_declarationContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_namespace_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1557); + match(NAMESPACE); + setState(1558); + ((Namespace_declarationContext) _localctx).qi = qualified_identifier(); + setState(1559); + namespace_body(); + setState(1561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(1560); + match(SEMICOLON); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qualified_identifierContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public List DOT() { + return getTokens(CSharpParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + + public Qualified_identifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_qualified_identifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterQualified_identifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitQualified_identifier(this); + } + } + + public final Qualified_identifierContext qualified_identifier() throws RecognitionException { + Qualified_identifierContext _localctx = new Qualified_identifierContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_qualified_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1563); + identifier(); + setState(1568); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == DOT) { + { + { + setState(1564); + match(DOT); + setState(1565); + identifier(); + } + } + setState(1570); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Namespace_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Extern_alias_directivesContext extern_alias_directives() { + return getRuleContext(Extern_alias_directivesContext.class, 0); + } + + public Using_directivesContext using_directives() { + return getRuleContext(Using_directivesContext.class, 0); + } + + public Namespace_member_declarationsContext namespace_member_declarations() { + return getRuleContext(Namespace_member_declarationsContext.class, 0); + } + + public Namespace_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namespace_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterNamespace_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitNamespace_body(this); + } + } + + public final Namespace_bodyContext namespace_body() throws RecognitionException { + Namespace_bodyContext _localctx = new Namespace_bodyContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_namespace_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1571); + match(OPEN_BRACE); + setState(1573); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 169, _ctx)) { + case 1: { + setState(1572); + extern_alias_directives(); + } + break; + } + setState(1576); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == USING) { + { + setState(1575); + using_directives(); + } + } + + setState(1579); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 216175120790618624L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4611708283706211587L) != 0)) { + { + setState(1578); + namespace_member_declarations(); + } + } + + setState(1581); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Extern_alias_directivesContext extends ParserRuleContext { + public List extern_alias_directive() { + return getRuleContexts(Extern_alias_directiveContext.class); + } + + public Extern_alias_directiveContext extern_alias_directive(int i) { + return getRuleContext(Extern_alias_directiveContext.class, i); + } + + public Extern_alias_directivesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_extern_alias_directives; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExtern_alias_directives(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExtern_alias_directives(this); + } + } + + public final Extern_alias_directivesContext extern_alias_directives() throws RecognitionException { + Extern_alias_directivesContext _localctx = new Extern_alias_directivesContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_extern_alias_directives); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1584); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1583); + extern_alias_directive(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1586); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 172, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Extern_alias_directiveContext extends ParserRuleContext { + public TerminalNode EXTERN() { + return getToken(CSharpParser.EXTERN, 0); + } + + public TerminalNode ALIAS() { + return getToken(CSharpParser.ALIAS, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Extern_alias_directiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_extern_alias_directive; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterExtern_alias_directive(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitExtern_alias_directive(this); + } + } + + public final Extern_alias_directiveContext extern_alias_directive() throws RecognitionException { + Extern_alias_directiveContext _localctx = new Extern_alias_directiveContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_extern_alias_directive); + try { + enterOuterAlt(_localctx, 1); + { + setState(1588); + match(EXTERN); + setState(1589); + match(ALIAS); + setState(1590); + identifier(); + setState(1591); + match(SEMICOLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Using_directivesContext extends ParserRuleContext { + public List using_directive() { + return getRuleContexts(Using_directiveContext.class); + } + + public Using_directiveContext using_directive(int i) { + return getRuleContext(Using_directiveContext.class, i); + } + + public Using_directivesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_using_directives; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterUsing_directives(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitUsing_directives(this); + } + } + + public final Using_directivesContext using_directives() throws RecognitionException { + Using_directivesContext _localctx = new Using_directivesContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_using_directives); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1594); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1593); + using_directive(); + } + } + setState(1596); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == USING); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Using_directiveContext extends ParserRuleContext { + public Using_directiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_using_directive; + } + + public Using_directiveContext() { + } + + public void copyFrom(Using_directiveContext ctx) { + super.copyFrom(ctx); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UsingAliasDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public UsingAliasDirectiveContext(Using_directiveContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUsingAliasDirective(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitUsingAliasDirective(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UsingNamespaceDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public UsingNamespaceDirectiveContext(Using_directiveContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUsingNamespaceDirective(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitUsingNamespaceDirective(this); + } + } + + @SuppressWarnings("CheckReturnValue") + public static class UsingStaticDirectiveContext extends Using_directiveContext { + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public TerminalNode STATIC() { + return getToken(CSharpParser.STATIC, 0); + } + + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public UsingStaticDirectiveContext(Using_directiveContext ctx) { + copyFrom(ctx); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterUsingStaticDirective(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitUsingStaticDirective(this); + } + } + + public final Using_directiveContext using_directive() throws RecognitionException { + Using_directiveContext _localctx = new Using_directiveContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_using_directive); + try { + setState(1613); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 174, _ctx)) { + case 1: + _localctx = new UsingAliasDirectiveContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1598); + match(USING); + setState(1599); + identifier(); + setState(1600); + match(ASSIGNMENT); + setState(1601); + namespace_or_type_name(); + setState(1602); + match(SEMICOLON); + } + break; + case 2: + _localctx = new UsingNamespaceDirectiveContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1604); + match(USING); + setState(1605); + namespace_or_type_name(); + setState(1606); + match(SEMICOLON); + } + break; + case 3: + _localctx = new UsingStaticDirectiveContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1608); + match(USING); + setState(1609); + match(STATIC); + setState(1610); + namespace_or_type_name(); + setState(1611); + match(SEMICOLON); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Namespace_member_declarationsContext extends ParserRuleContext { + public List namespace_member_declaration() { + return getRuleContexts(Namespace_member_declarationContext.class); + } + + public Namespace_member_declarationContext namespace_member_declaration(int i) { + return getRuleContext(Namespace_member_declarationContext.class, i); + } + + public Namespace_member_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namespace_member_declarations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNamespace_member_declarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNamespace_member_declarations(this); + } + } + + public final Namespace_member_declarationsContext namespace_member_declarations() throws RecognitionException { + Namespace_member_declarationsContext _localctx = new Namespace_member_declarationsContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_namespace_member_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1616); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1615); + namespace_member_declaration(); + } + } + setState(1618); + _errHandler.sync(this); + _la = _input.LA(1); + } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 216175120790618624L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 4611708283706211587L) != 0)); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Namespace_member_declarationContext extends ParserRuleContext { + public Namespace_declarationContext namespace_declaration() { + return getRuleContext(Namespace_declarationContext.class, 0); + } + + public Type_declarationContext type_declaration() { + return getRuleContext(Type_declarationContext.class, 0); + } + + public Namespace_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namespace_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterNamespace_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitNamespace_member_declaration(this); + } + } + + public final Namespace_member_declarationContext namespace_member_declaration() throws RecognitionException { + Namespace_member_declarationContext _localctx = new Namespace_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_namespace_member_declaration); + try { + setState(1622); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAMESPACE: + enterOuterAlt(_localctx, 1); + { + setState(1620); + namespace_declaration(); + } + break; + case ABSTRACT: + case ASYNC: + case CLASS: + case DELEGATE: + case ENUM: + case EXTERN: + case INTERFACE: + case INTERNAL: + case NEW: + case OVERRIDE: + case PARTIAL: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case READONLY: + case REF: + case SEALED: + case STATIC: + case STRUCT: + case UNSAFE: + case VIRTUAL: + case VOLATILE: + case OPEN_BRACKET: + enterOuterAlt(_localctx, 2); + { + setState(1621); + type_declaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_declarationContext extends ParserRuleContext { + public Class_definitionContext class_definition() { + return getRuleContext(Class_definitionContext.class, 0); + } + + public Struct_definitionContext struct_definition() { + return getRuleContext(Struct_definitionContext.class, 0); + } + + public Interface_definitionContext interface_definition() { + return getRuleContext(Interface_definitionContext.class, 0); + } + + public Enum_definitionContext enum_definition() { + return getRuleContext(Enum_definitionContext.class, 0); + } + + public Delegate_definitionContext delegate_definition() { + return getRuleContext(Delegate_definitionContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class, 0); + } + + public Type_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterType_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitType_declaration(this); + } + } + + public final Type_declarationContext type_declaration() throws RecognitionException { + Type_declarationContext _localctx = new Type_declarationContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_type_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1625); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1624); + attributes(); + } + } + + setState(1628); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 178, _ctx)) { + case 1: { + setState(1627); + all_member_modifiers(); + } + break; + } + setState(1635); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: { + setState(1630); + class_definition(); + } + break; + case READONLY: + case REF: + case STRUCT: { + setState(1631); + struct_definition(); + } + break; + case INTERFACE: { + setState(1632); + interface_definition(); + } + break; + case ENUM: { + setState(1633); + enum_definition(); + } + break; + case DELEGATE: { + setState(1634); + delegate_definition(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qualified_alias_memberContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public TerminalNode DOUBLE_COLON() { + return getToken(CSharpParser.DOUBLE_COLON, 0); + } + + public Type_argument_listContext type_argument_list() { + return getRuleContext(Type_argument_listContext.class, 0); + } + + public Qualified_alias_memberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_qualified_alias_member; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterQualified_alias_member(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitQualified_alias_member(this); + } + } + + public final Qualified_alias_memberContext qualified_alias_member() throws RecognitionException { + Qualified_alias_memberContext _localctx = new Qualified_alias_memberContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_qualified_alias_member); + try { + enterOuterAlt(_localctx, 1); + { + setState(1637); + identifier(); + setState(1638); + match(DOUBLE_COLON); + setState(1639); + identifier(); + setState(1641); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 180, _ctx)) { + case 1: { + setState(1640); + type_argument_list(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_parameter_listContext extends ParserRuleContext { + public TerminalNode LT() { + return getToken(CSharpParser.LT, 0); + } + + public List type_parameter() { + return getRuleContexts(Type_parameterContext.class); + } + + public Type_parameterContext type_parameter(int i) { + return getRuleContext(Type_parameterContext.class, i); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Type_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_parameter_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterType_parameter_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitType_parameter_list(this); + } + } + + public final Type_parameter_listContext type_parameter_list() throws RecognitionException { + Type_parameter_listContext _localctx = new Type_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_type_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1643); + match(LT); + setState(1644); + type_parameter(); + setState(1649); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1645); + match(COMMA); + setState(1646); + type_parameter(); + } + } + setState(1651); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1652); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_parameterContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Type_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_parameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterType_parameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitType_parameter(this); + } + } + + public final Type_parameterContext type_parameter() throws RecognitionException { + Type_parameterContext _localctx = new Type_parameterContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_type_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1655); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1654); + attributes(); + } + } + + setState(1657); + identifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_baseContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class, i); + } + + public Class_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_base; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterClass_base(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitClass_base(this); + } + } + + public final Class_baseContext class_base() throws RecognitionException { + Class_baseContext _localctx = new Class_baseContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_class_base); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1659); + match(COLON); + setState(1660); + class_type(); + setState(1665); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1661); + match(COMMA); + setState(1662); + namespace_or_type_name(); + } + } + setState(1667); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_type_listContext extends ParserRuleContext { + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Interface_type_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_type_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterface_type_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterface_type_list(this); + } + } + + public final Interface_type_listContext interface_type_list() throws RecognitionException { + Interface_type_listContext _localctx = new Interface_type_listContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_interface_type_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1668); + namespace_or_type_name(); + setState(1673); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1669); + match(COMMA); + setState(1670); + namespace_or_type_name(); + } + } + setState(1675); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_parameter_constraints_clausesContext extends ParserRuleContext { + public List type_parameter_constraints_clause() { + return getRuleContexts(Type_parameter_constraints_clauseContext.class); + } + + public Type_parameter_constraints_clauseContext type_parameter_constraints_clause(int i) { + return getRuleContext(Type_parameter_constraints_clauseContext.class, i); + } + + public Type_parameter_constraints_clausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_parameter_constraints_clauses; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterType_parameter_constraints_clauses(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitType_parameter_constraints_clauses(this); + } + } + + public final Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() throws RecognitionException { + Type_parameter_constraints_clausesContext _localctx = new Type_parameter_constraints_clausesContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_type_parameter_constraints_clauses); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1677); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1676); + type_parameter_constraints_clause(); + } + } + setState(1679); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == WHERE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_parameter_constraints_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { + return getToken(CSharpParser.WHERE, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Type_parameter_constraintsContext type_parameter_constraints() { + return getRuleContext(Type_parameter_constraintsContext.class, 0); + } + + public Type_parameter_constraints_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_parameter_constraints_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterType_parameter_constraints_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitType_parameter_constraints_clause(this); + } + } + + public final Type_parameter_constraints_clauseContext type_parameter_constraints_clause() throws RecognitionException { + Type_parameter_constraints_clauseContext _localctx = new Type_parameter_constraints_clauseContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_type_parameter_constraints_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1681); + match(WHERE); + setState(1682); + identifier(); + setState(1683); + match(COLON); + setState(1684); + type_parameter_constraints(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_parameter_constraintsContext extends ParserRuleContext { + public Constructor_constraintContext constructor_constraint() { + return getRuleContext(Constructor_constraintContext.class, 0); + } + + public Primary_constraintContext primary_constraint() { + return getRuleContext(Primary_constraintContext.class, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Secondary_constraintsContext secondary_constraints() { + return getRuleContext(Secondary_constraintsContext.class, 0); + } + + public Type_parameter_constraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_parameter_constraints; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterType_parameter_constraints(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitType_parameter_constraints(this); + } + } + + public final Type_parameter_constraintsContext type_parameter_constraints() throws RecognitionException { + Type_parameter_constraintsContext _localctx = new Type_parameter_constraintsContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_type_parameter_constraints); + int _la; + try { + setState(1696); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEW: + enterOuterAlt(_localctx, 1); + { + setState(1686); + constructor_constraint(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case CLASS: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case STRUCT: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1687); + primary_constraint(); + setState(1690); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 186, _ctx)) { + case 1: { + setState(1688); + match(COMMA); + setState(1689); + secondary_constraints(); + } + break; + } + setState(1694); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1692); + match(COMMA); + setState(1693); + constructor_constraint(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Primary_constraintContext extends ParserRuleContext { + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(CSharpParser.CLASS, 0); + } + + public TerminalNode INTERR() { + return getToken(CSharpParser.INTERR, 0); + } + + public TerminalNode STRUCT() { + return getToken(CSharpParser.STRUCT, 0); + } + + public TerminalNode UNMANAGED() { + return getToken(CSharpParser.UNMANAGED, 0); + } + + public Primary_constraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_primary_constraint; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterPrimary_constraint(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitPrimary_constraint(this); + } + } + + public final Primary_constraintContext primary_constraint() throws RecognitionException { + Primary_constraintContext _localctx = new Primary_constraintContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_primary_constraint); + int _la; + try { + setState(1705); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 190, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1698); + class_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1699); + match(CLASS); + setState(1701); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == INTERR) { + { + setState(1700); + match(INTERR); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1703); + match(STRUCT); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1704); + match(UNMANAGED); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Secondary_constraintsContext extends ParserRuleContext { + public List namespace_or_type_name() { + return getRuleContexts(Namespace_or_type_nameContext.class); + } + + public Namespace_or_type_nameContext namespace_or_type_name(int i) { + return getRuleContext(Namespace_or_type_nameContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Secondary_constraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_secondary_constraints; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSecondary_constraints(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSecondary_constraints(this); + } + } + + public final Secondary_constraintsContext secondary_constraints() throws RecognitionException { + Secondary_constraintsContext _localctx = new Secondary_constraintsContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_secondary_constraints); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1707); + namespace_or_type_name(); + setState(1712); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 191, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1708); + match(COMMA); + setState(1709); + namespace_or_type_name(); + } + } + } + setState(1714); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 191, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constructor_constraintContext extends ParserRuleContext { + public TerminalNode NEW() { + return getToken(CSharpParser.NEW, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Constructor_constraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constructor_constraint; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstructor_constraint(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstructor_constraint(this); + } + } + + public final Constructor_constraintContext constructor_constraint() throws RecognitionException { + Constructor_constraintContext _localctx = new Constructor_constraintContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_constructor_constraint); + try { + enterOuterAlt(_localctx, 1); + { + setState(1715); + match(NEW); + setState(1716); + match(OPEN_PARENS); + setState(1717); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Class_member_declarationsContext class_member_declarations() { + return getRuleContext(Class_member_declarationsContext.class, 0); + } + + public Class_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterClass_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitClass_body(this); + } + } + + public final Class_bodyContext class_body() throws RecognitionException { + Class_bodyContext _localctx = new Class_bodyContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_class_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1719); + match(OPEN_BRACE); + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5212032640031007232L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -9221404082353472843L) != 0) || _la == OPEN_PARENS || _la == TILDE) { + { + setState(1720); + class_member_declarations(); + } + } + + setState(1723); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_member_declarationsContext extends ParserRuleContext { + public List class_member_declaration() { + return getRuleContexts(Class_member_declarationContext.class); + } + + public Class_member_declarationContext class_member_declaration(int i) { + return getRuleContext(Class_member_declarationContext.class, i); + } + + public Class_member_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_member_declarations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterClass_member_declarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitClass_member_declarations(this); + } + } + + public final Class_member_declarationsContext class_member_declarations() throws RecognitionException { + Class_member_declarationsContext _localctx = new Class_member_declarationsContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_class_member_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1726); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1725); + class_member_declaration(); + } + } + setState(1728); + _errHandler.sync(this); + _la = _input.LA(1); + } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5212032640031007232L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -9221404082353472843L) != 0) || _la == OPEN_PARENS || _la == TILDE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_member_declarationContext extends ParserRuleContext { + public Common_member_declarationContext common_member_declaration() { + return getRuleContext(Common_member_declarationContext.class, 0); + } + + public Destructor_definitionContext destructor_definition() { + return getRuleContext(Destructor_definitionContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class, 0); + } + + public Class_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterClass_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitClass_member_declaration(this); + } + } + + public final Class_member_declarationContext class_member_declaration() throws RecognitionException { + Class_member_declarationContext _localctx = new Class_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_class_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1731); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1730); + attributes(); + } + } + + setState(1734); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 195, _ctx)) { + case 1: { + setState(1733); + all_member_modifiers(); + } + break; + } + setState(1738); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CLASS: + case CONST: + case DECIMAL: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case ENUM: + case EQUALS: + case EVENT: + case EXPLICIT: + case FLOAT: + case FROM: + case GET: + case GROUP: + case IMPLICIT: + case INT: + case INTERFACE: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case READONLY: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case STRUCT: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: { + setState(1736); + common_member_declaration(); + } + break; + case TILDE: { + setState(1737); + destructor_definition(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class All_member_modifiersContext extends ParserRuleContext { + public List all_member_modifier() { + return getRuleContexts(All_member_modifierContext.class); + } + + public All_member_modifierContext all_member_modifier(int i) { + return getRuleContext(All_member_modifierContext.class, i); + } + + public All_member_modifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_all_member_modifiers; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAll_member_modifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAll_member_modifiers(this); + } + } + + public final All_member_modifiersContext all_member_modifiers() throws RecognitionException { + All_member_modifiersContext _localctx = new All_member_modifiersContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_all_member_modifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1741); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1740); + all_member_modifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1743); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 197, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class All_member_modifierContext extends ParserRuleContext { + public TerminalNode NEW() { + return getToken(CSharpParser.NEW, 0); + } + + public TerminalNode PUBLIC() { + return getToken(CSharpParser.PUBLIC, 0); + } + + public TerminalNode PROTECTED() { + return getToken(CSharpParser.PROTECTED, 0); + } + + public TerminalNode INTERNAL() { + return getToken(CSharpParser.INTERNAL, 0); + } + + public TerminalNode PRIVATE() { + return getToken(CSharpParser.PRIVATE, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public TerminalNode VOLATILE() { + return getToken(CSharpParser.VOLATILE, 0); + } + + public TerminalNode VIRTUAL() { + return getToken(CSharpParser.VIRTUAL, 0); + } + + public TerminalNode SEALED() { + return getToken(CSharpParser.SEALED, 0); + } + + public TerminalNode OVERRIDE() { + return getToken(CSharpParser.OVERRIDE, 0); + } + + public TerminalNode ABSTRACT() { + return getToken(CSharpParser.ABSTRACT, 0); + } + + public TerminalNode STATIC() { + return getToken(CSharpParser.STATIC, 0); + } + + public TerminalNode UNSAFE() { + return getToken(CSharpParser.UNSAFE, 0); + } + + public TerminalNode EXTERN() { + return getToken(CSharpParser.EXTERN, 0); + } + + public TerminalNode PARTIAL() { + return getToken(CSharpParser.PARTIAL, 0); + } + + public TerminalNode ASYNC() { + return getToken(CSharpParser.ASYNC, 0); + } + + public All_member_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_all_member_modifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAll_member_modifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAll_member_modifier(this); + } + } + + public final All_member_modifierContext all_member_modifier() throws RecognitionException { + All_member_modifierContext _localctx = new All_member_modifierContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_all_member_modifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1745); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 144117387099144704L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 11132572286593L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Common_member_declarationContext extends ParserRuleContext { + public Constant_declarationContext constant_declaration() { + return getRuleContext(Constant_declarationContext.class, 0); + } + + public Typed_member_declarationContext typed_member_declaration() { + return getRuleContext(Typed_member_declarationContext.class, 0); + } + + public Event_declarationContext event_declaration() { + return getRuleContext(Event_declarationContext.class, 0); + } + + public Conversion_operator_declaratorContext conversion_operator_declarator() { + return getRuleContext(Conversion_operator_declaratorContext.class, 0); + } + + public BodyContext body() { + return getRuleContext(BodyContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Constructor_declarationContext constructor_declaration() { + return getRuleContext(Constructor_declarationContext.class, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public Method_declarationContext method_declaration() { + return getRuleContext(Method_declarationContext.class, 0); + } + + public Class_definitionContext class_definition() { + return getRuleContext(Class_definitionContext.class, 0); + } + + public Struct_definitionContext struct_definition() { + return getRuleContext(Struct_definitionContext.class, 0); + } + + public Interface_definitionContext interface_definition() { + return getRuleContext(Interface_definitionContext.class, 0); + } + + public Enum_definitionContext enum_definition() { + return getRuleContext(Enum_definitionContext.class, 0); + } + + public Delegate_definitionContext delegate_definition() { + return getRuleContext(Delegate_definitionContext.class, 0); + } + + public Common_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_common_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterCommon_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitCommon_member_declaration(this); + } + } + + public final Common_member_declarationContext common_member_declaration() throws RecognitionException { + Common_member_declarationContext _localctx = new Common_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_common_member_declaration); + try { + setState(1766); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 199, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1747); + constant_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1748); + typed_member_declaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1749); + event_declaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1750); + conversion_operator_declarator(); + setState(1756); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: { + setState(1751); + body(); + } + break; + case ASSIGNMENT: { + setState(1752); + right_arrow(); + setState(1753); + throwable_expression(); + setState(1754); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1758); + constructor_declaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1759); + match(VOID); + setState(1760); + method_declaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1761); + class_definition(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1762); + struct_definition(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1763); + interface_definition(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1764); + enum_definition(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1765); + delegate_definition(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Typed_member_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(CSharpParser.DOT, 0); + } + + public Indexer_declarationContext indexer_declaration() { + return getRuleContext(Indexer_declarationContext.class, 0); + } + + public Method_declarationContext method_declaration() { + return getRuleContext(Method_declarationContext.class, 0); + } + + public Property_declarationContext property_declaration() { + return getRuleContext(Property_declarationContext.class, 0); + } + + public Operator_declarationContext operator_declaration() { + return getRuleContext(Operator_declarationContext.class, 0); + } + + public Field_declarationContext field_declaration() { + return getRuleContext(Field_declarationContext.class, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public Typed_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typed_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterTyped_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitTyped_member_declaration(this); + } + } + + public final Typed_member_declarationContext typed_member_declaration() throws RecognitionException { + Typed_member_declarationContext _localctx = new Typed_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_typed_member_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1773); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 200, _ctx)) { + case 1: { + setState(1768); + match(REF); + } + break; + case 2: { + setState(1769); + match(READONLY); + setState(1770); + match(REF); + } + break; + case 3: { + setState(1771); + match(REF); + setState(1772); + match(READONLY); + } + break; + } + setState(1775); + type_(); + setState(1785); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 201, _ctx)) { + case 1: { + setState(1776); + namespace_or_type_name(); + setState(1777); + match(DOT); + setState(1778); + indexer_declaration(); + } + break; + case 2: { + setState(1780); + method_declaration(); + } + break; + case 3: { + setState(1781); + property_declaration(); + } + break; + case 4: { + setState(1782); + indexer_declaration(); + } + break; + case 5: { + setState(1783); + operator_declaration(); + } + break; + case 6: { + setState(1784); + field_declaration(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constant_declaratorsContext extends ParserRuleContext { + public List constant_declarator() { + return getRuleContexts(Constant_declaratorContext.class); + } + + public Constant_declaratorContext constant_declarator(int i) { + return getRuleContext(Constant_declaratorContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Constant_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constant_declarators; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstant_declarators(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstant_declarators(this); + } + } + + public final Constant_declaratorsContext constant_declarators() throws RecognitionException { + Constant_declaratorsContext _localctx = new Constant_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_constant_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1787); + constant_declarator(); + setState(1792); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1788); + match(COMMA); + setState(1789); + constant_declarator(); + } + } + setState(1794); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constant_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Constant_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constant_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstant_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstant_declarator(this); + } + } + + public final Constant_declaratorContext constant_declarator() throws RecognitionException { + Constant_declaratorContext _localctx = new Constant_declaratorContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_constant_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1795); + identifier(); + setState(1796); + match(ASSIGNMENT); + setState(1797); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variable_declaratorsContext extends ParserRuleContext { + public List variable_declarator() { + return getRuleContexts(Variable_declaratorContext.class); + } + + public Variable_declaratorContext variable_declarator(int i) { + return getRuleContext(Variable_declaratorContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Variable_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variable_declarators; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariable_declarators(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariable_declarators(this); + } + } + + public final Variable_declaratorsContext variable_declarators() throws RecognitionException { + Variable_declaratorsContext _localctx = new Variable_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_variable_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1799); + variable_declarator(); + setState(1804); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1800); + match(COMMA); + setState(1801); + variable_declarator(); + } + } + setState(1806); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variable_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Variable_initializerContext variable_initializer() { + return getRuleContext(Variable_initializerContext.class, 0); + } + + public Variable_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variable_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariable_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariable_declarator(this); + } + } + + public final Variable_declaratorContext variable_declarator() throws RecognitionException { + Variable_declaratorContext _localctx = new Variable_declaratorContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_variable_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1807); + identifier(); + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(1808); + match(ASSIGNMENT); + setState(1809); + variable_initializer(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variable_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Array_initializerContext array_initializer() { + return getRuleContext(Array_initializerContext.class, 0); + } + + public Variable_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variable_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariable_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariable_initializer(this); + } + } + + public final Variable_initializerContext variable_initializer() throws RecognitionException { + Variable_initializerContext _localctx = new Variable_initializerContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_variable_initializer); + try { + setState(1814); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(1812); + expression(); + } + break; + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1813); + array_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Return_typeContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public Return_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_return_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterReturn_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitReturn_type(this); + } + } + + public final Return_typeContext return_type() throws RecognitionException { + Return_typeContext _localctx = new Return_typeContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_return_type); + try { + setState(1818); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 206, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1816); + type_(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1817); + match(VOID); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Member_nameContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public Member_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_member_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterMember_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitMember_name(this); + } + } + + public final Member_nameContext member_name() throws RecognitionException { + Member_nameContext _localctx = new Member_nameContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_member_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(1820); + namespace_or_type_name(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Method_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Method_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_method_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterMethod_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitMethod_body(this); + } + } + + public final Method_bodyContext method_body() throws RecognitionException { + Method_bodyContext _localctx = new Method_bodyContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_method_body); + try { + setState(1824); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1822); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1823); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Formal_parameter_listContext extends ParserRuleContext { + public Parameter_arrayContext parameter_array() { + return getRuleContext(Parameter_arrayContext.class, 0); + } + + public Fixed_parametersContext fixed_parameters() { + return getRuleContext(Fixed_parametersContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Formal_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_formal_parameter_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFormal_parameter_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFormal_parameter_list(this); + } + } + + public final Formal_parameter_listContext formal_parameter_list() throws RecognitionException { + Formal_parameter_listContext _localctx = new Formal_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_formal_parameter_list); + int _la; + try { + setState(1832); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 209, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1826); + parameter_array(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1827); + fixed_parameters(); + setState(1830); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1828); + match(COMMA); + setState(1829); + parameter_array(); + } + } + + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_parametersContext extends ParserRuleContext { + public List fixed_parameter() { + return getRuleContexts(Fixed_parameterContext.class); + } + + public Fixed_parameterContext fixed_parameter(int i) { + return getRuleContext(Fixed_parameterContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Fixed_parametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_parameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFixed_parameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFixed_parameters(this); + } + } + + public final Fixed_parametersContext fixed_parameters() throws RecognitionException { + Fixed_parametersContext _localctx = new Fixed_parametersContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_fixed_parameters); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1834); + fixed_parameter(); + setState(1839); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1835); + match(COMMA); + setState(1836); + fixed_parameter(); + } + } + } + setState(1841); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_parameterContext extends ParserRuleContext { + public Arg_declarationContext arg_declaration() { + return getRuleContext(Arg_declarationContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Parameter_modifierContext parameter_modifier() { + return getRuleContext(Parameter_modifierContext.class, 0); + } + + public TerminalNode ARGLIST() { + return getToken(CSharpParser.ARGLIST, 0); + } + + public Fixed_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_parameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterFixed_parameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitFixed_parameter(this); + } + } + + public final Fixed_parameterContext fixed_parameter() throws RecognitionException { + Fixed_parameterContext _localctx = new Fixed_parameterContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_fixed_parameter); + int _la; + try { + setState(1850); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 213, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1843); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1842); + attributes(); + } + } + + setState(1846); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 1099578998785L) != 0)) { + { + setState(1845); + parameter_modifier(); + } + } + + setState(1848); + arg_declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1849); + match(ARGLIST); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Parameter_modifierContext extends ParserRuleContext { + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode OUT() { + return getToken(CSharpParser.OUT, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public Parameter_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parameter_modifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterParameter_modifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitParameter_modifier(this); + } + } + + public final Parameter_modifierContext parameter_modifier() throws RecognitionException { + Parameter_modifierContext _localctx = new Parameter_modifierContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_parameter_modifier); + try { + setState(1860); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 214, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1852); + match(REF); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1853); + match(OUT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1854); + match(IN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1855); + match(REF); + setState(1856); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1857); + match(IN); + setState(1858); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1859); + match(THIS); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Parameter_arrayContext extends ParserRuleContext { + public TerminalNode PARAMS() { + return getToken(CSharpParser.PARAMS, 0); + } + + public Array_typeContext array_type() { + return getRuleContext(Array_typeContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Parameter_arrayContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parameter_array; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterParameter_array(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitParameter_array(this); + } + } + + public final Parameter_arrayContext parameter_array() throws RecognitionException { + Parameter_arrayContext _localctx = new Parameter_arrayContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_parameter_array); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1863); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1862); + attributes(); + } + } + + setState(1865); + match(PARAMS); + setState(1866); + array_type(); + setState(1867); + identifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Accessor_declarationsContext extends ParserRuleContext { + public AttributesContext attrs; + public Accessor_modifierContext mods; + + public TerminalNode GET() { + return getToken(CSharpParser.GET, 0); + } + + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class, 0); + } + + public TerminalNode SET() { + return getToken(CSharpParser.SET, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class, 0); + } + + public Set_accessor_declarationContext set_accessor_declaration() { + return getRuleContext(Set_accessor_declarationContext.class, 0); + } + + public Get_accessor_declarationContext get_accessor_declaration() { + return getRuleContext(Get_accessor_declarationContext.class, 0); + } + + public Accessor_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_accessor_declarations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAccessor_declarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAccessor_declarations(this); + } + } + + public final Accessor_declarationsContext accessor_declarations() throws RecognitionException { + Accessor_declarationsContext _localctx = new Accessor_declarationsContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_accessor_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1870); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1869); + ((Accessor_declarationsContext) _localctx).attrs = attributes(); + } + } + + setState(1873); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 1572865L) != 0)) { + { + setState(1872); + ((Accessor_declarationsContext) _localctx).mods = accessor_modifier(); + } + } + + setState(1885); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GET: { + setState(1875); + match(GET); + setState(1876); + accessor_body(); + setState(1878); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 2251799813686275L) != 0)) { + { + setState(1877); + set_accessor_declaration(); + } + } + + } + break; + case SET: { + setState(1880); + match(SET); + setState(1881); + accessor_body(); + setState(1883); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == GET || _la == INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 2251799813685251L) != 0)) { + { + setState(1882); + get_accessor_declaration(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Get_accessor_declarationContext extends ParserRuleContext { + public TerminalNode GET() { + return getToken(CSharpParser.GET, 0); + } + + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class, 0); + } + + public Get_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_get_accessor_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterGet_accessor_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitGet_accessor_declaration(this); + } + } + + public final Get_accessor_declarationContext get_accessor_declaration() throws RecognitionException { + Get_accessor_declarationContext _localctx = new Get_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_get_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1888); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1887); + attributes(); + } + } + + setState(1891); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 1572865L) != 0)) { + { + setState(1890); + accessor_modifier(); + } + } + + setState(1893); + match(GET); + setState(1894); + accessor_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_accessor_declarationContext extends ParserRuleContext { + public TerminalNode SET() { + return getToken(CSharpParser.SET, 0); + } + + public Accessor_bodyContext accessor_body() { + return getRuleContext(Accessor_bodyContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Accessor_modifierContext accessor_modifier() { + return getRuleContext(Accessor_modifierContext.class, 0); + } + + public Set_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_set_accessor_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterSet_accessor_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitSet_accessor_declaration(this); + } + } + + public final Set_accessor_declarationContext set_accessor_declaration() throws RecognitionException { + Set_accessor_declarationContext _localctx = new Set_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_set_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1897); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1896); + attributes(); + } + } + + setState(1900); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 1572865L) != 0)) { + { + setState(1899); + accessor_modifier(); + } + } + + setState(1902); + match(SET); + setState(1903); + accessor_body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Accessor_modifierContext extends ParserRuleContext { + public TerminalNode PROTECTED() { + return getToken(CSharpParser.PROTECTED, 0); + } + + public TerminalNode INTERNAL() { + return getToken(CSharpParser.INTERNAL, 0); + } + + public TerminalNode PRIVATE() { + return getToken(CSharpParser.PRIVATE, 0); + } + + public Accessor_modifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_accessor_modifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAccessor_modifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAccessor_modifier(this); + } + } + + public final Accessor_modifierContext accessor_modifier() throws RecognitionException { + Accessor_modifierContext _localctx = new Accessor_modifierContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_accessor_modifier); + try { + setState(1912); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 225, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1905); + match(PROTECTED); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1906); + match(INTERNAL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1907); + match(PRIVATE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1908); + match(PROTECTED); + setState(1909); + match(INTERNAL); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1910); + match(INTERNAL); + setState(1911); + match(PROTECTED); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Accessor_bodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Accessor_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_accessor_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAccessor_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAccessor_body(this); + } + } + + public final Accessor_bodyContext accessor_body() throws RecognitionException { + Accessor_bodyContext _localctx = new Accessor_bodyContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_accessor_body); + try { + setState(1916); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1914); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1915); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Event_accessor_declarationsContext extends ParserRuleContext { + public TerminalNode ADD() { + return getToken(CSharpParser.ADD, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Remove_accessor_declarationContext remove_accessor_declaration() { + return getRuleContext(Remove_accessor_declarationContext.class, 0); + } + + public TerminalNode REMOVE() { + return getToken(CSharpParser.REMOVE, 0); + } + + public Add_accessor_declarationContext add_accessor_declaration() { + return getRuleContext(Add_accessor_declarationContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Event_accessor_declarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_event_accessor_declarations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterEvent_accessor_declarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitEvent_accessor_declarations(this); + } + } + + public final Event_accessor_declarationsContext event_accessor_declarations() throws RecognitionException { + Event_accessor_declarationsContext _localctx = new Event_accessor_declarationsContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_event_accessor_declarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1919); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1918); + attributes(); + } + } + + setState(1929); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: { + setState(1921); + match(ADD); + setState(1922); + block(); + setState(1923); + remove_accessor_declaration(); + } + break; + case REMOVE: { + setState(1925); + match(REMOVE); + setState(1926); + block(); + setState(1927); + add_accessor_declaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Add_accessor_declarationContext extends ParserRuleContext { + public TerminalNode ADD() { + return getToken(CSharpParser.ADD, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Add_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_add_accessor_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAdd_accessor_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAdd_accessor_declaration(this); + } + } + + public final Add_accessor_declarationContext add_accessor_declaration() throws RecognitionException { + Add_accessor_declarationContext _localctx = new Add_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_add_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1932); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1931); + attributes(); + } + } + + setState(1934); + match(ADD); + setState(1935); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Remove_accessor_declarationContext extends ParserRuleContext { + public TerminalNode REMOVE() { + return getToken(CSharpParser.REMOVE, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Remove_accessor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_remove_accessor_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterRemove_accessor_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitRemove_accessor_declaration(this); + } + } + + public final Remove_accessor_declarationContext remove_accessor_declaration() throws RecognitionException { + Remove_accessor_declarationContext _localctx = new Remove_accessor_declarationContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_remove_accessor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1938); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1937); + attributes(); + } + } + + setState(1940); + match(REMOVE); + setState(1941); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Overloadable_operatorContext extends ParserRuleContext { + public TerminalNode PLUS() { + return getToken(CSharpParser.PLUS, 0); + } + + public TerminalNode MINUS() { + return getToken(CSharpParser.MINUS, 0); + } + + public TerminalNode BANG() { + return getToken(CSharpParser.BANG, 0); + } + + public TerminalNode TILDE() { + return getToken(CSharpParser.TILDE, 0); + } + + public TerminalNode OP_INC() { + return getToken(CSharpParser.OP_INC, 0); + } + + public TerminalNode OP_DEC() { + return getToken(CSharpParser.OP_DEC, 0); + } + + public TerminalNode TRUE() { + return getToken(CSharpParser.TRUE, 0); + } + + public TerminalNode FALSE() { + return getToken(CSharpParser.FALSE, 0); + } + + public TerminalNode STAR() { + return getToken(CSharpParser.STAR, 0); + } + + public TerminalNode DIV() { + return getToken(CSharpParser.DIV, 0); + } + + public TerminalNode PERCENT() { + return getToken(CSharpParser.PERCENT, 0); + } + + public TerminalNode AMP() { + return getToken(CSharpParser.AMP, 0); + } + + public TerminalNode BITWISE_OR() { + return getToken(CSharpParser.BITWISE_OR, 0); + } + + public TerminalNode CARET() { + return getToken(CSharpParser.CARET, 0); + } + + public TerminalNode OP_LEFT_SHIFT() { + return getToken(CSharpParser.OP_LEFT_SHIFT, 0); + } + + public Right_shiftContext right_shift() { + return getRuleContext(Right_shiftContext.class, 0); + } + + public TerminalNode OP_EQ() { + return getToken(CSharpParser.OP_EQ, 0); + } + + public TerminalNode OP_NE() { + return getToken(CSharpParser.OP_NE, 0); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public TerminalNode LT() { + return getToken(CSharpParser.LT, 0); + } + + public TerminalNode OP_GE() { + return getToken(CSharpParser.OP_GE, 0); + } + + public TerminalNode OP_LE() { + return getToken(CSharpParser.OP_LE, 0); + } + + public Overloadable_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_overloadable_operator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterOverloadable_operator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitOverloadable_operator(this); + } + } + + public final Overloadable_operatorContext overloadable_operator() throws RecognitionException { + Overloadable_operatorContext _localctx = new Overloadable_operatorContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_overloadable_operator); + try { + setState(1965); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 231, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1943); + match(PLUS); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1944); + match(MINUS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1945); + match(BANG); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1946); + match(TILDE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1947); + match(OP_INC); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1948); + match(OP_DEC); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1949); + match(TRUE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1950); + match(FALSE); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1951); + match(STAR); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1952); + match(DIV); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1953); + match(PERCENT); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1954); + match(AMP); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1955); + match(BITWISE_OR); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1956); + match(CARET); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1957); + match(OP_LEFT_SHIFT); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(1958); + right_shift(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1959); + match(OP_EQ); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(1960); + match(OP_NE); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(1961); + match(GT); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(1962); + match(LT); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(1963); + match(OP_GE); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(1964); + match(OP_LE); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Conversion_operator_declaratorContext extends ParserRuleContext { + public TerminalNode OPERATOR() { + return getToken(CSharpParser.OPERATOR, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public Arg_declarationContext arg_declaration() { + return getRuleContext(Arg_declarationContext.class, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode IMPLICIT() { + return getToken(CSharpParser.IMPLICIT, 0); + } + + public TerminalNode EXPLICIT() { + return getToken(CSharpParser.EXPLICIT, 0); + } + + public Conversion_operator_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conversion_operator_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConversion_operator_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConversion_operator_declarator(this); + } + } + + public final Conversion_operator_declaratorContext conversion_operator_declarator() throws RecognitionException { + Conversion_operator_declaratorContext _localctx = new Conversion_operator_declaratorContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_conversion_operator_declarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1967); + _la = _input.LA(1); + if (!(_la == EXPLICIT || _la == IMPLICIT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1968); + match(OPERATOR); + setState(1969); + type_(); + setState(1970); + match(OPEN_PARENS); + setState(1971); + arg_declaration(); + setState(1972); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constructor_initializerContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode BASE() { + return getToken(CSharpParser.BASE, 0); + } + + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class, 0); + } + + public Constructor_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constructor_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstructor_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstructor_initializer(this); + } + } + + public final Constructor_initializerContext constructor_initializer() throws RecognitionException { + Constructor_initializerContext _localctx = new Constructor_initializerContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_constructor_initializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1974); + match(COLON); + setState(1975); + _la = _input.LA(1); + if (!(_la == BASE || _la == THIS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1976); + match(OPEN_PARENS); + setState(1978); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5419197809667089408L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305514793348041149L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(1977); + argument_list(); + } + } + + setState(1980); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public BodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitBody(this); + } + } + + public final BodyContext body() throws RecognitionException { + BodyContext _localctx = new BodyContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_body); + try { + setState(1984); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(1982); + block(); + } + break; + case SEMICOLON: + enterOuterAlt(_localctx, 2); + { + setState(1983); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Struct_interfacesContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Interface_type_listContext interface_type_list() { + return getRuleContext(Interface_type_listContext.class, 0); + } + + public Struct_interfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_struct_interfaces; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterStruct_interfaces(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitStruct_interfaces(this); + } + } + + public final Struct_interfacesContext struct_interfaces() throws RecognitionException { + Struct_interfacesContext _localctx = new Struct_interfacesContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_struct_interfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(1986); + match(COLON); + setState(1987); + interface_type_list(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Struct_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List struct_member_declaration() { + return getRuleContexts(Struct_member_declarationContext.class); + } + + public Struct_member_declarationContext struct_member_declaration(int i) { + return getRuleContext(Struct_member_declarationContext.class, i); + } + + public Struct_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_struct_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterStruct_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitStruct_body(this); + } + } + + public final Struct_bodyContext struct_body() throws RecognitionException { + Struct_bodyContext _localctx = new Struct_bodyContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_struct_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1989); + match(OPEN_BRACE); + setState(1993); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & 6547061340561119983L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 90075836208545277L) != 0)) { + { + { + setState(1990); + struct_member_declaration(); + } + } + setState(1995); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1996); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Struct_member_declarationContext extends ParserRuleContext { + public Common_member_declarationContext common_member_declaration() { + return getRuleContext(Common_member_declarationContext.class, 0); + } + + public TerminalNode FIXED() { + return getToken(CSharpParser.FIXED, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public All_member_modifiersContext all_member_modifiers() { + return getRuleContext(All_member_modifiersContext.class, 0); + } + + public List fixed_size_buffer_declarator() { + return getRuleContexts(Fixed_size_buffer_declaratorContext.class); + } + + public Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator(int i) { + return getRuleContext(Fixed_size_buffer_declaratorContext.class, i); + } + + public Struct_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_struct_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterStruct_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitStruct_member_declaration(this); + } + } + + public final Struct_member_declarationContext struct_member_declaration() throws RecognitionException { + Struct_member_declarationContext _localctx = new Struct_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_struct_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1999); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(1998); + attributes(); + } + } + + setState(2002); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 236, _ctx)) { + case 1: { + setState(2001); + all_member_modifiers(); + } + break; + } + setState(2014); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CLASS: + case CONST: + case DECIMAL: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case ENUM: + case EQUALS: + case EVENT: + case EXPLICIT: + case FLOAT: + case FROM: + case GET: + case GROUP: + case IMPLICIT: + case INT: + case INTERFACE: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case READONLY: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case STRUCT: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case VOID: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case OPEN_PARENS: { + setState(2004); + common_member_declaration(); + } + break; + case FIXED: { + setState(2005); + match(FIXED); + setState(2006); + type_(); + setState(2008); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2007); + fixed_size_buffer_declarator(); + } + } + setState(2010); + _errHandler.sync(this); + _la = _input.LA(1); + } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1904629023639713L) != 0)); + setState(2012); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Array_typeContext extends ParserRuleContext { + public Base_typeContext base_type() { + return getRuleContext(Base_typeContext.class, 0); + } + + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class, i); + } + + public List STAR() { + return getTokens(CSharpParser.STAR); + } + + public TerminalNode STAR(int i) { + return getToken(CSharpParser.STAR, i); + } + + public List INTERR() { + return getTokens(CSharpParser.INTERR); + } + + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + + public Array_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_array_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterArray_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitArray_type(this); + } + } + + public final Array_typeContext array_type() throws RecognitionException { + Array_typeContext _localctx = new Array_typeContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_array_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2016); + base_type(); + setState(2024); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2020); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == STAR || _la == INTERR) { + { + { + setState(2017); + _la = _input.LA(1); + if (!(_la == STAR || _la == INTERR)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(2022); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2023); + rank_specifier(); + } + } + setState(2026); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 127)) & ~0x3f) == 0 && ((1L << (_la - 127)) & 2098177L) != 0)); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Rank_specifierContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Rank_specifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_rank_specifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterRank_specifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitRank_specifier(this); + } + } + + public final Rank_specifierContext rank_specifier() throws RecognitionException { + Rank_specifierContext _localctx = new Rank_specifierContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_rank_specifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2028); + match(OPEN_BRACKET); + setState(2032); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2029); + match(COMMA); + } + } + setState(2034); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2035); + match(CLOSE_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Array_initializerContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List variable_initializer() { + return getRuleContexts(Variable_initializerContext.class); + } + + public Variable_initializerContext variable_initializer(int i) { + return getRuleContext(Variable_initializerContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Array_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_array_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterArray_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitArray_initializer(this); + } + } + + public final Array_initializerContext array_initializer() throws RecognitionException { + Array_initializerContext _localctx = new Array_initializerContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_array_initializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2037); + match(OPEN_BRACE); + setState(2049); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4611340210375690429L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(2038); + variable_initializer(); + setState(2043); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 242, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2039); + match(COMMA); + setState(2040); + variable_initializer(); + } + } + } + setState(2045); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 242, _ctx); + } + setState(2047); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2046); + match(COMMA); + } + } + + } + } + + setState(2051); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variant_type_parameter_listContext extends ParserRuleContext { + public TerminalNode LT() { + return getToken(CSharpParser.LT, 0); + } + + public List variant_type_parameter() { + return getRuleContexts(Variant_type_parameterContext.class); + } + + public Variant_type_parameterContext variant_type_parameter(int i) { + return getRuleContext(Variant_type_parameterContext.class, i); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Variant_type_parameter_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variant_type_parameter_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariant_type_parameter_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariant_type_parameter_list(this); + } + } + + public final Variant_type_parameter_listContext variant_type_parameter_list() throws RecognitionException { + Variant_type_parameter_listContext _localctx = new Variant_type_parameter_listContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_variant_type_parameter_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2053); + match(LT); + setState(2054); + variant_type_parameter(); + setState(2059); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2055); + match(COMMA); + setState(2056); + variant_type_parameter(); + } + } + setState(2061); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2062); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variant_type_parameterContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public Variance_annotationContext variance_annotation() { + return getRuleContext(Variance_annotationContext.class, 0); + } + + public Variant_type_parameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variant_type_parameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariant_type_parameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariant_type_parameter(this); + } + } + + public final Variant_type_parameterContext variant_type_parameter() throws RecognitionException { + Variant_type_parameterContext _localctx = new Variant_type_parameterContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_variant_type_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2065); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2064); + attributes(); + } + } + + setState(2068); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == IN || _la == OUT) { + { + setState(2067); + variance_annotation(); + } + } + + setState(2070); + identifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Variance_annotationContext extends ParserRuleContext { + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public TerminalNode OUT() { + return getToken(CSharpParser.OUT, 0); + } + + public Variance_annotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variance_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterVariance_annotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitVariance_annotation(this); + } + } + + public final Variance_annotationContext variance_annotation() throws RecognitionException { + Variance_annotationContext _localctx = new Variance_annotationContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_variance_annotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2072); + _la = _input.LA(1); + if (!(_la == IN || _la == OUT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_baseContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Interface_type_listContext interface_type_list() { + return getRuleContext(Interface_type_listContext.class, 0); + } + + public Interface_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_base; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterInterface_base(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitInterface_base(this); + } + } + + public final Interface_baseContext interface_base() throws RecognitionException { + Interface_baseContext _localctx = new Interface_baseContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_interface_base); + try { + enterOuterAlt(_localctx, 1); + { + setState(2074); + match(COLON); + setState(2075); + interface_type_list(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List interface_member_declaration() { + return getRuleContexts(Interface_member_declarationContext.class); + } + + public Interface_member_declarationContext interface_member_declaration(int i) { + return getRuleContext(Interface_member_declarationContext.class, i); + } + + public Interface_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterInterface_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitInterface_body(this); + } + } + + public final Interface_bodyContext interface_body() throws RecognitionException { + Interface_bodyContext _localctx = new Interface_bodyContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_interface_body); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2077); + match(OPEN_BRACE); + setState(2081); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 3273310747417398647L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & 22518937577135473L) != 0)) { + { + { + setState(2078); + interface_member_declaration(); + } + } + setState(2083); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2084); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_member_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public TerminalNode EVENT() { + return getToken(CSharpParser.EVENT, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public TerminalNode NEW() { + return getToken(CSharpParser.NEW, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public Interface_accessorsContext interface_accessors() { + return getRuleContext(Interface_accessorsContext.class, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public TerminalNode UNSAFE() { + return getToken(CSharpParser.UNSAFE, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public Interface_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterface_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterface_member_declaration(this); + } + } + + public final Interface_member_declarationContext interface_member_declaration() throws RecognitionException { + Interface_member_declarationContext _localctx = new Interface_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_interface_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2087); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2086); + attributes(); + } + } + + setState(2090); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == NEW) { + { + setState(2089); + match(NEW); + } + } + + setState(2155); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 261, _ctx)) { + case 1: { + setState(2093); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == UNSAFE) { + { + setState(2092); + match(UNSAFE); + } + } + + setState(2100); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 252, _ctx)) { + case 1: { + setState(2095); + match(REF); + } + break; + case 2: { + setState(2096); + match(REF); + setState(2097); + match(READONLY); + } + break; + case 3: { + setState(2098); + match(READONLY); + setState(2099); + match(REF); + } + break; + } + setState(2102); + type_(); + setState(2130); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 256, _ctx)) { + case 1: { + setState(2103); + identifier(); + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2104); + type_parameter_list(); + } + } + + setState(2107); + match(OPEN_PARENS); + setState(2109); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(2108); + formal_parameter_list(); + } + } + + setState(2111); + match(CLOSE_PARENS); + setState(2113); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2112); + type_parameter_constraints_clauses(); + } + } + + setState(2115); + match(SEMICOLON); + } + break; + case 2: { + setState(2117); + identifier(); + setState(2118); + match(OPEN_BRACE); + setState(2119); + interface_accessors(); + setState(2120); + match(CLOSE_BRACE); + } + break; + case 3: { + setState(2122); + match(THIS); + setState(2123); + match(OPEN_BRACKET); + setState(2124); + formal_parameter_list(); + setState(2125); + match(CLOSE_BRACKET); + setState(2126); + match(OPEN_BRACE); + setState(2127); + interface_accessors(); + setState(2128); + match(CLOSE_BRACE); + } + break; + } + } + break; + case 2: { + setState(2133); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == UNSAFE) { + { + setState(2132); + match(UNSAFE); + } + } + + setState(2135); + match(VOID); + setState(2136); + identifier(); + setState(2138); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2137); + type_parameter_list(); + } + } + + setState(2140); + match(OPEN_PARENS); + setState(2142); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(2141); + formal_parameter_list(); + } + } + + setState(2144); + match(CLOSE_PARENS); + setState(2146); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2145); + type_parameter_constraints_clauses(); + } + } + + setState(2148); + match(SEMICOLON); + } + break; + case 3: { + setState(2150); + match(EVENT); + setState(2151); + type_(); + setState(2152); + identifier(); + setState(2153); + match(SEMICOLON); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_accessorsContext extends ParserRuleContext { + public TerminalNode GET() { + return getToken(CSharpParser.GET, 0); + } + + public List SEMICOLON() { + return getTokens(CSharpParser.SEMICOLON); + } + + public TerminalNode SEMICOLON(int i) { + return getToken(CSharpParser.SEMICOLON, i); + } + + public TerminalNode SET() { + return getToken(CSharpParser.SET, 0); + } + + public List attributes() { + return getRuleContexts(AttributesContext.class); + } + + public AttributesContext attributes(int i) { + return getRuleContext(AttributesContext.class, i); + } + + public Interface_accessorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_accessors; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterface_accessors(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterface_accessors(this); + } + } + + public final Interface_accessorsContext interface_accessors() throws RecognitionException { + Interface_accessorsContext _localctx = new Interface_accessorsContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_interface_accessors); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2158); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2157); + attributes(); + } + } + + setState(2178); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GET: { + setState(2160); + match(GET); + setState(2161); + match(SEMICOLON); + setState(2167); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SET || _la == OPEN_BRACKET) { + { + setState(2163); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2162); + attributes(); + } + } + + setState(2165); + match(SET); + setState(2166); + match(SEMICOLON); + } + } + + } + break; + case SET: { + setState(2169); + match(SET); + setState(2170); + match(SEMICOLON); + setState(2176); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == GET || _la == OPEN_BRACKET) { + { + setState(2172); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2171); + attributes(); + } + } + + setState(2174); + match(GET); + setState(2175); + match(SEMICOLON); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enum_baseContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Enum_baseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enum_base; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterEnum_base(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitEnum_base(this); + } + } + + public final Enum_baseContext enum_base() throws RecognitionException { + Enum_baseContext _localctx = new Enum_baseContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_enum_base); + try { + enterOuterAlt(_localctx, 1); + { + setState(2180); + match(COLON); + setState(2181); + type_(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enum_bodyContext extends ParserRuleContext { + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List enum_member_declaration() { + return getRuleContexts(Enum_member_declarationContext.class); + } + + public Enum_member_declarationContext enum_member_declaration(int i) { + return getRuleContext(Enum_member_declarationContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Enum_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enum_body; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterEnum_body(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitEnum_body(this); + } + } + + public final Enum_bodyContext enum_body() throws RecognitionException { + Enum_bodyContext _localctx = new Enum_bodyContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_enum_body); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2183); + match(OPEN_BRACE); + setState(2195); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -9221467407831136095L) != 0)) { + { + setState(2184); + enum_member_declaration(); + setState(2189); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 268, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2185); + match(COMMA); + setState(2186); + enum_member_declaration(); + } + } + } + setState(2191); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 268, _ctx); + } + setState(2193); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2192); + match(COMMA); + } + } + + } + } + + setState(2197); + match(CLOSE_BRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enum_member_declarationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Enum_member_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enum_member_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterEnum_member_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitEnum_member_declaration(this); + } + } + + public final Enum_member_declarationContext enum_member_declaration() throws RecognitionException { + Enum_member_declarationContext _localctx = new Enum_member_declarationContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_enum_member_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2200); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACKET) { + { + setState(2199); + attributes(); + } + } + + setState(2202); + identifier(); + setState(2205); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(2203); + match(ASSIGNMENT); + setState(2204); + expression(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Global_attribute_sectionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Global_attribute_targetContext global_attribute_target() { + return getRuleContext(Global_attribute_targetContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Attribute_listContext attribute_list() { + return getRuleContext(Attribute_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Global_attribute_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_global_attribute_section; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterGlobal_attribute_section(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitGlobal_attribute_section(this); + } + } + + public final Global_attribute_sectionContext global_attribute_section() throws RecognitionException { + Global_attribute_sectionContext _localctx = new Global_attribute_sectionContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_global_attribute_section); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2207); + match(OPEN_BRACKET); + setState(2208); + global_attribute_target(); + setState(2209); + match(COLON); + setState(2210); + attribute_list(); + setState(2212); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2211); + match(COMMA); + } + } + + setState(2214); + match(CLOSE_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Global_attribute_targetContext extends ParserRuleContext { + public KeywordContext keyword() { + return getRuleContext(KeywordContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Global_attribute_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_global_attribute_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterGlobal_attribute_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitGlobal_attribute_target(this); + } + } + + public final Global_attribute_targetContext global_attribute_target() throws RecognitionException { + Global_attribute_targetContext _localctx = new Global_attribute_targetContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_global_attribute_target); + try { + setState(2218); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 274, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2216); + keyword(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2217); + identifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AttributesContext extends ParserRuleContext { + public List attribute_section() { + return getRuleContexts(Attribute_sectionContext.class); + } + + public Attribute_sectionContext attribute_section(int i) { + return getRuleContext(Attribute_sectionContext.class, i); + } + + public AttributesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attributes; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAttributes(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAttributes(this); + } + } + + public final AttributesContext attributes() throws RecognitionException { + AttributesContext _localctx = new AttributesContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_attributes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2221); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2220); + attribute_section(); + } + } + setState(2223); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == OPEN_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attribute_sectionContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Attribute_listContext attribute_list() { + return getRuleContext(Attribute_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public Attribute_targetContext attribute_target() { + return getRuleContext(Attribute_targetContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Attribute_sectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attribute_section; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAttribute_section(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAttribute_section(this); + } + } + + public final Attribute_sectionContext attribute_section() throws RecognitionException { + Attribute_sectionContext _localctx = new Attribute_sectionContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_attribute_section); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2225); + match(OPEN_BRACKET); + setState(2229); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 276, _ctx)) { + case 1: { + setState(2226); + attribute_target(); + setState(2227); + match(COLON); + } + break; + } + setState(2231); + attribute_list(); + setState(2233); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2232); + match(COMMA); + } + } + + setState(2235); + match(CLOSE_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attribute_targetContext extends ParserRuleContext { + public KeywordContext keyword() { + return getRuleContext(KeywordContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Attribute_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attribute_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAttribute_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAttribute_target(this); + } + } + + public final Attribute_targetContext attribute_target() throws RecognitionException { + Attribute_targetContext _localctx = new Attribute_targetContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_attribute_target); + try { + setState(2239); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 278, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2237); + keyword(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2238); + identifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attribute_listContext extends ParserRuleContext { + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Attribute_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attribute_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAttribute_list(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAttribute_list(this); + } + } + + public final Attribute_listContext attribute_list() throws RecognitionException { + Attribute_listContext _localctx = new Attribute_listContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_attribute_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2241); + attribute(); + setState(2246); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 279, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2242); + match(COMMA); + setState(2243); + attribute(); + } + } + } + setState(2248); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 279, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AttributeContext extends ParserRuleContext { + public Namespace_or_type_nameContext namespace_or_type_name() { + return getRuleContext(Namespace_or_type_nameContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public List attribute_argument() { + return getRuleContexts(Attribute_argumentContext.class); + } + + public Attribute_argumentContext attribute_argument(int i) { + return getRuleContext(Attribute_argumentContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attribute; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterAttribute(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitAttribute(this); + } + } + + public final AttributeContext attribute() throws RecognitionException { + AttributeContext _localctx = new AttributeContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_attribute); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2249); + namespace_or_type_name(); + setState(2262); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_PARENS) { + { + setState(2250); + match(OPEN_PARENS); + setState(2259); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(2251); + attribute_argument(); + setState(2256); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2252); + match(COMMA); + setState(2253); + attribute_argument(); + } + } + setState(2258); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(2261); + match(CLOSE_PARENS); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attribute_argumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public Attribute_argumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attribute_argument; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterAttribute_argument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitAttribute_argument(this); + } + } + + public final Attribute_argumentContext attribute_argument() throws RecognitionException { + Attribute_argumentContext _localctx = new Attribute_argumentContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_attribute_argument); + try { + enterOuterAlt(_localctx, 1); + { + setState(2267); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 283, _ctx)) { + case 1: { + setState(2264); + identifier(); + setState(2265); + match(COLON); + } + break; + } + setState(2269); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Pointer_typeContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(CSharpParser.STAR, 0); + } + + public Simple_typeContext simple_type() { + return getRuleContext(Simple_typeContext.class, 0); + } + + public Class_typeContext class_type() { + return getRuleContext(Class_typeContext.class, 0); + } + + public List rank_specifier() { + return getRuleContexts(Rank_specifierContext.class); + } + + public Rank_specifierContext rank_specifier(int i) { + return getRuleContext(Rank_specifierContext.class, i); + } + + public List INTERR() { + return getTokens(CSharpParser.INTERR); + } + + public TerminalNode INTERR(int i) { + return getToken(CSharpParser.INTERR, i); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public Pointer_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_pointer_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterPointer_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitPointer_type(this); + } + } + + public final Pointer_typeContext pointer_type() throws RecognitionException { + Pointer_typeContext _localctx = new Pointer_typeContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_pointer_type); + int _la; + try { + setState(2286); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BOOL: + case BY: + case BYTE: + case CHAR: + case DECIMAL: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case STRING: + case UINT: + case ULONG: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(2273); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOL: + case BYTE: + case CHAR: + case DECIMAL: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SBYTE: + case SHORT: + case UINT: + case ULONG: + case USHORT: { + setState(2271); + simple_type(); + } + break; + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BY: + case DESCENDING: + case DYNAMIC: + case EQUALS: + case FROM: + case GET: + case GROUP: + case INTO: + case JOIN: + case LET: + case NAMEOF: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REMOVE: + case SELECT: + case SET: + case STRING: + case UNMANAGED: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: { + setState(2272); + class_type(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2279); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OPEN_BRACKET || _la == INTERR) { + { + setState(2277); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACKET: { + setState(2275); + rank_specifier(); + } + break; + case INTERR: { + setState(2276); + match(INTERR); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(2281); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2282); + match(STAR); + } + break; + case VOID: + enterOuterAlt(_localctx, 2); + { + setState(2284); + match(VOID); + setState(2285); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_pointer_declaratorsContext extends ParserRuleContext { + public List fixed_pointer_declarator() { + return getRuleContexts(Fixed_pointer_declaratorContext.class); + } + + public Fixed_pointer_declaratorContext fixed_pointer_declarator(int i) { + return getRuleContext(Fixed_pointer_declaratorContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Fixed_pointer_declaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_pointer_declarators; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFixed_pointer_declarators(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFixed_pointer_declarators(this); + } + } + + public final Fixed_pointer_declaratorsContext fixed_pointer_declarators() throws RecognitionException { + Fixed_pointer_declaratorsContext _localctx = new Fixed_pointer_declaratorsContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_fixed_pointer_declarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2288); + fixed_pointer_declarator(); + setState(2293); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2289); + match(COMMA); + setState(2290); + fixed_pointer_declarator(); + } + } + setState(2295); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_pointer_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Fixed_pointer_initializerContext fixed_pointer_initializer() { + return getRuleContext(Fixed_pointer_initializerContext.class, 0); + } + + public Fixed_pointer_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_pointer_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFixed_pointer_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFixed_pointer_declarator(this); + } + } + + public final Fixed_pointer_declaratorContext fixed_pointer_declarator() throws RecognitionException { + Fixed_pointer_declaratorContext _localctx = new Fixed_pointer_declaratorContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_fixed_pointer_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(2296); + identifier(); + setState(2297); + match(ASSIGNMENT); + setState(2298); + fixed_pointer_initializer(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_pointer_initializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode AMP() { + return getToken(CSharpParser.AMP, 0); + } + + public Stackalloc_initializerContext stackalloc_initializer() { + return getRuleContext(Stackalloc_initializerContext.class, 0); + } + + public Fixed_pointer_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_pointer_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFixed_pointer_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFixed_pointer_initializer(this); + } + } + + public final Fixed_pointer_initializerContext fixed_pointer_initializer() throws RecognitionException { + Fixed_pointer_initializerContext _localctx = new Fixed_pointer_initializerContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_fixed_pointer_initializer); + try { + setState(2305); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2301); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 289, _ctx)) { + case 1: { + setState(2300); + match(AMP); + } + break; + } + setState(2303); + expression(); + } + break; + case STACKALLOC: + enterOuterAlt(_localctx, 2); + { + setState(2304); + stackalloc_initializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fixed_size_buffer_declaratorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public Fixed_size_buffer_declaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fixed_size_buffer_declarator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterFixed_size_buffer_declarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitFixed_size_buffer_declarator(this); + } + } + + public final Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator() throws RecognitionException { + Fixed_size_buffer_declaratorContext _localctx = new Fixed_size_buffer_declaratorContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_fixed_size_buffer_declarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(2307); + identifier(); + setState(2308); + match(OPEN_BRACKET); + setState(2309); + expression(); + setState(2310); + match(CLOSE_BRACKET); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stackalloc_initializerContext extends ParserRuleContext { + public TerminalNode STACKALLOC() { + return getToken(CSharpParser.STACKALLOC, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public Stackalloc_initializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_stackalloc_initializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterStackalloc_initializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitStackalloc_initializer(this); + } + } + + public final Stackalloc_initializerContext stackalloc_initializer() throws RecognitionException { + Stackalloc_initializerContext _localctx = new Stackalloc_initializerContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_stackalloc_initializer); + int _la; + try { + int _alt; + setState(2341); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 295, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2312); + match(STACKALLOC); + setState(2313); + type_(); + setState(2314); + match(OPEN_BRACKET); + setState(2315); + expression(); + setState(2316); + match(CLOSE_BRACKET); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2318); + match(STACKALLOC); + setState(2320); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 3201253152842599799L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & 18015337681329473L) != 0)) { + { + setState(2319); + type_(); + } + } + + setState(2322); + match(OPEN_BRACKET); + setState(2324); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(2323); + expression(); + } + } + + setState(2326); + match(CLOSE_BRACKET); + setState(2327); + match(OPEN_BRACE); + setState(2328); + expression(); + setState(2333); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 293, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2329); + match(COMMA); + setState(2330); + expression(); + } + } + } + setState(2335); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 293, _ctx); + } + setState(2337); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2336); + match(COMMA); + } + } + + setState(2339); + match(CLOSE_BRACE); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Right_arrowContext extends ParserRuleContext { + public Token first; + public Token second; + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public Right_arrowContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_right_arrow; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterRight_arrow(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitRight_arrow(this); + } + } + + public final Right_arrowContext right_arrow() throws RecognitionException { + Right_arrowContext _localctx = new Right_arrowContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_right_arrow); + try { + enterOuterAlt(_localctx, 1); + { + setState(2343); + ((Right_arrowContext) _localctx).first = match(ASSIGNMENT); + setState(2344); + ((Right_arrowContext) _localctx).second = match(GT); + setState(2345); + if (!((((Right_arrowContext) _localctx).first != null ? ((Right_arrowContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_arrowContext) _localctx).second != null ? ((Right_arrowContext) _localctx).second.getTokenIndex() : 0))) + throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Right_shiftContext extends ParserRuleContext { + public Token first; + public Token second; + + public List GT() { + return getTokens(CSharpParser.GT); + } + + public TerminalNode GT(int i) { + return getToken(CSharpParser.GT, i); + } + + public Right_shiftContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_right_shift; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterRight_shift(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitRight_shift(this); + } + } + + public final Right_shiftContext right_shift() throws RecognitionException { + Right_shiftContext _localctx = new Right_shiftContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_right_shift); + try { + enterOuterAlt(_localctx, 1); + { + setState(2347); + ((Right_shiftContext) _localctx).first = match(GT); + setState(2348); + ((Right_shiftContext) _localctx).second = match(GT); + setState(2349); + if (!((((Right_shiftContext) _localctx).first != null ? ((Right_shiftContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_shiftContext) _localctx).second != null ? ((Right_shiftContext) _localctx).second.getTokenIndex() : 0))) + throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Right_shift_assignmentContext extends ParserRuleContext { + public Token first; + public Token second; + + public TerminalNode GT() { + return getToken(CSharpParser.GT, 0); + } + + public TerminalNode OP_GE() { + return getToken(CSharpParser.OP_GE, 0); + } + + public Right_shift_assignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_right_shift_assignment; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterRight_shift_assignment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitRight_shift_assignment(this); + } + } + + public final Right_shift_assignmentContext right_shift_assignment() throws RecognitionException { + Right_shift_assignmentContext _localctx = new Right_shift_assignmentContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_right_shift_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(2351); + ((Right_shift_assignmentContext) _localctx).first = match(GT); + setState(2352); + ((Right_shift_assignmentContext) _localctx).second = match(OP_GE); + setState(2353); + if (!((((Right_shift_assignmentContext) _localctx).first != null ? ((Right_shift_assignmentContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_shift_assignmentContext) _localctx).second != null ? ((Right_shift_assignmentContext) _localctx).second.getTokenIndex() : 0))) + throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralContext extends ParserRuleContext { + public Boolean_literalContext boolean_literal() { + return getRuleContext(Boolean_literalContext.class, 0); + } + + public String_literalContext string_literal() { + return getRuleContext(String_literalContext.class, 0); + } + + public TerminalNode INTEGER_LITERAL() { + return getToken(CSharpParser.INTEGER_LITERAL, 0); + } + + public TerminalNode HEX_INTEGER_LITERAL() { + return getToken(CSharpParser.HEX_INTEGER_LITERAL, 0); + } + + public TerminalNode BIN_INTEGER_LITERAL() { + return getToken(CSharpParser.BIN_INTEGER_LITERAL, 0); + } + + public TerminalNode REAL_LITERAL() { + return getToken(CSharpParser.REAL_LITERAL, 0); + } + + public TerminalNode CHARACTER_LITERAL() { + return getToken(CSharpParser.CHARACTER_LITERAL, 0); + } + + public TerminalNode NULL() { + return getToken(CSharpParser.NULL, 0); + } + + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_literal; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitLiteral(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_literal); + try { + setState(2363); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FALSE: + case TRUE: + enterOuterAlt(_localctx, 1); + { + setState(2355); + boolean_literal(); + } + break; + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + enterOuterAlt(_localctx, 2); + { + setState(2356); + string_literal(); + } + break; + case INTEGER_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(2357); + match(INTEGER_LITERAL); + } + break; + case HEX_INTEGER_LITERAL: + enterOuterAlt(_localctx, 4); + { + setState(2358); + match(HEX_INTEGER_LITERAL); + } + break; + case BIN_INTEGER_LITERAL: + enterOuterAlt(_localctx, 5); + { + setState(2359); + match(BIN_INTEGER_LITERAL); + } + break; + case REAL_LITERAL: + enterOuterAlt(_localctx, 6); + { + setState(2360); + match(REAL_LITERAL); + } + break; + case CHARACTER_LITERAL: + enterOuterAlt(_localctx, 7); + { + setState(2361); + match(CHARACTER_LITERAL); + } + break; + case NULL: + enterOuterAlt(_localctx, 8); + { + setState(2362); + match(NULL); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Boolean_literalContext extends ParserRuleContext { + public TerminalNode TRUE() { + return getToken(CSharpParser.TRUE, 0); + } + + public TerminalNode FALSE() { + return getToken(CSharpParser.FALSE, 0); + } + + public Boolean_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_boolean_literal; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterBoolean_literal(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitBoolean_literal(this); + } + } + + public final Boolean_literalContext boolean_literal() throws RecognitionException { + Boolean_literalContext _localctx = new Boolean_literalContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_boolean_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2365); + _la = _input.LA(1); + if (!(_la == FALSE || _la == TRUE)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class String_literalContext extends ParserRuleContext { + public Interpolated_regular_stringContext interpolated_regular_string() { + return getRuleContext(Interpolated_regular_stringContext.class, 0); + } + + public Interpolated_verbatium_stringContext interpolated_verbatium_string() { + return getRuleContext(Interpolated_verbatium_stringContext.class, 0); + } + + public TerminalNode REGULAR_STRING() { + return getToken(CSharpParser.REGULAR_STRING, 0); + } + + public TerminalNode VERBATIUM_STRING() { + return getToken(CSharpParser.VERBATIUM_STRING, 0); + } + + public String_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_string_literal; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterString_literal(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitString_literal(this); + } + } + + public final String_literalContext string_literal() throws RecognitionException { + String_literalContext _localctx = new String_literalContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_string_literal); + try { + setState(2371); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTERPOLATED_REGULAR_STRING_START: + enterOuterAlt(_localctx, 1); + { + setState(2367); + interpolated_regular_string(); + } + break; + case INTERPOLATED_VERBATIUM_STRING_START: + enterOuterAlt(_localctx, 2); + { + setState(2368); + interpolated_verbatium_string(); + } + break; + case REGULAR_STRING: + enterOuterAlt(_localctx, 3); + { + setState(2369); + match(REGULAR_STRING); + } + break; + case VERBATIUM_STRING: + enterOuterAlt(_localctx, 4); + { + setState(2370); + match(VERBATIUM_STRING); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interpolated_regular_stringContext extends ParserRuleContext { + public TerminalNode INTERPOLATED_REGULAR_STRING_START() { + return getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0); + } + + public TerminalNode DOUBLE_QUOTE_INSIDE() { + return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); + } + + public List interpolated_regular_string_part() { + return getRuleContexts(Interpolated_regular_string_partContext.class); + } + + public Interpolated_regular_string_partContext interpolated_regular_string_part(int i) { + return getRuleContext(Interpolated_regular_string_partContext.class, i); + } + + public Interpolated_regular_stringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interpolated_regular_string; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterpolated_regular_string(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterpolated_regular_string(this); + } + } + + public final Interpolated_regular_stringContext interpolated_regular_string() throws RecognitionException { + Interpolated_regular_stringContext _localctx = new Interpolated_regular_stringContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_interpolated_regular_string); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2373); + match(INTERPOLATED_REGULAR_STRING_START); + setState(2377); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 329853500975553L) != 0)) { + { + { + setState(2374); + interpolated_regular_string_part(); + } + } + setState(2379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2380); + match(DOUBLE_QUOTE_INSIDE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interpolated_verbatium_stringContext extends ParserRuleContext { + public TerminalNode INTERPOLATED_VERBATIUM_STRING_START() { + return getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0); + } + + public TerminalNode DOUBLE_QUOTE_INSIDE() { + return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); + } + + public List interpolated_verbatium_string_part() { + return getRuleContexts(Interpolated_verbatium_string_partContext.class); + } + + public Interpolated_verbatium_string_partContext interpolated_verbatium_string_part(int i) { + return getRuleContext(Interpolated_verbatium_string_partContext.class, i); + } + + public Interpolated_verbatium_stringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interpolated_verbatium_string; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterpolated_verbatium_string(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterpolated_verbatium_string(this); + } + } + + public final Interpolated_verbatium_stringContext interpolated_verbatium_string() throws RecognitionException { + Interpolated_verbatium_stringContext _localctx = new Interpolated_verbatium_stringContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_interpolated_verbatium_string); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2382); + match(INTERPOLATED_VERBATIUM_STRING_START); + setState(2386); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5437212208176571392L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305497201161996477L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 646512849775041L) != 0)) { + { + { + setState(2383); + interpolated_verbatium_string_part(); + } + } + setState(2388); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2389); + match(DOUBLE_QUOTE_INSIDE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interpolated_regular_string_partContext extends ParserRuleContext { + public Interpolated_string_expressionContext interpolated_string_expression() { + return getRuleContext(Interpolated_string_expressionContext.class, 0); + } + + public TerminalNode DOUBLE_CURLY_INSIDE() { + return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); + } + + public TerminalNode REGULAR_CHAR_INSIDE() { + return getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0); + } + + public TerminalNode REGULAR_STRING_INSIDE() { + return getToken(CSharpParser.REGULAR_STRING_INSIDE, 0); + } + + public Interpolated_regular_string_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interpolated_regular_string_part; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterpolated_regular_string_part(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterpolated_regular_string_part(this); + } + } + + public final Interpolated_regular_string_partContext interpolated_regular_string_part() throws RecognitionException { + Interpolated_regular_string_partContext _localctx = new Interpolated_regular_string_partContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_interpolated_regular_string_part); + try { + setState(2395); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2391); + interpolated_string_expression(); + } + break; + case DOUBLE_CURLY_INSIDE: + enterOuterAlt(_localctx, 2); + { + setState(2392); + match(DOUBLE_CURLY_INSIDE); + } + break; + case REGULAR_CHAR_INSIDE: + enterOuterAlt(_localctx, 3); + { + setState(2393); + match(REGULAR_CHAR_INSIDE); + } + break; + case REGULAR_STRING_INSIDE: + enterOuterAlt(_localctx, 4); + { + setState(2394); + match(REGULAR_STRING_INSIDE); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interpolated_verbatium_string_partContext extends ParserRuleContext { + public Interpolated_string_expressionContext interpolated_string_expression() { + return getRuleContext(Interpolated_string_expressionContext.class, 0); + } + + public TerminalNode DOUBLE_CURLY_INSIDE() { + return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); + } + + public TerminalNode VERBATIUM_DOUBLE_QUOTE_INSIDE() { + return getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0); + } + + public TerminalNode VERBATIUM_INSIDE_STRING() { + return getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0); + } + + public Interpolated_verbatium_string_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interpolated_verbatium_string_part; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterpolated_verbatium_string_part(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterpolated_verbatium_string_part(this); + } + } + + public final Interpolated_verbatium_string_partContext interpolated_verbatium_string_part() throws RecognitionException { + Interpolated_verbatium_string_partContext _localctx = new Interpolated_verbatium_string_partContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_interpolated_verbatium_string_part); + try { + setState(2401); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case ALIAS: + case ARGLIST: + case ASCENDING: + case ASYNC: + case AWAIT: + case BASE: + case BOOL: + case BY: + case BYTE: + case CHAR: + case CHECKED: + case DECIMAL: + case DEFAULT: + case DELEGATE: + case DESCENDING: + case DOUBLE: + case DYNAMIC: + case EQUALS: + case FALSE: + case FLOAT: + case FROM: + case GET: + case GROUP: + case INT: + case INTO: + case JOIN: + case LET: + case LONG: + case NAMEOF: + case NEW: + case NULL: + case OBJECT: + case ON: + case ORDERBY: + case PARTIAL: + case REF: + case REMOVE: + case SBYTE: + case SELECT: + case SET: + case SHORT: + case SIZEOF: + case STRING: + case THIS: + case TRUE: + case TYPEOF: + case UINT: + case ULONG: + case UNCHECKED: + case UNMANAGED: + case USHORT: + case VAR: + case WHEN: + case WHERE: + case YIELD: + case IDENTIFIER: + case LITERAL_ACCESS: + case INTEGER_LITERAL: + case HEX_INTEGER_LITERAL: + case BIN_INTEGER_LITERAL: + case REAL_LITERAL: + case CHARACTER_LITERAL: + case REGULAR_STRING: + case VERBATIUM_STRING: + case INTERPOLATED_REGULAR_STRING_START: + case INTERPOLATED_VERBATIUM_STRING_START: + case OPEN_PARENS: + case PLUS: + case MINUS: + case STAR: + case AMP: + case CARET: + case BANG: + case TILDE: + case OP_INC: + case OP_DEC: + case OP_RANGE: + enterOuterAlt(_localctx, 1); + { + setState(2397); + interpolated_string_expression(); + } + break; + case DOUBLE_CURLY_INSIDE: + enterOuterAlt(_localctx, 2); + { + setState(2398); + match(DOUBLE_CURLY_INSIDE); + } + break; + case VERBATIUM_DOUBLE_QUOTE_INSIDE: + enterOuterAlt(_localctx, 3); + { + setState(2399); + match(VERBATIUM_DOUBLE_QUOTE_INSIDE); + } + break; + case VERBATIUM_INSIDE_STRING: + enterOuterAlt(_localctx, 4); + { + setState(2400); + match(VERBATIUM_INSIDE_STRING); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interpolated_string_expressionContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(CSharpParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(CSharpParser.COMMA, i); + } + + public TerminalNode COLON() { + return getToken(CSharpParser.COLON, 0); + } + + public List FORMAT_STRING() { + return getTokens(CSharpParser.FORMAT_STRING); + } + + public TerminalNode FORMAT_STRING(int i) { + return getToken(CSharpParser.FORMAT_STRING, i); + } + + public Interpolated_string_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interpolated_string_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterpolated_string_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterpolated_string_expression(this); + } + } + + public final Interpolated_string_expressionContext interpolated_string_expression() throws RecognitionException { + Interpolated_string_expressionContext _localctx = new Interpolated_string_expressionContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_interpolated_string_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2403); + expression(); + setState(2408); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2404); + match(COMMA); + setState(2405); + expression(); + } + } + setState(2410); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2417); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2411); + match(COLON); + setState(2413); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2412); + match(FORMAT_STRING); + } + } + setState(2415); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == FORMAT_STRING); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KeywordContext extends ParserRuleContext { + public TerminalNode ABSTRACT() { + return getToken(CSharpParser.ABSTRACT, 0); + } + + public TerminalNode AS() { + return getToken(CSharpParser.AS, 0); + } + + public TerminalNode BASE() { + return getToken(CSharpParser.BASE, 0); + } + + public TerminalNode BOOL() { + return getToken(CSharpParser.BOOL, 0); + } + + public TerminalNode BREAK() { + return getToken(CSharpParser.BREAK, 0); + } + + public TerminalNode BYTE() { + return getToken(CSharpParser.BYTE, 0); + } + + public TerminalNode CASE() { + return getToken(CSharpParser.CASE, 0); + } + + public TerminalNode CATCH() { + return getToken(CSharpParser.CATCH, 0); + } + + public TerminalNode CHAR() { + return getToken(CSharpParser.CHAR, 0); + } + + public TerminalNode CHECKED() { + return getToken(CSharpParser.CHECKED, 0); + } + + public TerminalNode CLASS() { + return getToken(CSharpParser.CLASS, 0); + } + + public TerminalNode CONST() { + return getToken(CSharpParser.CONST, 0); + } + + public TerminalNode CONTINUE() { + return getToken(CSharpParser.CONTINUE, 0); + } + + public TerminalNode DECIMAL() { + return getToken(CSharpParser.DECIMAL, 0); + } + + public TerminalNode DEFAULT() { + return getToken(CSharpParser.DEFAULT, 0); + } + + public TerminalNode DELEGATE() { + return getToken(CSharpParser.DELEGATE, 0); + } + + public TerminalNode DO() { + return getToken(CSharpParser.DO, 0); + } + + public TerminalNode DOUBLE() { + return getToken(CSharpParser.DOUBLE, 0); + } + + public TerminalNode ELSE() { + return getToken(CSharpParser.ELSE, 0); + } + + public TerminalNode ENUM() { + return getToken(CSharpParser.ENUM, 0); + } + + public TerminalNode EVENT() { + return getToken(CSharpParser.EVENT, 0); + } + + public TerminalNode EXPLICIT() { + return getToken(CSharpParser.EXPLICIT, 0); + } + + public TerminalNode EXTERN() { + return getToken(CSharpParser.EXTERN, 0); + } + + public TerminalNode FALSE() { + return getToken(CSharpParser.FALSE, 0); + } + + public TerminalNode FINALLY() { + return getToken(CSharpParser.FINALLY, 0); + } + + public TerminalNode FIXED() { + return getToken(CSharpParser.FIXED, 0); + } + + public TerminalNode FLOAT() { + return getToken(CSharpParser.FLOAT, 0); + } + + public TerminalNode FOR() { + return getToken(CSharpParser.FOR, 0); + } + + public TerminalNode FOREACH() { + return getToken(CSharpParser.FOREACH, 0); + } + + public TerminalNode GOTO() { + return getToken(CSharpParser.GOTO, 0); + } + + public TerminalNode IF() { + return getToken(CSharpParser.IF, 0); + } + + public TerminalNode IMPLICIT() { + return getToken(CSharpParser.IMPLICIT, 0); + } + + public TerminalNode IN() { + return getToken(CSharpParser.IN, 0); + } + + public TerminalNode INT() { + return getToken(CSharpParser.INT, 0); + } + + public TerminalNode INTERFACE() { + return getToken(CSharpParser.INTERFACE, 0); + } + + public TerminalNode INTERNAL() { + return getToken(CSharpParser.INTERNAL, 0); + } + + public TerminalNode IS() { + return getToken(CSharpParser.IS, 0); + } + + public TerminalNode LOCK() { + return getToken(CSharpParser.LOCK, 0); + } + + public TerminalNode LONG() { + return getToken(CSharpParser.LONG, 0); + } + + public TerminalNode NAMESPACE() { + return getToken(CSharpParser.NAMESPACE, 0); + } + + public TerminalNode NEW() { + return getToken(CSharpParser.NEW, 0); + } + + public TerminalNode NULL() { + return getToken(CSharpParser.NULL, 0); + } + + public TerminalNode OBJECT() { + return getToken(CSharpParser.OBJECT, 0); + } + + public TerminalNode OPERATOR() { + return getToken(CSharpParser.OPERATOR, 0); + } + + public TerminalNode OUT() { + return getToken(CSharpParser.OUT, 0); + } + + public TerminalNode OVERRIDE() { + return getToken(CSharpParser.OVERRIDE, 0); + } + + public TerminalNode PARAMS() { + return getToken(CSharpParser.PARAMS, 0); + } + + public TerminalNode PRIVATE() { + return getToken(CSharpParser.PRIVATE, 0); + } + + public TerminalNode PROTECTED() { + return getToken(CSharpParser.PROTECTED, 0); + } + + public TerminalNode PUBLIC() { + return getToken(CSharpParser.PUBLIC, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public TerminalNode RETURN() { + return getToken(CSharpParser.RETURN, 0); + } + + public TerminalNode SBYTE() { + return getToken(CSharpParser.SBYTE, 0); + } + + public TerminalNode SEALED() { + return getToken(CSharpParser.SEALED, 0); + } + + public TerminalNode SHORT() { + return getToken(CSharpParser.SHORT, 0); + } + + public TerminalNode SIZEOF() { + return getToken(CSharpParser.SIZEOF, 0); + } + + public TerminalNode STACKALLOC() { + return getToken(CSharpParser.STACKALLOC, 0); + } + + public TerminalNode STATIC() { + return getToken(CSharpParser.STATIC, 0); + } + + public TerminalNode STRING() { + return getToken(CSharpParser.STRING, 0); + } + + public TerminalNode STRUCT() { + return getToken(CSharpParser.STRUCT, 0); + } + + public TerminalNode SWITCH() { + return getToken(CSharpParser.SWITCH, 0); + } + + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public TerminalNode THROW() { + return getToken(CSharpParser.THROW, 0); + } + + public TerminalNode TRUE() { + return getToken(CSharpParser.TRUE, 0); + } + + public TerminalNode TRY() { + return getToken(CSharpParser.TRY, 0); + } + + public TerminalNode TYPEOF() { + return getToken(CSharpParser.TYPEOF, 0); + } + + public TerminalNode UINT() { + return getToken(CSharpParser.UINT, 0); + } + + public TerminalNode ULONG() { + return getToken(CSharpParser.ULONG, 0); + } + + public TerminalNode UNCHECKED() { + return getToken(CSharpParser.UNCHECKED, 0); + } + + public TerminalNode UNMANAGED() { + return getToken(CSharpParser.UNMANAGED, 0); + } + + public TerminalNode UNSAFE() { + return getToken(CSharpParser.UNSAFE, 0); + } + + public TerminalNode USHORT() { + return getToken(CSharpParser.USHORT, 0); + } + + public TerminalNode USING() { + return getToken(CSharpParser.USING, 0); + } + + public TerminalNode VIRTUAL() { + return getToken(CSharpParser.VIRTUAL, 0); + } + + public TerminalNode VOID() { + return getToken(CSharpParser.VOID, 0); + } + + public TerminalNode VOLATILE() { + return getToken(CSharpParser.VOLATILE, 0); + } + + public TerminalNode WHILE() { + return getToken(CSharpParser.WHILE, 0); + } + + public KeywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_keyword; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterKeyword(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitKeyword(this); + } + } + + public final KeywordContext keyword() throws RecognitionException { + KeywordContext _localctx = new KeywordContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2419); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & -3750091428249853440L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 173722833976239L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_definitionContext extends ParserRuleContext { + public TerminalNode CLASS() { + return getToken(CSharpParser.CLASS, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Class_bodyContext class_body() { + return getRuleContext(Class_bodyContext.class, 0); + } + + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class, 0); + } + + public Class_baseContext class_base() { + return getRuleContext(Class_baseContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Class_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterClass_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitClass_definition(this); + } + } + + public final Class_definitionContext class_definition() throws RecognitionException { + Class_definitionContext _localctx = new Class_definitionContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_class_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2421); + match(CLASS); + setState(2422); + identifier(); + setState(2424); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2423); + type_parameter_list(); + } + } + + setState(2427); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2426); + class_base(); + } + } + + setState(2430); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2429); + type_parameter_constraints_clauses(); + } + } + + setState(2432); + class_body(); + setState(2434); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(2433); + match(SEMICOLON); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Struct_definitionContext extends ParserRuleContext { + public TerminalNode STRUCT() { + return getToken(CSharpParser.STRUCT, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Struct_bodyContext struct_body() { + return getRuleContext(Struct_bodyContext.class, 0); + } + + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class, 0); + } + + public Struct_interfacesContext struct_interfaces() { + return getRuleContext(Struct_interfacesContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public TerminalNode READONLY() { + return getToken(CSharpParser.READONLY, 0); + } + + public TerminalNode REF() { + return getToken(CSharpParser.REF, 0); + } + + public Struct_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_struct_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterStruct_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitStruct_definition(this); + } + } + + public final Struct_definitionContext struct_definition() throws RecognitionException { + Struct_definitionContext _localctx = new Struct_definitionContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_struct_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == READONLY || _la == REF) { + { + setState(2436); + _la = _input.LA(1); + if (!(_la == READONLY || _la == REF)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2439); + match(STRUCT); + setState(2440); + identifier(); + setState(2442); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2441); + type_parameter_list(); + } + } + + setState(2445); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2444); + struct_interfaces(); + } + } + + setState(2448); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2447); + type_parameter_constraints_clauses(); + } + } + + setState(2450); + struct_body(); + setState(2452); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(2451); + match(SEMICOLON); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interface_definitionContext extends ParserRuleContext { + public TerminalNode INTERFACE() { + return getToken(CSharpParser.INTERFACE, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Class_bodyContext class_body() { + return getRuleContext(Class_bodyContext.class, 0); + } + + public Variant_type_parameter_listContext variant_type_parameter_list() { + return getRuleContext(Variant_type_parameter_listContext.class, 0); + } + + public Interface_baseContext interface_base() { + return getRuleContext(Interface_baseContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Interface_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interface_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterInterface_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitInterface_definition(this); + } + } + + public final Interface_definitionContext interface_definition() throws RecognitionException { + Interface_definitionContext _localctx = new Interface_definitionContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_interface_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2454); + match(INTERFACE); + setState(2455); + identifier(); + setState(2457); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2456); + variant_type_parameter_list(); + } + } + + setState(2460); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2459); + interface_base(); + } + } + + setState(2463); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2462); + type_parameter_constraints_clauses(); + } + } + + setState(2465); + class_body(); + setState(2467); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(2466); + match(SEMICOLON); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enum_definitionContext extends ParserRuleContext { + public TerminalNode ENUM() { + return getToken(CSharpParser.ENUM, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public Enum_bodyContext enum_body() { + return getRuleContext(Enum_bodyContext.class, 0); + } + + public Enum_baseContext enum_base() { + return getRuleContext(Enum_baseContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Enum_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enum_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterEnum_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitEnum_definition(this); + } + } + + public final Enum_definitionContext enum_definition() throws RecognitionException { + Enum_definitionContext _localctx = new Enum_definitionContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_enum_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2469); + match(ENUM); + setState(2470); + identifier(); + setState(2472); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2471); + enum_base(); + } + } + + setState(2474); + enum_body(); + setState(2476); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(2475); + match(SEMICOLON); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Delegate_definitionContext extends ParserRuleContext { + public TerminalNode DELEGATE() { + return getToken(CSharpParser.DELEGATE, 0); + } + + public Return_typeContext return_type() { + return getRuleContext(Return_typeContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Variant_type_parameter_listContext variant_type_parameter_list() { + return getRuleContext(Variant_type_parameter_listContext.class, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public Delegate_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_delegate_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterDelegate_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitDelegate_definition(this); + } + } + + public final Delegate_definitionContext delegate_definition() throws RecognitionException { + Delegate_definitionContext _localctx = new Delegate_definitionContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_delegate_definition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2478); + match(DELEGATE); + setState(2479); + return_type(); + setState(2480); + identifier(); + setState(2482); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2481); + variant_type_parameter_list(); + } + } + + setState(2484); + match(OPEN_PARENS); + setState(2486); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(2485); + formal_parameter_list(); + } + } + + setState(2488); + match(CLOSE_PARENS); + setState(2490); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2489); + type_parameter_constraints_clauses(); + } + } + + setState(2492); + match(SEMICOLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Event_declarationContext extends ParserRuleContext { + public TerminalNode EVENT() { + return getToken(CSharpParser.EVENT, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Variable_declaratorsContext variable_declarators() { + return getRuleContext(Variable_declaratorsContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Member_nameContext member_name() { + return getRuleContext(Member_nameContext.class, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public Event_accessor_declarationsContext event_accessor_declarations() { + return getRuleContext(Event_accessor_declarationsContext.class, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Event_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_event_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterEvent_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitEvent_declaration(this); + } + } + + public final Event_declarationContext event_declaration() throws RecognitionException { + Event_declarationContext _localctx = new Event_declarationContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_event_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2494); + match(EVENT); + setState(2495); + type_(); + setState(2504); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 323, _ctx)) { + case 1: { + setState(2496); + variable_declarators(); + setState(2497); + match(SEMICOLON); + } + break; + case 2: { + setState(2499); + member_name(); + setState(2500); + match(OPEN_BRACE); + setState(2501); + event_accessor_declarations(); + setState(2502); + match(CLOSE_BRACE); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Field_declarationContext extends ParserRuleContext { + public Variable_declaratorsContext variable_declarators() { + return getRuleContext(Variable_declaratorsContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Field_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_field_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterField_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitField_declaration(this); + } + } + + public final Field_declarationContext field_declaration() throws RecognitionException { + Field_declarationContext _localctx = new Field_declarationContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_field_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2506); + variable_declarators(); + setState(2507); + match(SEMICOLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Property_declarationContext extends ParserRuleContext { + public Member_nameContext member_name() { + return getRuleContext(Member_nameContext.class, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public Accessor_declarationsContext accessor_declarations() { + return getRuleContext(Accessor_declarationsContext.class, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public Variable_initializerContext variable_initializer() { + return getRuleContext(Variable_initializerContext.class, 0); + } + + public Property_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_property_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterProperty_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitProperty_declaration(this); + } + } + + public final Property_declarationContext property_declaration() throws RecognitionException { + Property_declarationContext _localctx = new Property_declarationContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_property_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2509); + member_name(); + setState(2523); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: { + setState(2510); + match(OPEN_BRACE); + setState(2511); + accessor_declarations(); + setState(2512); + match(CLOSE_BRACE); + setState(2517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(2513); + match(ASSIGNMENT); + setState(2514); + variable_initializer(); + setState(2515); + match(SEMICOLON); + } + } + + } + break; + case ASSIGNMENT: { + setState(2519); + right_arrow(); + setState(2520); + throwable_expression(); + setState(2521); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constant_declarationContext extends ParserRuleContext { + public TerminalNode CONST() { + return getToken(CSharpParser.CONST, 0); + } + + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public Constant_declaratorsContext constant_declarators() { + return getRuleContext(Constant_declaratorsContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Constant_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constant_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstant_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstant_declaration(this); + } + } + + public final Constant_declarationContext constant_declaration() throws RecognitionException { + Constant_declarationContext _localctx = new Constant_declarationContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_constant_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2525); + match(CONST); + setState(2526); + type_(); + setState(2527); + constant_declarators(); + setState(2528); + match(SEMICOLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Indexer_declarationContext extends ParserRuleContext { + public TerminalNode THIS() { + return getToken(CSharpParser.THIS, 0); + } + + public TerminalNode OPEN_BRACKET() { + return getToken(CSharpParser.OPEN_BRACKET, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public TerminalNode CLOSE_BRACKET() { + return getToken(CSharpParser.CLOSE_BRACKET, 0); + } + + public TerminalNode OPEN_BRACE() { + return getToken(CSharpParser.OPEN_BRACE, 0); + } + + public Accessor_declarationsContext accessor_declarations() { + return getRuleContext(Accessor_declarationsContext.class, 0); + } + + public TerminalNode CLOSE_BRACE() { + return getToken(CSharpParser.CLOSE_BRACE, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Indexer_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_indexer_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterIndexer_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitIndexer_declaration(this); + } + } + + public final Indexer_declarationContext indexer_declaration() throws RecognitionException { + Indexer_declarationContext _localctx = new Indexer_declarationContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_indexer_declaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(2530); + match(THIS); + setState(2531); + match(OPEN_BRACKET); + setState(2532); + formal_parameter_list(); + setState(2533); + match(CLOSE_BRACKET); + setState(2542); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: { + setState(2534); + match(OPEN_BRACE); + setState(2535); + accessor_declarations(); + setState(2536); + match(CLOSE_BRACE); + } + break; + case ASSIGNMENT: { + setState(2538); + right_arrow(); + setState(2539); + throwable_expression(); + setState(2540); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Destructor_definitionContext extends ParserRuleContext { + public TerminalNode TILDE() { + return getToken(CSharpParser.TILDE, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public BodyContext body() { + return getRuleContext(BodyContext.class, 0); + } + + public Destructor_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_destructor_definition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterDestructor_definition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitDestructor_definition(this); + } + } + + public final Destructor_definitionContext destructor_definition() throws RecognitionException { + Destructor_definitionContext _localctx = new Destructor_definitionContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_destructor_definition); + try { + enterOuterAlt(_localctx, 1); + { + setState(2544); + match(TILDE); + setState(2545); + identifier(); + setState(2546); + match(OPEN_PARENS); + setState(2547); + match(CLOSE_PARENS); + setState(2548); + body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constructor_declarationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public BodyContext body() { + return getRuleContext(BodyContext.class, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public Constructor_initializerContext constructor_initializer() { + return getRuleContext(Constructor_initializerContext.class, 0); + } + + public Constructor_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constructor_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterConstructor_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitConstructor_declaration(this); + } + } + + public final Constructor_declarationContext constructor_declaration() throws RecognitionException { + Constructor_declarationContext _localctx = new Constructor_declarationContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_constructor_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2550); + identifier(); + setState(2551); + match(OPEN_PARENS); + setState(2553); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(2552); + formal_parameter_list(); + } + } + + setState(2555); + match(CLOSE_PARENS); + setState(2557); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(2556); + constructor_initializer(); + } + } + + setState(2559); + body(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Method_declarationContext extends ParserRuleContext { + public Method_member_nameContext method_member_name() { + return getRuleContext(Method_member_nameContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Method_bodyContext method_body() { + return getRuleContext(Method_bodyContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public Type_parameter_listContext type_parameter_list() { + return getRuleContext(Type_parameter_listContext.class, 0); + } + + public Formal_parameter_listContext formal_parameter_list() { + return getRuleContext(Formal_parameter_listContext.class, 0); + } + + public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { + return getRuleContext(Type_parameter_constraints_clausesContext.class, 0); + } + + public Method_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_method_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMethod_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMethod_declaration(this); + } + } + + public final Method_declarationContext method_declaration() throws RecognitionException { + Method_declarationContext _localctx = new Method_declarationContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_method_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2561); + method_member_name(); + setState(2563); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2562); + type_parameter_list(); + } + } + + setState(2565); + match(OPEN_PARENS); + setState(2567); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & 7812956763456032119L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 45037874618448579L) != 0)) { + { + setState(2566); + formal_parameter_list(); + } + } + + setState(2569); + match(CLOSE_PARENS); + setState(2571); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == WHERE) { + { + setState(2570); + type_parameter_constraints_clauses(); + } + } + + setState(2578); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: { + setState(2573); + method_body(); + } + break; + case ASSIGNMENT: { + setState(2574); + right_arrow(); + setState(2575); + throwable_expression(); + setState(2576); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Method_member_nameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class, i); + } + + public TerminalNode DOUBLE_COLON() { + return getToken(CSharpParser.DOUBLE_COLON, 0); + } + + public List DOT() { + return getTokens(CSharpParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(CSharpParser.DOT, i); + } + + public List type_argument_list() { + return getRuleContexts(Type_argument_listContext.class); + } + + public Type_argument_listContext type_argument_list(int i) { + return getRuleContext(Type_argument_listContext.class, i); + } + + public Method_member_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_method_member_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMethod_member_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitMethod_member_name(this); + } + } + + public final Method_member_nameContext method_member_name() throws RecognitionException { + Method_member_nameContext _localctx = new Method_member_nameContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_method_member_name); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2585); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 333, _ctx)) { + case 1: { + setState(2580); + identifier(); + } + break; + case 2: { + setState(2581); + identifier(); + setState(2582); + match(DOUBLE_COLON); + setState(2583); + identifier(); + } + break; + } + setState(2594); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 335, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2588); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(2587); + type_argument_list(); + } + } + + setState(2590); + match(DOT); + setState(2591); + identifier(); + } + } + } + setState(2596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 335, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_declarationContext extends ParserRuleContext { + public TerminalNode OPERATOR() { + return getToken(CSharpParser.OPERATOR, 0); + } + + public Overloadable_operatorContext overloadable_operator() { + return getRuleContext(Overloadable_operatorContext.class, 0); + } + + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public List arg_declaration() { + return getRuleContexts(Arg_declarationContext.class); + } + + public Arg_declarationContext arg_declaration(int i) { + return getRuleContext(Arg_declarationContext.class, i); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public BodyContext body() { + return getRuleContext(BodyContext.class, 0); + } + + public Right_arrowContext right_arrow() { + return getRuleContext(Right_arrowContext.class, 0); + } + + public Throwable_expressionContext throwable_expression() { + return getRuleContext(Throwable_expressionContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(CSharpParser.SEMICOLON, 0); + } + + public List IN() { + return getTokens(CSharpParser.IN); + } + + public TerminalNode IN(int i) { + return getToken(CSharpParser.IN, i); + } + + public TerminalNode COMMA() { + return getToken(CSharpParser.COMMA, 0); + } + + public Operator_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_operator_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterOperator_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitOperator_declaration(this); + } + } + + public final Operator_declarationContext operator_declaration() throws RecognitionException { + Operator_declarationContext _localctx = new Operator_declarationContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_operator_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2597); + match(OPERATOR); + setState(2598); + overloadable_operator(); + setState(2599); + match(OPEN_PARENS); + setState(2601); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == IN) { + { + setState(2600); + match(IN); + } + } + + setState(2603); + arg_declaration(); + setState(2609); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2604); + match(COMMA); + setState(2606); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == IN) { + { + setState(2605); + match(IN); + } + } + + setState(2608); + arg_declaration(); + } + } + + setState(2611); + match(CLOSE_PARENS); + setState(2617); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_BRACE: + case SEMICOLON: { + setState(2612); + body(); + } + break; + case ASSIGNMENT: { + setState(2613); + right_arrow(); + setState(2614); + throwable_expression(); + setState(2615); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Arg_declarationContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(CSharpParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Arg_declarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_arg_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterArg_declaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitArg_declaration(this); + } + } + + public final Arg_declarationContext arg_declaration() throws RecognitionException { + Arg_declarationContext _localctx = new Arg_declarationContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_arg_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2619); + type_(); + setState(2620); + identifier(); + setState(2623); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(2621); + match(ASSIGNMENT); + setState(2622); + expression(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Method_invocationContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class, 0); + } + + public Method_invocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_method_invocation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterMethod_invocation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitMethod_invocation(this); + } + } + + public final Method_invocationContext method_invocation() throws RecognitionException { + Method_invocationContext _localctx = new Method_invocationContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_method_invocation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2625); + match(OPEN_PARENS); + setState(2627); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5419197809667089408L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305514793348041149L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(2626); + argument_list(); + } + } + + setState(2629); + match(CLOSE_PARENS); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_creation_expressionContext extends ParserRuleContext { + public TerminalNode OPEN_PARENS() { + return getToken(CSharpParser.OPEN_PARENS, 0); + } + + public TerminalNode CLOSE_PARENS() { + return getToken(CSharpParser.CLOSE_PARENS, 0); + } + + public Argument_listContext argument_list() { + return getRuleContext(Argument_listContext.class, 0); + } + + public Object_or_collection_initializerContext object_or_collection_initializer() { + return getRuleContext(Object_or_collection_initializerContext.class, 0); + } + + public Object_creation_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_object_creation_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).enterObject_creation_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) + ((CSharpParserListener) listener).exitObject_creation_expression(this); + } + } + + public final Object_creation_expressionContext object_creation_expression() throws RecognitionException { + Object_creation_expressionContext _localctx = new Object_creation_expressionContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_object_creation_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2631); + match(OPEN_PARENS); + setState(2633); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5419197809667089408L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2305514793348041149L) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 4398059153857L) != 0)) { + { + setState(2632); + argument_list(); + } + } + + setState(2635); + match(CLOSE_PARENS); + setState(2637); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == OPEN_BRACE) { + { + setState(2636); + object_or_collection_initializer(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { + return getToken(CSharpParser.IDENTIFIER, 0); + } + + public TerminalNode ADD() { + return getToken(CSharpParser.ADD, 0); + } + + public TerminalNode ALIAS() { + return getToken(CSharpParser.ALIAS, 0); + } + + public TerminalNode ARGLIST() { + return getToken(CSharpParser.ARGLIST, 0); + } + + public TerminalNode ASCENDING() { + return getToken(CSharpParser.ASCENDING, 0); + } + + public TerminalNode ASYNC() { + return getToken(CSharpParser.ASYNC, 0); + } + + public TerminalNode AWAIT() { + return getToken(CSharpParser.AWAIT, 0); + } + + public TerminalNode BY() { + return getToken(CSharpParser.BY, 0); + } + + public TerminalNode DESCENDING() { + return getToken(CSharpParser.DESCENDING, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(CSharpParser.DYNAMIC, 0); + } + + public TerminalNode EQUALS() { + return getToken(CSharpParser.EQUALS, 0); + } + + public TerminalNode FROM() { + return getToken(CSharpParser.FROM, 0); + } + + public TerminalNode GET() { + return getToken(CSharpParser.GET, 0); + } + + public TerminalNode GROUP() { + return getToken(CSharpParser.GROUP, 0); + } + + public TerminalNode INTO() { + return getToken(CSharpParser.INTO, 0); + } + + public TerminalNode JOIN() { + return getToken(CSharpParser.JOIN, 0); + } + + public TerminalNode LET() { + return getToken(CSharpParser.LET, 0); + } + + public TerminalNode NAMEOF() { + return getToken(CSharpParser.NAMEOF, 0); + } + + public TerminalNode ON() { + return getToken(CSharpParser.ON, 0); + } + + public TerminalNode ORDERBY() { + return getToken(CSharpParser.ORDERBY, 0); + } + + public TerminalNode PARTIAL() { + return getToken(CSharpParser.PARTIAL, 0); + } + + public TerminalNode REMOVE() { + return getToken(CSharpParser.REMOVE, 0); + } + + public TerminalNode SELECT() { + return getToken(CSharpParser.SELECT, 0); + } + + public TerminalNode SET() { + return getToken(CSharpParser.SET, 0); + } + + public TerminalNode UNMANAGED() { + return getToken(CSharpParser.UNMANAGED, 0); + } + + public TerminalNode VAR() { + return getToken(CSharpParser.VAR, 0); + } + + public TerminalNode WHEN() { + return getToken(CSharpParser.WHEN, 0); + } + + public TerminalNode WHERE() { + return getToken(CSharpParser.WHERE, 0); + } + + public TerminalNode YIELD() { + return getToken(CSharpParser.YIELD, 0); + } + + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_identifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).enterIdentifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CSharpParserListener) ((CSharpParserListener) listener).exitIdentifier(this); + } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 434, RULE_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2639); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 3750091428249852928L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1904629023639713L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 187: + return right_arrow_sempred((Right_arrowContext) _localctx, predIndex); + case 188: + return right_shift_sempred((Right_shiftContext) _localctx, predIndex); + case 189: + return right_shift_assignment_sempred((Right_shift_assignmentContext) _localctx, predIndex); + } + return true; + } + + private boolean right_arrow_sempred(Right_arrowContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return (((Right_arrowContext) _localctx).first != null ? ((Right_arrowContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_arrowContext) _localctx).second != null ? ((Right_arrowContext) _localctx).second.getTokenIndex() : 0); + } + return true; + } + + private boolean right_shift_sempred(Right_shiftContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return (((Right_shiftContext) _localctx).first != null ? ((Right_shiftContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_shiftContext) _localctx).second != null ? ((Right_shiftContext) _localctx).second.getTokenIndex() : 0); + } + return true; + } + + private boolean right_shift_assignment_sempred(Right_shift_assignmentContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return (((Right_shift_assignmentContext) _localctx).first != null ? ((Right_shift_assignmentContext) _localctx).first.getTokenIndex() : 0) + 1 == (((Right_shift_assignmentContext) _localctx).second != null ? ((Right_shift_assignmentContext) _localctx).second.getTokenIndex() : 0); + } + return true; + } + + private static final String _serializedATNSegment0 = + "\u0004\u0001\u00c6\u0a52\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001" + + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004" + + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007" + + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b" + + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007" + + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007" + + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007" + + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007" + + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007" + + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007" + + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007" + + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007" + + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007" + + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007" + + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007" + + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007" + + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007" + + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007" + + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007" + + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007" + + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007" + + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007" + + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007" + + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007" + + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007" + + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007" + + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007" + + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007" + + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007" + + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007" + + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007" + + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007" + + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007" + + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007" + + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007" + + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007" + + "\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007" + + "\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007" + + "\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007" + + "\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007" + + "\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007" + + "\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007" + + "\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007" + + "\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007" + + "\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007" + + "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007" + + "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007" + + "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007" + + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007" + + "\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007" + + "\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007" + + "\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007" + + "\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007" + + "\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007" + + "\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007" + + "\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007" + + "\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007" + + "\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007" + + "\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007" + + "\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0001\u0000\u0003" + + "\u0000\u01b6\b\u0000\u0001\u0000\u0003\u0000\u01b9\b\u0000\u0001\u0000" + + "\u0003\u0000\u01bc\b\u0000\u0001\u0000\u0005\u0000\u01bf\b\u0000\n\u0000" + + "\f\u0000\u01c2\t\u0000\u0001\u0000\u0003\u0000\u01c5\b\u0000\u0001\u0000" + + "\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001\u01cb\b\u0001\u0001\u0001" + + "\u0003\u0001\u01ce\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001" + + "\u01d3\b\u0001\u0005\u0001\u01d5\b\u0001\n\u0001\f\u0001\u01d8\t\u0001" + + "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0005\u0002\u01de\b\u0002" + + "\n\u0002\f\u0002\u01e1\t\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0003\u0003\u0003\u01e8\b\u0003\u0001\u0004\u0001\u0004\u0001" + + "\u0004\u0001\u0004\u0004\u0004\u01ee\b\u0004\u000b\u0004\f\u0004\u01ef" + + "\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0003\u0005\u01f6\b\u0005" + + "\u0001\u0006\u0001\u0006\u0003\u0006\u01fa\b\u0006\u0001\u0007\u0001\u0007" + + "\u0001\u0007\u0003\u0007\u01ff\b\u0007\u0001\b\u0001\b\u0001\t\u0001\t" + + "\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u0209\b\n\u0001\u000b\u0001\u000b" + + "\u0001\u000b\u0001\u000b\u0005\u000b\u020f\b\u000b\n\u000b\f\u000b\u0212" + + "\t\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0005\f\u0219" + + "\b\f\n\f\f\f\u021c\t\f\u0001\r\u0001\r\u0001\r\u0003\r\u0221\b\r\u0001" + + "\r\u0003\r\u0224\b\r\u0001\r\u0001\r\u0003\r\u0228\b\r\u0001\r\u0001\r" + + "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003\u000e\u0230\b\u000e" + + "\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0235\b\u000f\u0001\u0010" + + "\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010" + + "\u0001\u0010\u0003\u0010\u023f\b\u0010\u0001\u0011\u0001\u0011\u0001\u0011" + + "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011" + + "\u0001\u0011\u0001\u0011\u0003\u0011\u024c\b\u0011\u0001\u0012\u0001\u0012" + + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u0254\b\u0012" + + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u025a\b\u0013" + + "\u0003\u0013\u025c\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0005\u0014" + + "\u0261\b\u0014\n\u0014\f\u0014\u0264\t\u0014\u0001\u0015\u0001\u0015\u0001" + + "\u0015\u0005\u0015\u0269\b\u0015\n\u0015\f\u0015\u026c\t\u0015\u0001\u0016" + + "\u0001\u0016\u0001\u0016\u0005\u0016\u0271\b\u0016\n\u0016\f\u0016\u0274" + + "\t\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0005\u0017\u0279\b\u0017" + + "\n\u0017\f\u0017\u027c\t\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0005" + + "\u0018\u0281\b\u0018\n\u0018\f\u0018\u0284\t\u0018\u0001\u0019\u0001\u0019" + + "\u0001\u0019\u0005\u0019\u0289\b\u0019\n\u0019\f\u0019\u028c\t\u0019\u0001" + + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001" + + "\u001a\u0005\u001a\u0295\b\u001a\n\u001a\f\u001a\u0298\t\u001a\u0001\u001b" + + "\u0001\u001b\u0001\u001b\u0003\u001b\u029d\b\u001b\u0001\u001b\u0005\u001b" + + "\u02a0\b\u001b\n\u001b\f\u001b\u02a3\t\u001b\u0001\u001c\u0001\u001c\u0001" + + "\u001c\u0005\u001c\u02a8\b\u001c\n\u001c\f\u001c\u02ab\t\u001c\u0001\u001d" + + "\u0001\u001d\u0001\u001d\u0005\u001d\u02b0\b\u001d\n\u001d\f\u001d\u02b3" + + "\t\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003" + + "\u001e\u02ba\b\u001e\u0003\u001e\u02bc\b\u001e\u0001\u001e\u0003\u001e" + + "\u02bf\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u02c4\b" + + "\u001f\n\u001f\f\u001f\u02c7\t\u001f\u0001 \u0001 \u0003 \u02cb\b \u0001" + + " \u0001 \u0001 \u0001!\u0001!\u0003!\u02d2\b!\u0001!\u0001!\u0003!\u02d6" + + "\b!\u0003!\u02d8\b!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "\"\u0001\"\u0003\"\u02f4\b\"\u0001#\u0001#\u0003#\u02f8\b#\u0001#\u0005" + + "#\u02fb\b#\n#\f#\u02fe\t#\u0001#\u0003#\u0301\b#\u0001#\u0001#\u0001#" + + "\u0001#\u0001#\u0001#\u0003#\u0309\b#\u0001#\u0003#\u030c\b#\u0001#\u0005" + + "#\u030f\b#\n#\f#\u0312\t#\u0001#\u0003#\u0315\b#\u0005#\u0317\b#\n#\f" + + "#\u031a\t#\u0001$\u0001$\u0001$\u0003$\u031f\b$\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u032d" + + "\b$\u0001$\u0001$\u0001$\u0001$\u0003$\u0333\b$\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0001$\u0001$\u0005$\u033d\b$\n$\f$\u0340\t$\u0001$\u0003" + + "$\u0343\b$\u0001$\u0004$\u0346\b$\u000b$\f$\u0347\u0001$\u0001$\u0003" + + "$\u034c\b$\u0001$\u0001$\u0001$\u0001$\u0003$\u0352\b$\u0001$\u0001$\u0001" + + "$\u0001$\u0004$\u0358\b$\u000b$\f$\u0359\u0001$\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0003$\u0363\b$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001" + + "$\u0003$\u0375\b$\u0001$\u0003$\u0378\b$\u0001$\u0001$\u0001$\u0003$\u037d" + + "\b$\u0001$\u0003$\u0380\b$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001" + + "$\u0001$\u0001$\u0001$\u0001$\u0005$\u038d\b$\n$\f$\u0390\t$\u0001$\u0001" + + "$\u0001$\u0003$\u0395\b$\u0001%\u0001%\u0003%\u0399\b%\u0001&\u0001&\u0001" + + "&\u0001\'\u0003\'\u039f\b\'\u0001\'\u0001\'\u0001\'\u0003\'\u03a4\b\'" + + "\u0001(\u0003(\u03a7\b(\u0001(\u0001(\u0001(\u0001(\u0005(\u03ad\b(\n" + + "(\f(\u03b0\t(\u0001(\u0001(\u0001)\u0001)\u0001)\u0003)\u03b7\b)\u0001" + + ")\u0001)\u0001*\u0001*\u0001+\u0001+\u0001+\u0005+\u03c0\b+\n+\f+\u03c3" + + "\t+\u0001,\u0001,\u0003,\u03c7\b,\u0001-\u0001-\u0001-\u0003-\u03cc\b" + + "-\u0003-\u03ce\b-\u0001-\u0001-\u0001.\u0001.\u0001.\u0005.\u03d5\b.\n" + + ".\f.\u03d8\t.\u0001/\u0001/\u0001/\u0001/\u0001/\u0003/\u03df\b/\u0001" + + "/\u0001/\u0001/\u00010\u00010\u00030\u03e6\b0\u00011\u00011\u00011\u0001" + + "1\u00051\u03ec\b1\n1\f1\u03ef\t1\u00011\u00031\u03f2\b1\u00011\u00011" + + "\u00012\u00012\u00012\u00012\u00012\u00032\u03fb\b2\u00013\u00013\u0001" + + "3\u00033\u0400\b3\u00033\u0402\b3\u00013\u00013\u00014\u00014\u00014\u0005" + + "4\u0409\b4\n4\f4\u040c\t4\u00015\u00015\u00015\u00015\u00015\u00035\u0413" + + "\b5\u00016\u00016\u00036\u0417\b6\u00016\u00016\u00016\u00036\u041c\b" + + "6\u00036\u041e\b6\u00016\u00016\u00016\u00036\u0423\b6\u00056\u0425\b" + + "6\n6\f6\u0428\t6\u00017\u00017\u00057\u042c\b7\n7\f7\u042f\t7\u00017\u0001" + + "7\u00018\u00018\u00018\u00058\u0436\b8\n8\f8\u0439\t8\u00018\u00038\u043c" + + "\b8\u00018\u00038\u043f\b8\u00018\u00038\u0442\b8\u00019\u00019\u0001" + + "9\u00019\u00059\u0448\b9\n9\f9\u044b\t9\u00019\u00019\u0001:\u0001:\u0001" + + ":\u0001:\u0001;\u0003;\u0454\b;\u0001;\u0001;\u0001;\u0001;\u0001<\u0001" + + "<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0003" + + "<\u0465\b<\u0001=\u0001=\u0001=\u0005=\u046a\b=\n=\f=\u046d\t=\u0001>" + + "\u0003>\u0470\b>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0005?\u0478" + + "\b?\n?\f?\u047b\t?\u0001@\u0001@\u0003@\u047f\b@\u0001A\u0001A\u0001A" + + "\u0001B\u0001B\u0003B\u0486\bB\u0001B\u0001B\u0001B\u0001B\u0001C\u0005" + + "C\u048d\bC\nC\fC\u0490\tC\u0001C\u0001C\u0003C\u0494\bC\u0001D\u0001D" + + "\u0001D\u0001D\u0001D\u0003D\u049b\bD\u0001E\u0001E\u0001E\u0001E\u0001" + + "E\u0001F\u0001F\u0001F\u0001G\u0001G\u0003G\u04a7\bG\u0001G\u0001G\u0001" + + "G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0003G\u04b2\bG\u0001H\u0001" + + "H\u0001H\u0001H\u0005H\u04b8\bH\nH\fH\u04bb\tH\u0001I\u0001I\u0003I\u04bf" + + "\bI\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u04c8\bJ\u0001" + + "K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0003L\u04d1\bL\u0001M\u0001" + + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003M\u04da\bM\u0001N\u0001N\u0001" + + "N\u0001O\u0003O\u04e0\bO\u0001O\u0001O\u0001O\u0003O\u04e5\bO\u0001O\u0001" + + "O\u0003O\u04e9\bO\u0001O\u0001O\u0003O\u04ed\bO\u0001P\u0001P\u0003P\u04f1" + + "\bP\u0001P\u0001P\u0003P\u04f5\bP\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0003" + + "Q\u04fc\bQ\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0003S\u0504\bS\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0003T\u0511\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0005T\u0519" + + "\bT\nT\fT\u051c\tT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0003T\u0531\bT\u0001T\u0001T\u0003T\u0535\bT\u0001T\u0001T\u0003" + + "T\u0539\bT\u0001T\u0001T\u0001T\u0003T\u053e\bT\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0003T\u0552\bT\u0001T\u0001T\u0001T\u0003" + + "T\u0557\bT\u0001T\u0001T\u0001T\u0003T\u055c\bT\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0003T\u0563\bT\u0001T\u0003T\u0566\bT\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u057c\bT\u0001T\u0001" + + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u0588" + + "\bT\u0001U\u0001U\u0003U\u058c\bU\u0001U\u0001U\u0001V\u0001V\u0001V\u0001" + + "V\u0003V\u0594\bV\u0001V\u0001V\u0001V\u0001V\u0005V\u059a\bV\nV\fV\u059d" + + "\tV\u0001V\u0001V\u0001V\u0001V\u0003V\u05a3\bV\u0001W\u0001W\u0003W\u05a7" + + "\bW\u0001X\u0001X\u0001X\u0003X\u05ac\bX\u0001X\u0003X\u05af\bX\u0001" + + "Y\u0001Y\u0001Y\u0003Y\u05b4\bY\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001" + + "[\u0003[\u05bc\b[\u0001\\\u0004\\\u05bf\b\\\u000b\\\f\\\u05c0\u0001\\" + + "\u0001\\\u0001]\u0001]\u0001]\u0003]\u05c8\b]\u0001]\u0001]\u0001]\u0001" + + "]\u0003]\u05ce\b]\u0001^\u0001^\u0001^\u0001_\u0004_\u05d4\b_\u000b_\f" + + "_\u05d5\u0001`\u0001`\u0001`\u0001`\u0005`\u05dc\b`\n`\f`\u05df\t`\u0003" + + "`\u05e1\b`\u0001a\u0001a\u0001a\u0005a\u05e6\ba\na\fa\u05e9\ta\u0001b" + + "\u0001b\u0005b\u05ed\bb\nb\fb\u05f0\tb\u0001b\u0003b\u05f3\bb\u0001b\u0003" + + "b\u05f6\bb\u0001c\u0001c\u0001c\u0001c\u0003c\u05fc\bc\u0001c\u0001c\u0003" + + "c\u0600\bc\u0001c\u0001c\u0001d\u0001d\u0003d\u0606\bd\u0001d\u0001d\u0001" + + "e\u0001e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001g\u0001g\u0003" + + "g\u0614\bg\u0001h\u0001h\u0001h\u0001h\u0003h\u061a\bh\u0001i\u0001i\u0001" + + "i\u0005i\u061f\bi\ni\fi\u0622\ti\u0001j\u0001j\u0003j\u0626\bj\u0001j" + + "\u0003j\u0629\bj\u0001j\u0003j\u062c\bj\u0001j\u0001j\u0001k\u0004k\u0631" + + "\bk\u000bk\fk\u0632\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0004m\u063b" + + "\bm\u000bm\fm\u063c\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001" + + "n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0003n\u064e\bn\u0001" + + "o\u0004o\u0651\bo\u000bo\fo\u0652\u0001p\u0001p\u0003p\u0657\bp\u0001" + + "q\u0003q\u065a\bq\u0001q\u0003q\u065d\bq\u0001q\u0001q\u0001q\u0001q\u0001" + + "q\u0003q\u0664\bq\u0001r\u0001r\u0001r\u0001r\u0003r\u066a\br\u0001s\u0001" + + "s\u0001s\u0001s\u0005s\u0670\bs\ns\fs\u0673\ts\u0001s\u0001s\u0001t\u0003" + + "t\u0678\bt\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0005u\u0680\bu\n" + + "u\fu\u0683\tu\u0001v\u0001v\u0001v\u0005v\u0688\bv\nv\fv\u068b\tv\u0001" + + "w\u0004w\u068e\bw\u000bw\fw\u068f\u0001x\u0001x\u0001x\u0001x\u0001x\u0001" + + "y\u0001y\u0001y\u0001y\u0003y\u069b\by\u0001y\u0001y\u0003y\u069f\by\u0003" + + "y\u06a1\by\u0001z\u0001z\u0001z\u0003z\u06a6\bz\u0001z\u0001z\u0003z\u06aa" + + "\bz\u0001{\u0001{\u0001{\u0005{\u06af\b{\n{\f{\u06b2\t{\u0001|\u0001|" + + "\u0001|\u0001|\u0001}\u0001}\u0003}\u06ba\b}\u0001}\u0001}\u0001~\u0004" + + "~\u06bf\b~\u000b~\f~\u06c0\u0001\u007f\u0003\u007f\u06c4\b\u007f\u0001" + + "\u007f\u0003\u007f\u06c7\b\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u06cb" + + "\b\u007f\u0001\u0080\u0004\u0080\u06ce\b\u0080\u000b\u0080\f\u0080\u06cf" + + "\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082" + + "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082" + + "\u06dd\b\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082" + + "\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u06e7\b\u0082\u0001\u0083" + + "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u06ee\b\u0083" + + "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083" + + "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u06fa\b\u0083" + + "\u0001\u0084\u0001\u0084\u0001\u0084\u0005\u0084\u06ff\b\u0084\n\u0084" + + "\f\u0084\u0702\t\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085" + + "\u0001\u0086\u0001\u0086\u0001\u0086\u0005\u0086\u070b\b\u0086\n\u0086" + + "\f\u0086\u070e\t\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0003\u0087" + + "\u0713\b\u0087\u0001\u0088\u0001\u0088\u0003\u0088\u0717\b\u0088\u0001" + + "\u0089\u0001\u0089\u0003\u0089\u071b\b\u0089\u0001\u008a\u0001\u008a\u0001" + + "\u008b\u0001\u008b\u0003\u008b\u0721\b\u008b\u0001\u008c\u0001\u008c\u0001" + + "\u008c\u0001\u008c\u0003\u008c\u0727\b\u008c\u0003\u008c\u0729\b\u008c" + + "\u0001\u008d\u0001\u008d\u0001\u008d\u0005\u008d\u072e\b\u008d\n\u008d" + + "\f\u008d\u0731\t\u008d\u0001\u008e\u0003\u008e\u0734\b\u008e\u0001\u008e" + + "\u0003\u008e\u0737\b\u008e\u0001\u008e\u0001\u008e\u0003\u008e\u073b\b" + + "\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001" + + "\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0745\b\u008f\u0001\u0090\u0003" + + "\u0090\u0748\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001" + + "\u0091\u0003\u0091\u074f\b\u0091\u0001\u0091\u0003\u0091\u0752\b\u0091" + + "\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0757\b\u0091\u0001\u0091" + + "\u0001\u0091\u0001\u0091\u0003\u0091\u075c\b\u0091\u0003\u0091\u075e\b" + + "\u0091\u0001\u0092\u0003\u0092\u0761\b\u0092\u0001\u0092\u0003\u0092\u0764" + + "\b\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0093\u0003\u0093\u076a" + + "\b\u0093\u0001\u0093\u0003\u0093\u076d\b\u0093\u0001\u0093\u0001\u0093" + + "\u0001\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094" + + "\u0001\u0094\u0001\u0094\u0003\u0094\u0779\b\u0094\u0001\u0095\u0001\u0095" + + "\u0003\u0095\u077d\b\u0095\u0001\u0096\u0003\u0096\u0780\b\u0096\u0001" + + "\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001" + + "\u0096\u0001\u0096\u0003\u0096\u078a\b\u0096\u0001\u0097\u0003\u0097\u078d" + + "\b\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0098\u0003\u0098\u0793" + + "\b\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0003\u0099\u07ae\b\u0099\u0001\u009a\u0001\u009a\u0001" + + "\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009b\u0001" + + "\u009b\u0001\u009b\u0001\u009b\u0003\u009b\u07bb\b\u009b\u0001\u009b\u0001" + + "\u009b\u0001\u009c\u0001\u009c\u0003\u009c\u07c1\b\u009c\u0001\u009d\u0001" + + "\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0005\u009e\u07c8\b\u009e\n" + + "\u009e\f\u009e\u07cb\t\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0003" + + "\u009f\u07d0\b\u009f\u0001\u009f\u0003\u009f\u07d3\b\u009f\u0001\u009f" + + "\u0001\u009f\u0001\u009f\u0001\u009f\u0004\u009f\u07d9\b\u009f\u000b\u009f" + + "\f\u009f\u07da\u0001\u009f\u0001\u009f\u0003\u009f\u07df\b\u009f\u0001" + + "\u00a0\u0001\u00a0\u0005\u00a0\u07e3\b\u00a0\n\u00a0\f\u00a0\u07e6\t\u00a0" + + "\u0001\u00a0\u0004\u00a0\u07e9\b\u00a0\u000b\u00a0\f\u00a0\u07ea\u0001" + + "\u00a1\u0001\u00a1\u0005\u00a1\u07ef\b\u00a1\n\u00a1\f\u00a1\u07f2\t\u00a1" + + "\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2" + + "\u0005\u00a2\u07fa\b\u00a2\n\u00a2\f\u00a2\u07fd\t\u00a2\u0001\u00a2\u0003" + + "\u00a2\u0800\b\u00a2\u0003\u00a2\u0802\b\u00a2\u0001\u00a2\u0001\u00a2" + + "\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0005\u00a3\u080a\b\u00a3" + + "\n\u00a3\f\u00a3\u080d\t\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4\u0003" + + "\u00a4\u0812\b\u00a4\u0001\u00a4\u0003\u00a4\u0815\b\u00a4\u0001\u00a4" + + "\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6" + + "\u0001\u00a7\u0001\u00a7\u0005\u00a7\u0820\b\u00a7\n\u00a7\f\u00a7\u0823" + + "\t\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0003\u00a8\u0828\b\u00a8" + + "\u0001\u00a8\u0003\u00a8\u082b\b\u00a8\u0001\u00a8\u0003\u00a8\u082e\b" + + "\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0003" + + "\u00a8\u0835\b\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u083a" + + "\b\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u083e\b\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0003\u00a8\u0842\b\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8" + + "\u0003\u00a8\u0853\b\u00a8\u0001\u00a8\u0003\u00a8\u0856\b\u00a8\u0001" + + "\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u085b\b\u00a8\u0001\u00a8\u0001" + + "\u00a8\u0003\u00a8\u085f\b\u00a8\u0001\u00a8\u0001\u00a8\u0003\u00a8\u0863" + + "\b\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001" + + "\u00a8\u0001\u00a8\u0003\u00a8\u086c\b\u00a8\u0001\u00a9\u0003\u00a9\u086f" + + "\b\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0874\b\u00a9" + + "\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0878\b\u00a9\u0001\u00a9\u0001\u00a9" + + "\u0001\u00a9\u0003\u00a9\u087d\b\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9" + + "\u0881\b\u00a9\u0003\u00a9\u0883\b\u00a9\u0001\u00aa\u0001\u00aa\u0001" + + "\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u088c" + + "\b\u00ab\n\u00ab\f\u00ab\u088f\t\u00ab\u0001\u00ab\u0003\u00ab\u0892\b" + + "\u00ab\u0003\u00ab\u0894\b\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0003" + + "\u00ac\u0899\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u089e" + + "\b\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003" + + "\u00ad\u08a5\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae\u0001\u00ae\u0003" + + "\u00ae\u08ab\b\u00ae\u0001\u00af\u0004\u00af\u08ae\b\u00af\u000b\u00af" + + "\f\u00af\u08af\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0" + + "\u08b6\b\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u08ba\b\u00b0\u0001" + + "\u00b0\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0003\u00b1\u08c0\b\u00b1\u0001" + + "\u00b2\u0001\u00b2\u0001\u00b2\u0005\u00b2\u08c5\b\u00b2\n\u00b2\f\u00b2" + + "\u08c8\t\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3" + + "\u0005\u00b3\u08cf\b\u00b3\n\u00b3\f\u00b3\u08d2\t\u00b3\u0003\u00b3\u08d4" + + "\b\u00b3\u0001\u00b3\u0003\u00b3\u08d7\b\u00b3\u0001\u00b4\u0001\u00b4" + + "\u0001\u00b4\u0003\u00b4\u08dc\b\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b5" + + "\u0001\u00b5\u0003\u00b5\u08e2\b\u00b5\u0001\u00b5\u0001\u00b5\u0005\u00b5" + + "\u08e6\b\u00b5\n\u00b5\f\u00b5\u08e9\t\u00b5\u0001\u00b5\u0001\u00b5\u0001" + + "\u00b5\u0001\u00b5\u0003\u00b5\u08ef\b\u00b5\u0001\u00b6\u0001\u00b6\u0001" + + "\u00b6\u0005\u00b6\u08f4\b\u00b6\n\u00b6\f\u00b6\u08f7\t\u00b6\u0001\u00b7" + + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b8\u0003\u00b8\u08fe\b\u00b8" + + "\u0001\u00b8\u0001\u00b8\u0003\u00b8\u0902\b\u00b8\u0001\u00b9\u0001\u00b9" + + "\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba" + + "\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba" + + "\u0911\b\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u0915\b\u00ba\u0001" + + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0005\u00ba\u091c" + + "\b\u00ba\n\u00ba\f\u00ba\u091f\t\u00ba\u0001\u00ba\u0003\u00ba\u0922\b" + + "\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u0926\b\u00ba\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001" + + "\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00be\u0001" + + "\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001" + + "\u00be\u0003\u00be\u093c\b\u00be\u0001\u00bf\u0001\u00bf\u0001\u00c0\u0001" + + "\u00c0\u0001\u00c0\u0001\u00c0\u0003\u00c0\u0944\b\u00c0\u0001\u00c1\u0001" + + "\u00c1\u0005\u00c1\u0948\b\u00c1\n\u00c1\f\u00c1\u094b\t\u00c1\u0001\u00c1" + + "\u0001\u00c1\u0001\u00c2\u0001\u00c2\u0005\u00c2\u0951\b\u00c2\n\u00c2" + + "\f\u00c2\u0954\t\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3\u0001\u00c3" + + "\u0001\u00c3\u0001\u00c3\u0003\u00c3\u095c\b\u00c3\u0001\u00c4\u0001\u00c4" + + "\u0001\u00c4\u0001\u00c4\u0003\u00c4\u0962\b\u00c4\u0001\u00c5\u0001\u00c5" + + "\u0001\u00c5\u0005\u00c5\u0967\b\u00c5\n\u00c5\f\u00c5\u096a\t\u00c5\u0001" + + "\u00c5\u0001\u00c5\u0004\u00c5\u096e\b\u00c5\u000b\u00c5\f\u00c5\u096f" + + "\u0003\u00c5\u0972\b\u00c5\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7" + + "\u0001\u00c7\u0003\u00c7\u0979\b\u00c7\u0001\u00c7\u0003\u00c7\u097c\b" + + "\u00c7\u0001\u00c7\u0003\u00c7\u097f\b\u00c7\u0001\u00c7\u0001\u00c7\u0003" + + "\u00c7\u0983\b\u00c7\u0001\u00c8\u0003\u00c8\u0986\b\u00c8\u0001\u00c8" + + "\u0001\u00c8\u0001\u00c8\u0003\u00c8\u098b\b\u00c8\u0001\u00c8\u0003\u00c8" + + "\u098e\b\u00c8\u0001\u00c8\u0003\u00c8\u0991\b\u00c8\u0001\u00c8\u0001" + + "\u00c8\u0003\u00c8\u0995\b\u00c8\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0003" + + "\u00c9\u099a\b\u00c9\u0001\u00c9\u0003\u00c9\u099d\b\u00c9\u0001\u00c9" + + "\u0003\u00c9\u09a0\b\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u09a4\b" + + "\u00c9\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0003\u00ca\u09a9\b\u00ca\u0001" + + "\u00ca\u0001\u00ca\u0003\u00ca\u09ad\b\u00ca\u0001\u00cb\u0001\u00cb\u0001" + + "\u00cb\u0001\u00cb\u0003\u00cb\u09b3\b\u00cb\u0001\u00cb\u0001\u00cb\u0003" + + "\u00cb\u09b7\b\u00cb\u0001\u00cb\u0001\u00cb\u0003\u00cb\u09bb\b\u00cb" + + "\u0001\u00cb\u0001\u00cb\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc" + + "\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc" + + "\u0003\u00cc\u09c9\b\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00ce" + + "\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce" + + "\u0001\u00ce\u0003\u00ce\u09d6\b\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce" + + "\u0001\u00ce\u0003\u00ce\u09dc\b\u00ce\u0001\u00cf\u0001\u00cf\u0001\u00cf" + + "\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0" + + "\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0" + + "\u0001\u00d0\u0001\u00d0\u0003\u00d0\u09ef\b\u00d0\u0001\u00d1\u0001\u00d1" + + "\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d2\u0001\u00d2" + + "\u0001\u00d2\u0003\u00d2\u09fa\b\u00d2\u0001\u00d2\u0001\u00d2\u0003\u00d2" + + "\u09fe\b\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001\u00d3\u0003\u00d3" + + "\u0a04\b\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u0a08\b\u00d3\u0001" + + "\u00d3\u0001\u00d3\u0003\u00d3\u0a0c\b\u00d3\u0001\u00d3\u0001\u00d3\u0001" + + "\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u0a13\b\u00d3\u0001\u00d4\u0001" + + "\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003\u00d4\u0a1a\b\u00d4\u0001" + + "\u00d4\u0003\u00d4\u0a1d\b\u00d4\u0001\u00d4\u0001\u00d4\u0005\u00d4\u0a21" + + "\b\u00d4\n\u00d4\f\u00d4\u0a24\t\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5" + + "\u0001\u00d5\u0003\u00d5\u0a2a\b\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5" + + "\u0003\u00d5\u0a2f\b\u00d5\u0001\u00d5\u0003\u00d5\u0a32\b\u00d5\u0001" + + "\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0003" + + "\u00d5\u0a3a\b\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0003" + + "\u00d6\u0a40\b\u00d6\u0001\u00d7\u0001\u00d7\u0003\u00d7\u0a44\b\u00d7" + + "\u0001\u00d7\u0001\u00d7\u0001\u00d8\u0001\u00d8\u0003\u00d8\u0a4a\b\u00d8" + + "\u0001\u00d8\u0001\u00d8\u0003\u00d8\u0a4e\b\u00d8\u0001\u00d9\u0001\u00d9" + + "\u0001\u00d9\u0000\u0000\u00da\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010" + + "\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPR" + + "TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e" + + "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6" + + "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be" + + "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6" + + "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee" + + "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106" + + "\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e" + + "\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136" + + "\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e" + + "\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166" + + "\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e" + + "\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196" + + "\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae" + + "\u01b0\u01b2\u0000\u0013\b\u0000\u0015\u0015\u0018\u001877??SSWWcdhh\u0002" + + "\u0000\"\"--\u0003\u000066HHPP\u0001\u0000\u009c\u009d\u0002\u0000\u0092" + + "\u0093\u009e\u009f\u0001\u0000\u0087\u0088\u0001\u0000\u0089\u008b\u000e" + + "\u0000\u0012\u0012\u0015\u0015\u0018\u0018\u001d\u001d\"\"--77??DDSSW" + + "W[[cdhh\u0002\u0000\u000e\u000e \u0002\u0000\u000f\u000fgg\f\u0000\t" + + "\t\u000f\u000f))99BBIIKOTTZZggkkmm\u0002\u0000((55\u0002\u0000\u0011\u0011" + + "^^\u0002\u0000\u0089\u0089\u0094\u0094\u0002\u000066HH\u0002\u0000**`" + + "`\u0013\u0000\t\t\r\r\u0011\u0013\u0015\u001f!\"$%\'/2249;;>?ADFFHJLP" + + "RTWikmpp\u0001\u0000OP\u0014\u0000\n\f\u000e\u0010\u0014\u0014 ##&&0" + + "133::<=@@EEGGKKQQUVffjjnoqr\u0b60\u0000\u01b5\u0001\u0000\u0000\u0000" + + "\u0002\u01cd\u0001\u0000\u0000\u0000\u0004\u01d9\u0001\u0000\u0000\u0000" + + "\u0006\u01e7\u0001\u0000\u0000\u0000\b\u01e9\u0001\u0000\u0000\u0000\n" + + "\u01f3\u0001\u0000\u0000\u0000\f\u01f9\u0001\u0000\u0000\u0000\u000e\u01fe" + + "\u0001\u0000\u0000\u0000\u0010\u0200\u0001\u0000\u0000\u0000\u0012\u0202" + + "\u0001\u0000\u0000\u0000\u0014\u0208\u0001\u0000\u0000\u0000\u0016\u020a" + + "\u0001\u0000\u0000\u0000\u0018\u0215\u0001\u0000\u0000\u0000\u001a\u0220" + + "\u0001\u0000\u0000\u0000\u001c\u022f\u0001\u0000\u0000\u0000\u001e\u0234" + + "\u0001\u0000\u0000\u0000 \u023e\u0001\u0000\u0000\u0000\"\u024b\u0001" + + "\u0000\u0000\u0000$\u024d\u0001\u0000\u0000\u0000&\u0255\u0001\u0000\u0000" + + "\u0000(\u025d\u0001\u0000\u0000\u0000*\u0265\u0001\u0000\u0000\u0000," + + "\u026d\u0001\u0000\u0000\u0000.\u0275\u0001\u0000\u0000\u00000\u027d\u0001" + + "\u0000\u0000\u00002\u0285\u0001\u0000\u0000\u00004\u028d\u0001\u0000\u0000" + + "\u00006\u0299\u0001\u0000\u0000\u00008\u02a4\u0001\u0000\u0000\u0000:" + + "\u02ac\u0001\u0000\u0000\u0000<\u02b4\u0001\u0000\u0000\u0000>\u02c0\u0001" + + "\u0000\u0000\u0000@\u02c8\u0001\u0000\u0000\u0000B\u02d7\u0001\u0000\u0000" + + "\u0000D\u02f3\u0001\u0000\u0000\u0000F\u02f5\u0001\u0000\u0000\u0000H" + + "\u0394\u0001\u0000\u0000\u0000J\u0398\u0001\u0000\u0000\u0000L\u039a\u0001" + + "\u0000\u0000\u0000N\u039e\u0001\u0000\u0000\u0000P\u03a6\u0001\u0000\u0000" + + "\u0000R\u03b6\u0001\u0000\u0000\u0000T\u03ba\u0001\u0000\u0000\u0000V" + + "\u03bc\u0001\u0000\u0000\u0000X\u03c6\u0001\u0000\u0000\u0000Z\u03c8\u0001" + + "\u0000\u0000\u0000\\\u03d1\u0001\u0000\u0000\u0000^\u03de\u0001\u0000" + + "\u0000\u0000`\u03e5\u0001\u0000\u0000\u0000b\u03e7\u0001\u0000\u0000\u0000" + + "d\u03fa\u0001\u0000\u0000\u0000f\u03fc\u0001\u0000\u0000\u0000h\u0405" + + "\u0001\u0000\u0000\u0000j\u0412\u0001\u0000\u0000\u0000l\u0414\u0001\u0000" + + "\u0000\u0000n\u0429\u0001\u0000\u0000\u0000p\u0432\u0001\u0000\u0000\u0000" + + "r\u0443\u0001\u0000\u0000\u0000t\u044e\u0001\u0000\u0000\u0000v\u0453" + + "\u0001\u0000\u0000\u0000x\u0464\u0001\u0000\u0000\u0000z\u0466\u0001\u0000" + + "\u0000\u0000|\u046f\u0001\u0000\u0000\u0000~\u0474\u0001\u0000\u0000\u0000" + + "\u0080\u047e\u0001\u0000\u0000\u0000\u0082\u0480\u0001\u0000\u0000\u0000" + + "\u0084\u0483\u0001\u0000\u0000\u0000\u0086\u048e\u0001\u0000\u0000\u0000" + + "\u0088\u049a\u0001\u0000\u0000\u0000\u008a\u049c\u0001\u0000\u0000\u0000" + + "\u008c\u04a1\u0001\u0000\u0000\u0000\u008e\u04a4\u0001\u0000\u0000\u0000" + + "\u0090\u04b3\u0001\u0000\u0000\u0000\u0092\u04bc\u0001\u0000\u0000\u0000" + + "\u0094\u04c7\u0001\u0000\u0000\u0000\u0096\u04c9\u0001\u0000\u0000\u0000" + + "\u0098\u04d0\u0001\u0000\u0000\u0000\u009a\u04d9\u0001\u0000\u0000\u0000" + + "\u009c\u04db\u0001\u0000\u0000\u0000\u009e\u04df\u0001\u0000\u0000\u0000" + + "\u00a0\u04f4\u0001\u0000\u0000\u0000\u00a2\u04fb\u0001\u0000\u0000\u0000" + + "\u00a4\u04fd\u0001\u0000\u0000\u0000\u00a6\u0503\u0001\u0000\u0000\u0000" + + "\u00a8\u0587\u0001\u0000\u0000\u0000\u00aa\u0589\u0001\u0000\u0000\u0000" + + "\u00ac\u05a2\u0001\u0000\u0000\u0000\u00ae\u05a6\u0001\u0000\u0000\u0000" + + "\u00b0\u05a8\u0001\u0000\u0000\u0000\u00b2\u05b3\u0001\u0000\u0000\u0000" + + "\u00b4\u05b5\u0001\u0000\u0000\u0000\u00b6\u05bb\u0001\u0000\u0000\u0000" + + "\u00b8\u05be\u0001\u0000\u0000\u0000\u00ba\u05cd\u0001\u0000\u0000\u0000" + + "\u00bc\u05cf\u0001\u0000\u0000\u0000\u00be\u05d3\u0001\u0000\u0000\u0000" + + "\u00c0\u05e0\u0001\u0000\u0000\u0000\u00c2\u05e2\u0001\u0000\u0000\u0000" + + "\u00c4\u05f5\u0001\u0000\u0000\u0000\u00c6\u05f7\u0001\u0000\u0000\u0000" + + "\u00c8\u0603\u0001\u0000\u0000\u0000\u00ca\u0609\u0001\u0000\u0000\u0000" + + "\u00cc\u060e\u0001\u0000\u0000\u0000\u00ce\u0613\u0001\u0000\u0000\u0000" + + "\u00d0\u0615\u0001\u0000\u0000\u0000\u00d2\u061b\u0001\u0000\u0000\u0000" + + "\u00d4\u0623\u0001\u0000\u0000\u0000\u00d6\u0630\u0001\u0000\u0000\u0000" + + "\u00d8\u0634\u0001\u0000\u0000\u0000\u00da\u063a\u0001\u0000\u0000\u0000" + + "\u00dc\u064d\u0001\u0000\u0000\u0000\u00de\u0650\u0001\u0000\u0000\u0000" + + "\u00e0\u0656\u0001\u0000\u0000\u0000\u00e2\u0659\u0001\u0000\u0000\u0000" + + "\u00e4\u0665\u0001\u0000\u0000\u0000\u00e6\u066b\u0001\u0000\u0000\u0000" + + "\u00e8\u0677\u0001\u0000\u0000\u0000\u00ea\u067b\u0001\u0000\u0000\u0000" + + "\u00ec\u0684\u0001\u0000\u0000\u0000\u00ee\u068d\u0001\u0000\u0000\u0000" + + "\u00f0\u0691\u0001\u0000\u0000\u0000\u00f2\u06a0\u0001\u0000\u0000\u0000" + + "\u00f4\u06a9\u0001\u0000\u0000\u0000\u00f6\u06ab\u0001\u0000\u0000\u0000" + + "\u00f8\u06b3\u0001\u0000\u0000\u0000\u00fa\u06b7\u0001\u0000\u0000\u0000" + + "\u00fc\u06be\u0001\u0000\u0000\u0000\u00fe\u06c3\u0001\u0000\u0000\u0000" + + "\u0100\u06cd\u0001\u0000\u0000\u0000\u0102\u06d1\u0001\u0000\u0000\u0000" + + "\u0104\u06e6\u0001\u0000\u0000\u0000\u0106\u06ed\u0001\u0000\u0000\u0000" + + "\u0108\u06fb\u0001\u0000\u0000\u0000\u010a\u0703\u0001\u0000\u0000\u0000" + + "\u010c\u0707\u0001\u0000\u0000\u0000\u010e\u070f\u0001\u0000\u0000\u0000" + + "\u0110\u0716\u0001\u0000\u0000\u0000\u0112\u071a\u0001\u0000\u0000\u0000" + + "\u0114\u071c\u0001\u0000\u0000\u0000\u0116\u0720\u0001\u0000\u0000\u0000" + + "\u0118\u0728\u0001\u0000\u0000\u0000\u011a\u072a\u0001\u0000\u0000\u0000" + + "\u011c\u073a\u0001\u0000\u0000\u0000\u011e\u0744\u0001\u0000\u0000\u0000" + + "\u0120\u0747\u0001\u0000\u0000\u0000\u0122\u074e\u0001\u0000\u0000\u0000" + + "\u0124\u0760\u0001\u0000\u0000\u0000\u0126\u0769\u0001\u0000\u0000\u0000" + + "\u0128\u0778\u0001\u0000\u0000\u0000\u012a\u077c\u0001\u0000\u0000\u0000" + + "\u012c\u077f\u0001\u0000\u0000\u0000\u012e\u078c\u0001\u0000\u0000\u0000" + + "\u0130\u0792\u0001\u0000\u0000\u0000\u0132\u07ad\u0001\u0000\u0000\u0000" + + "\u0134\u07af\u0001\u0000\u0000\u0000\u0136\u07b6\u0001\u0000\u0000\u0000" + + "\u0138\u07c0\u0001\u0000\u0000\u0000\u013a\u07c2\u0001\u0000\u0000\u0000" + + "\u013c\u07c5\u0001\u0000\u0000\u0000\u013e\u07cf\u0001\u0000\u0000\u0000" + + "\u0140\u07e0\u0001\u0000\u0000\u0000\u0142\u07ec\u0001\u0000\u0000\u0000" + + "\u0144\u07f5\u0001\u0000\u0000\u0000\u0146\u0805\u0001\u0000\u0000\u0000" + + "\u0148\u0811\u0001\u0000\u0000\u0000\u014a\u0818\u0001\u0000\u0000\u0000" + + "\u014c\u081a\u0001\u0000\u0000\u0000\u014e\u081d\u0001\u0000\u0000\u0000" + + "\u0150\u0827\u0001\u0000\u0000\u0000\u0152\u086e\u0001\u0000\u0000\u0000" + + "\u0154\u0884\u0001\u0000\u0000\u0000\u0156\u0887\u0001\u0000\u0000\u0000" + + "\u0158\u0898\u0001\u0000\u0000\u0000\u015a\u089f\u0001\u0000\u0000\u0000" + + "\u015c\u08aa\u0001\u0000\u0000\u0000\u015e\u08ad\u0001\u0000\u0000\u0000" + + "\u0160\u08b1\u0001\u0000\u0000\u0000\u0162\u08bf\u0001\u0000\u0000\u0000" + + "\u0164\u08c1\u0001\u0000\u0000\u0000\u0166\u08c9\u0001\u0000\u0000\u0000" + + "\u0168\u08db\u0001\u0000\u0000\u0000\u016a\u08ee\u0001\u0000\u0000\u0000" + + "\u016c\u08f0\u0001\u0000\u0000\u0000\u016e\u08f8\u0001\u0000\u0000\u0000" + + "\u0170\u0901\u0001\u0000\u0000\u0000\u0172\u0903\u0001\u0000\u0000\u0000" + + "\u0174\u0925\u0001\u0000\u0000\u0000\u0176\u0927\u0001\u0000\u0000\u0000" + + "\u0178\u092b\u0001\u0000\u0000\u0000\u017a\u092f\u0001\u0000\u0000\u0000" + + "\u017c\u093b\u0001\u0000\u0000\u0000\u017e\u093d\u0001\u0000\u0000\u0000" + + "\u0180\u0943\u0001\u0000\u0000\u0000\u0182\u0945\u0001\u0000\u0000\u0000" + + "\u0184\u094e\u0001\u0000\u0000\u0000\u0186\u095b\u0001\u0000\u0000\u0000" + + "\u0188\u0961\u0001\u0000\u0000\u0000\u018a\u0963\u0001\u0000\u0000\u0000" + + "\u018c\u0973\u0001\u0000\u0000\u0000\u018e\u0975\u0001\u0000\u0000\u0000" + + "\u0190\u0985\u0001\u0000\u0000\u0000\u0192\u0996\u0001\u0000\u0000\u0000" + + "\u0194\u09a5\u0001\u0000\u0000\u0000\u0196\u09ae\u0001\u0000\u0000\u0000" + + "\u0198\u09be\u0001\u0000\u0000\u0000\u019a\u09ca\u0001\u0000\u0000\u0000" + + "\u019c\u09cd\u0001\u0000\u0000\u0000\u019e\u09dd\u0001\u0000\u0000\u0000" + + "\u01a0\u09e2\u0001\u0000\u0000\u0000\u01a2\u09f0\u0001\u0000\u0000\u0000" + + "\u01a4\u09f6\u0001\u0000\u0000\u0000\u01a6\u0a01\u0001\u0000\u0000\u0000" + + "\u01a8\u0a19\u0001\u0000\u0000\u0000\u01aa\u0a25\u0001\u0000\u0000\u0000" + + "\u01ac\u0a3b\u0001\u0000\u0000\u0000\u01ae\u0a41\u0001\u0000\u0000\u0000" + + "\u01b0\u0a47\u0001\u0000\u0000\u0000\u01b2\u0a4f\u0001\u0000\u0000\u0000" + + "\u01b4\u01b6\u0005\u0001\u0000\u0000\u01b5\u01b4\u0001\u0000\u0000\u0000" + + "\u01b5\u01b6\u0001\u0000\u0000\u0000\u01b6\u01b8\u0001\u0000\u0000\u0000" + + "\u01b7\u01b9\u0003\u00d6k\u0000\u01b8\u01b7\u0001\u0000\u0000\u0000\u01b8" + + "\u01b9\u0001\u0000\u0000\u0000\u01b9\u01bb\u0001\u0000\u0000\u0000\u01ba" + + "\u01bc\u0003\u00dam\u0000\u01bb\u01ba\u0001\u0000\u0000\u0000\u01bb\u01bc" + + "\u0001\u0000\u0000\u0000\u01bc\u01c0\u0001\u0000\u0000\u0000\u01bd\u01bf" + + "\u0003\u015a\u00ad\u0000\u01be\u01bd\u0001\u0000\u0000\u0000\u01bf\u01c2" + + "\u0001\u0000\u0000\u0000\u01c0\u01be\u0001\u0000\u0000\u0000\u01c0\u01c1" + + "\u0001\u0000\u0000\u0000\u01c1\u01c4\u0001\u0000\u0000\u0000\u01c2\u01c0" + + "\u0001\u0000\u0000\u0000\u01c3\u01c5\u0003\u00deo\u0000\u01c4\u01c3\u0001" + + "\u0000\u0000\u0000\u01c4\u01c5\u0001\u0000\u0000\u0000\u01c5\u01c6\u0001" + + "\u0000\u0000\u0000\u01c6\u01c7\u0005\u0000\u0000\u0001\u01c7\u0001\u0001" + + "\u0000\u0000\u0000\u01c8\u01ca\u0003\u01b2\u00d9\u0000\u01c9\u01cb\u0003" + + "\u0016\u000b\u0000\u01ca\u01c9\u0001\u0000\u0000\u0000\u01ca\u01cb\u0001" + + "\u0000\u0000\u0000\u01cb\u01ce\u0001\u0000\u0000\u0000\u01cc\u01ce\u0003" + + "\u00e4r\u0000\u01cd\u01c8\u0001\u0000\u0000\u0000\u01cd\u01cc\u0001\u0000" + + "\u0000\u0000\u01ce\u01d6\u0001\u0000\u0000\u0000\u01cf\u01d0\u0005\u0083" + + "\u0000\u0000\u01d0\u01d2\u0003\u01b2\u00d9\u0000\u01d1\u01d3\u0003\u0016" + + "\u000b\u0000\u01d2\u01d1\u0001\u0000\u0000\u0000\u01d2\u01d3\u0001\u0000" + + "\u0000\u0000\u01d3\u01d5\u0001\u0000\u0000\u0000\u01d4\u01cf\u0001\u0000" + + "\u0000\u0000\u01d5\u01d8\u0001\u0000\u0000\u0000\u01d6\u01d4\u0001\u0000" + + "\u0000\u0000\u01d6\u01d7\u0001\u0000\u0000\u0000\u01d7\u0003\u0001\u0000" + + "\u0000\u0000\u01d8\u01d6\u0001\u0000\u0000\u0000\u01d9\u01df\u0003\u0006" + + "\u0003\u0000\u01da\u01de\u0005\u0094\u0000\u0000\u01db\u01de\u0003\u0142" + + "\u00a1\u0000\u01dc\u01de\u0005\u0089\u0000\u0000\u01dd\u01da\u0001\u0000" + + "\u0000\u0000\u01dd\u01db\u0001\u0000\u0000\u0000\u01dd\u01dc\u0001\u0000" + + "\u0000\u0000\u01de\u01e1\u0001\u0000\u0000\u0000\u01df\u01dd\u0001\u0000" + + "\u0000\u0000\u01df\u01e0\u0001\u0000\u0000\u0000\u01e0\u0005\u0001\u0000" + + "\u0000\u0000\u01e1\u01df\u0001\u0000\u0000\u0000\u01e2\u01e8\u0003\f\u0006" + + "\u0000\u01e3\u01e8\u0003\u0014\n\u0000\u01e4\u01e5\u0005l\u0000\u0000" + + "\u01e5\u01e8\u0005\u0089\u0000\u0000\u01e6\u01e8\u0003\b\u0004\u0000\u01e7" + + "\u01e2\u0001\u0000\u0000\u0000\u01e7\u01e3\u0001\u0000\u0000\u0000\u01e7" + + "\u01e4\u0001\u0000\u0000\u0000\u01e7\u01e6\u0001\u0000\u0000\u0000\u01e8" + + "\u0007\u0001\u0000\u0000\u0000\u01e9\u01ea\u0005\u0081\u0000\u0000\u01ea" + + "\u01ed\u0003\n\u0005\u0000\u01eb\u01ec\u0005\u0084\u0000\u0000\u01ec\u01ee" + + "\u0003\n\u0005\u0000\u01ed\u01eb\u0001\u0000\u0000\u0000\u01ee\u01ef\u0001" + + "\u0000\u0000\u0000\u01ef\u01ed\u0001\u0000\u0000\u0000\u01ef\u01f0\u0001" + + "\u0000\u0000\u0000\u01f0\u01f1\u0001\u0000\u0000\u0000\u01f1\u01f2\u0005" + + "\u0082\u0000\u0000\u01f2\t\u0001\u0000\u0000\u0000\u01f3\u01f5\u0003\u0004" + + "\u0002\u0000\u01f4\u01f6\u0003\u01b2\u00d9\u0000\u01f5\u01f4\u0001\u0000" + + "\u0000\u0000\u01f5\u01f6\u0001\u0000\u0000\u0000\u01f6\u000b\u0001\u0000" + + "\u0000\u0000\u01f7\u01fa\u0003\u000e\u0007\u0000\u01f8\u01fa\u0005\u0012" + + "\u0000\u0000\u01f9\u01f7\u0001\u0000\u0000\u0000\u01f9\u01f8\u0001\u0000" + + "\u0000\u0000\u01fa\r\u0001\u0000\u0000\u0000\u01fb\u01ff\u0003\u0010\b" + + "\u0000\u01fc\u01ff\u0003\u0012\t\u0000\u01fd\u01ff\u0005\u001d\u0000\u0000" + + "\u01fe\u01fb\u0001\u0000\u0000\u0000\u01fe\u01fc\u0001\u0000\u0000\u0000" + + "\u01fe\u01fd\u0001\u0000\u0000\u0000\u01ff\u000f\u0001\u0000\u0000\u0000" + + "\u0200\u0201\u0007\u0000\u0000\u0000\u0201\u0011\u0001\u0000\u0000\u0000" + + "\u0202\u0203\u0007\u0001\u0000\u0000\u0203\u0013\u0001\u0000\u0000\u0000" + + "\u0204\u0209\u0003\u0002\u0001\u0000\u0205\u0209\u0005D\u0000\u0000\u0206" + + "\u0209\u0005#\u0000\u0000\u0207\u0209\u0005[\u0000\u0000\u0208\u0204\u0001" + + "\u0000\u0000\u0000\u0208\u0205\u0001\u0000\u0000\u0000\u0208\u0206\u0001" + + "\u0000\u0000\u0000\u0208\u0207\u0001\u0000\u0000\u0000\u0209\u0015\u0001" + + "\u0000\u0000\u0000\u020a\u020b\u0005\u0092\u0000\u0000\u020b\u0210\u0003" + + "\u0004\u0002\u0000\u020c\u020d\u0005\u0084\u0000\u0000\u020d\u020f\u0003" + + "\u0004\u0002\u0000\u020e\u020c\u0001\u0000\u0000\u0000\u020f\u0212\u0001" + + "\u0000\u0000\u0000\u0210\u020e\u0001\u0000\u0000\u0000\u0210\u0211\u0001" + + "\u0000\u0000\u0000\u0211\u0213\u0001\u0000\u0000\u0000\u0212\u0210\u0001" + + "\u0000\u0000\u0000\u0213\u0214\u0005\u0093\u0000\u0000\u0214\u0017\u0001" + + "\u0000\u0000\u0000\u0215\u021a\u0003\u001a\r\u0000\u0216\u0217\u0005\u0084" + + "\u0000\u0000\u0217\u0219\u0003\u001a\r\u0000\u0218\u0216\u0001\u0000\u0000" + + "\u0000\u0219\u021c\u0001\u0000\u0000\u0000\u021a\u0218\u0001\u0000\u0000" + + "\u0000\u021a\u021b\u0001\u0000\u0000\u0000\u021b\u0019\u0001\u0000\u0000" + + "\u0000\u021c\u021a\u0001\u0000\u0000\u0000\u021d\u021e\u0003\u01b2\u00d9" + + "\u0000\u021e\u021f\u0005\u0085\u0000\u0000\u021f\u0221\u0001\u0000\u0000" + + "\u0000\u0220\u021d\u0001\u0000\u0000\u0000\u0220\u0221\u0001\u0000\u0000" + + "\u0000\u0221\u0223\u0001\u0000\u0000\u0000\u0222\u0224\u0007\u0002\u0000" + + "\u0000\u0223\u0222\u0001\u0000\u0000\u0000\u0223\u0224\u0001\u0000\u0000" + + "\u0000\u0224\u0227\u0001\u0000\u0000\u0000\u0225\u0228\u0005j\u0000\u0000" + + "\u0226\u0228\u0003\u0004\u0002\u0000\u0227\u0225\u0001\u0000\u0000\u0000" + + "\u0227\u0226\u0001\u0000\u0000\u0000\u0227\u0228\u0001\u0000\u0000\u0000" + + "\u0228\u0229\u0001\u0000\u0000\u0000\u0229\u022a\u0003\u001c\u000e\u0000" + + "\u022a\u001b\u0001\u0000\u0000\u0000\u022b\u0230\u0003 \u0010\u0000\u022c" + + "\u0230\u0003\u001e\u000f\u0000\u022d\u022e\u0005P\u0000\u0000\u022e\u0230" + + "\u0003\u001e\u000f\u0000\u022f\u022b\u0001\u0000\u0000\u0000\u022f\u022c" + + "\u0001\u0000\u0000\u0000\u022f\u022d\u0001\u0000\u0000\u0000\u0230\u001d" + + "\u0001\u0000\u0000\u0000\u0231\u0235\u0003v;\u0000\u0232\u0235\u0003\u0082" + + "A\u0000\u0233\u0235\u0003$\u0012\u0000\u0234\u0231\u0001\u0000\u0000\u0000" + + "\u0234\u0232\u0001\u0000\u0000\u0000\u0234\u0233\u0001\u0000\u0000\u0000" + + "\u0235\u001f\u0001\u0000\u0000\u0000\u0236\u0237\u0003D\"\u0000\u0237" + + "\u0238\u0003\"\u0011\u0000\u0238\u0239\u0003\u001c\u000e\u0000\u0239\u023f" + + "\u0001\u0000\u0000\u0000\u023a\u023b\u0003D\"\u0000\u023b\u023c\u0005" + + "\u00aa\u0000\u0000\u023c\u023d\u0003J%\u0000\u023d\u023f\u0001\u0000\u0000" + + "\u0000\u023e\u0236\u0001\u0000\u0000\u0000\u023e\u023a\u0001\u0000\u0000" + + "\u0000\u023f!\u0001\u0000\u0000\u0000\u0240\u024c\u0005\u0091\u0000\u0000" + + "\u0241\u024c\u0005\u00a0\u0000\u0000\u0242\u024c\u0005\u00a1\u0000\u0000" + + "\u0243\u024c\u0005\u00a2\u0000\u0000\u0244\u024c\u0005\u00a3\u0000\u0000" + + "\u0245\u024c\u0005\u00a4\u0000\u0000\u0246\u024c\u0005\u00a5\u0000\u0000" + + "\u0247\u024c\u0005\u00a6\u0000\u0000\u0248\u024c\u0005\u00a7\u0000\u0000" + + "\u0249\u024c\u0005\u00a9\u0000\u0000\u024a\u024c\u0003\u017a\u00bd\u0000" + + "\u024b\u0240\u0001\u0000\u0000\u0000\u024b\u0241\u0001\u0000\u0000\u0000" + + "\u024b\u0242\u0001\u0000\u0000\u0000\u024b\u0243\u0001\u0000\u0000\u0000" + + "\u024b\u0244\u0001\u0000\u0000\u0000\u024b\u0245\u0001\u0000\u0000\u0000" + + "\u024b\u0246\u0001\u0000\u0000\u0000\u024b\u0247\u0001\u0000\u0000\u0000" + + "\u024b\u0248\u0001\u0000\u0000\u0000\u024b\u0249\u0001\u0000\u0000\u0000" + + "\u024b\u024a\u0001\u0000\u0000\u0000\u024c#\u0001\u0000\u0000\u0000\u024d" + + "\u0253\u0003&\u0013\u0000\u024e\u024f\u0005\u0094\u0000\u0000\u024f\u0250" + + "\u0003J%\u0000\u0250\u0251\u0005\u0085\u0000\u0000\u0251\u0252\u0003J" + + "%\u0000\u0252\u0254\u0001\u0000\u0000\u0000\u0253\u024e\u0001\u0000\u0000" + + "\u0000\u0253\u0254\u0001\u0000\u0000\u0000\u0254%\u0001\u0000\u0000\u0000" + + "\u0255\u025b\u0003(\u0014\u0000\u0256\u0259\u0005\u0096\u0000\u0000\u0257" + + "\u025a\u0003&\u0013\u0000\u0258\u025a\u0003L&\u0000\u0259\u0257\u0001" + + "\u0000\u0000\u0000\u0259\u0258\u0001\u0000\u0000\u0000\u025a\u025c\u0001" + + "\u0000\u0000\u0000\u025b\u0256\u0001\u0000\u0000\u0000\u025b\u025c\u0001" + + "\u0000\u0000\u0000\u025c\'\u0001\u0000\u0000\u0000\u025d\u0262\u0003*" + + "\u0015\u0000\u025e\u025f\u0005\u009a\u0000\u0000\u025f\u0261\u0003*\u0015" + + "\u0000\u0260\u025e\u0001\u0000\u0000\u0000\u0261\u0264\u0001\u0000\u0000" + + "\u0000\u0262\u0260\u0001\u0000\u0000\u0000\u0262\u0263\u0001\u0000\u0000" + + "\u0000\u0263)\u0001\u0000\u0000\u0000\u0264\u0262\u0001\u0000\u0000\u0000" + + "\u0265\u026a\u0003,\u0016\u0000\u0266\u0267\u0005\u0099\u0000\u0000\u0267" + + "\u0269\u0003,\u0016\u0000\u0268\u0266\u0001\u0000\u0000\u0000\u0269\u026c" + + "\u0001\u0000\u0000\u0000\u026a\u0268\u0001\u0000\u0000\u0000\u026a\u026b" + + "\u0001\u0000\u0000\u0000\u026b+\u0001\u0000\u0000\u0000\u026c\u026a\u0001" + + "\u0000\u0000\u0000\u026d\u0272\u0003.\u0017\u0000\u026e\u026f\u0005\u008d" + + "\u0000\u0000\u026f\u0271\u0003.\u0017\u0000\u0270\u026e\u0001\u0000\u0000" + + "\u0000\u0271\u0274\u0001\u0000\u0000\u0000\u0272\u0270\u0001\u0000\u0000" + + "\u0000\u0272\u0273\u0001\u0000\u0000\u0000\u0273-\u0001\u0000\u0000\u0000" + + "\u0274\u0272\u0001\u0000\u0000\u0000\u0275\u027a\u00030\u0018\u0000\u0276" + + "\u0277\u0005\u008e\u0000\u0000\u0277\u0279\u00030\u0018\u0000\u0278\u0276" + + "\u0001\u0000\u0000\u0000\u0279\u027c\u0001\u0000\u0000\u0000\u027a\u0278" + + "\u0001\u0000\u0000\u0000\u027a\u027b\u0001\u0000\u0000\u0000\u027b/\u0001" + + "\u0000\u0000\u0000\u027c\u027a\u0001\u0000\u0000\u0000\u027d\u0282\u0003" + + "2\u0019\u0000\u027e\u027f\u0005\u008c\u0000\u0000\u027f\u0281\u00032\u0019" + + "\u0000\u0280\u027e\u0001\u0000\u0000\u0000\u0281\u0284\u0001\u0000\u0000" + + "\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0282\u0283\u0001\u0000\u0000" + + "\u0000\u02831\u0001\u0000\u0000\u0000\u0284\u0282\u0001\u0000\u0000\u0000" + + "\u0285\u028a\u00034\u001a\u0000\u0286\u0287\u0007\u0003\u0000\u0000\u0287" + + "\u0289\u00034\u001a\u0000\u0288\u0286\u0001\u0000\u0000\u0000\u0289\u028c" + + "\u0001\u0000\u0000\u0000\u028a\u0288\u0001\u0000\u0000\u0000\u028a\u028b" + + "\u0001\u0000\u0000\u0000\u028b3\u0001\u0000\u0000\u0000\u028c\u028a\u0001" + + "\u0000\u0000\u0000\u028d\u0296\u00036\u001b\u0000\u028e\u028f\u0007\u0004" + + "\u0000\u0000\u028f\u0295\u00036\u001b\u0000\u0290\u0291\u0005;\u0000\u0000" + + "\u0291\u0295\u0003p8\u0000\u0292\u0293\u0005\r\u0000\u0000\u0293\u0295" + + "\u0003\u0004\u0002\u0000\u0294\u028e\u0001\u0000\u0000\u0000\u0294\u0290" + + "\u0001\u0000\u0000\u0000\u0294\u0292\u0001\u0000\u0000\u0000\u0295\u0298" + + "\u0001\u0000\u0000\u0000\u0296\u0294\u0001\u0000\u0000\u0000\u0296\u0297" + + "\u0001\u0000\u0000\u0000\u02975\u0001\u0000\u0000\u0000\u0298\u0296\u0001" + + "\u0000\u0000\u0000\u0299\u02a1\u00038\u001c\u0000\u029a\u029d\u0005\u00a8" + + "\u0000\u0000\u029b\u029d\u0003\u0178\u00bc\u0000\u029c\u029a\u0001\u0000" + + "\u0000\u0000\u029c\u029b\u0001\u0000\u0000\u0000\u029d\u029e\u0001\u0000" + + "\u0000\u0000\u029e\u02a0\u00038\u001c\u0000\u029f\u029c\u0001\u0000\u0000" + + "\u0000\u02a0\u02a3\u0001\u0000\u0000\u0000\u02a1\u029f\u0001\u0000\u0000" + + "\u0000\u02a1\u02a2\u0001\u0000\u0000\u0000\u02a27\u0001\u0000\u0000\u0000" + + "\u02a3\u02a1\u0001\u0000\u0000\u0000\u02a4\u02a9\u0003:\u001d\u0000\u02a5" + + "\u02a6\u0007\u0005\u0000\u0000\u02a6\u02a8\u0003:\u001d\u0000\u02a7\u02a5" + + "\u0001\u0000\u0000\u0000\u02a8\u02ab\u0001\u0000\u0000\u0000\u02a9\u02a7" + + "\u0001\u0000\u0000\u0000\u02a9\u02aa\u0001\u0000\u0000\u0000\u02aa9\u0001" + + "\u0000\u0000\u0000\u02ab\u02a9\u0001\u0000\u0000\u0000\u02ac\u02b1\u0003" + + "<\u001e\u0000\u02ad\u02ae\u0007\u0006\u0000\u0000\u02ae\u02b0\u0003<\u001e" + + "\u0000\u02af\u02ad\u0001\u0000\u0000\u0000\u02b0\u02b3\u0001\u0000\u0000" + + "\u0000\u02b1\u02af\u0001\u0000\u0000\u0000\u02b1\u02b2\u0001\u0000\u0000" + + "\u0000\u02b2;\u0001\u0000\u0000\u0000\u02b3\u02b1\u0001\u0000\u0000\u0000" + + "\u02b4\u02be\u0003B!\u0000\u02b5\u02b6\u0005]\u0000\u0000\u02b6\u02bb" + + "\u0005}\u0000\u0000\u02b7\u02b9\u0003>\u001f\u0000\u02b8\u02ba\u0005\u0084" + + "\u0000\u0000\u02b9\u02b8\u0001\u0000\u0000\u0000\u02b9\u02ba\u0001\u0000" + + "\u0000\u0000\u02ba\u02bc\u0001\u0000\u0000\u0000\u02bb\u02b7\u0001\u0000" + + "\u0000\u0000\u02bb\u02bc\u0001\u0000\u0000\u0000\u02bc\u02bd\u0001\u0000" + + "\u0000\u0000\u02bd\u02bf\u0005~\u0000\u0000\u02be\u02b5\u0001\u0000\u0000" + + "\u0000\u02be\u02bf\u0001\u0000\u0000\u0000\u02bf=\u0001\u0000\u0000\u0000" + + "\u02c0\u02c5\u0003@ \u0000\u02c1\u02c2\u0005\u0084\u0000\u0000\u02c2\u02c4" + + "\u0003@ \u0000\u02c3\u02c1\u0001\u0000\u0000\u0000\u02c4\u02c7\u0001\u0000" + + "\u0000\u0000\u02c5\u02c3\u0001\u0000\u0000\u0000\u02c5\u02c6\u0001\u0000" + + "\u0000\u0000\u02c6?\u0001\u0000\u0000\u0000\u02c7\u02c5\u0001\u0000\u0000" + + "\u0000\u02c8\u02ca\u0003\u001c\u000e\u0000\u02c9\u02cb\u0003\u00bc^\u0000" + + "\u02ca\u02c9\u0001\u0000\u0000\u0000\u02ca\u02cb\u0001\u0000\u0000\u0000" + + "\u02cb\u02cc\u0001\u0000\u0000\u0000\u02cc\u02cd\u0003\u0176\u00bb\u0000" + + "\u02cd\u02ce\u0003J%\u0000\u02ceA\u0001\u0000\u0000\u0000\u02cf\u02d8" + + "\u0003D\"\u0000\u02d0\u02d2\u0003D\"\u0000\u02d1\u02d0\u0001\u0000\u0000" + + "\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000\u02d2\u02d3\u0001\u0000\u0000" + + "\u0000\u02d3\u02d5\u0005\u00ab\u0000\u0000\u02d4\u02d6\u0003D\"\u0000" + + "\u02d5\u02d4\u0001\u0000\u0000\u0000\u02d5\u02d6\u0001\u0000\u0000\u0000" + + "\u02d6\u02d8\u0001\u0000\u0000\u0000\u02d7\u02cf\u0001\u0000\u0000\u0000" + + "\u02d7\u02d1\u0001\u0000\u0000\u0000\u02d8C\u0001\u0000\u0000\u0000\u02d9" + + "\u02f4\u0003F#\u0000\u02da\u02db\u0005\u0087\u0000\u0000\u02db\u02f4\u0003" + + "D\"\u0000\u02dc\u02dd\u0005\u0088\u0000\u0000\u02dd\u02f4\u0003D\"\u0000" + + "\u02de\u02df\u0005\u008f\u0000\u0000\u02df\u02f4\u0003D\"\u0000\u02e0" + + "\u02e1\u0005\u0090\u0000\u0000\u02e1\u02f4\u0003D\"\u0000\u02e2\u02e3" + + "\u0005\u0097\u0000\u0000\u02e3\u02f4\u0003D\"\u0000\u02e4\u02e5\u0005" + + "\u0098\u0000\u0000\u02e5\u02f4\u0003D\"\u0000\u02e6\u02e7\u0005\u0081" + + "\u0000\u0000\u02e7\u02e8\u0003\u0004\u0002\u0000\u02e8\u02e9\u0005\u0082" + + "\u0000\u0000\u02e9\u02ea\u0003D\"\u0000\u02ea\u02f4\u0001\u0000\u0000" + + "\u0000\u02eb\u02ec\u0005\u0010\u0000\u0000\u02ec\u02f4\u0003D\"\u0000" + + "\u02ed\u02ee\u0005\u008c\u0000\u0000\u02ee\u02f4\u0003D\"\u0000\u02ef" + + "\u02f0\u0005\u0089\u0000\u0000\u02f0\u02f4\u0003D\"\u0000\u02f1\u02f2" + + "\u0005\u008e\u0000\u0000\u02f2\u02f4\u0003D\"\u0000\u02f3\u02d9\u0001" + + "\u0000\u0000\u0000\u02f3\u02da\u0001\u0000\u0000\u0000\u02f3\u02dc\u0001" + + "\u0000\u0000\u0000\u02f3\u02de\u0001\u0000\u0000\u0000\u02f3\u02e0\u0001" + + "\u0000\u0000\u0000\u02f3\u02e2\u0001\u0000\u0000\u0000\u02f3\u02e4\u0001" + + "\u0000\u0000\u0000\u02f3\u02e6\u0001\u0000\u0000\u0000\u02f3\u02eb\u0001" + + "\u0000\u0000\u0000\u02f3\u02ed\u0001\u0000\u0000\u0000\u02f3\u02ef\u0001" + + "\u0000\u0000\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f4E\u0001\u0000" + + "\u0000\u0000\u02f5\u02f7\u0003H$\u0000\u02f6\u02f8\u0005\u008f\u0000\u0000" + + "\u02f7\u02f6\u0001\u0000\u0000\u0000\u02f7\u02f8\u0001\u0000\u0000\u0000" + + "\u02f8\u02fc\u0001\u0000\u0000\u0000\u02f9\u02fb\u0003P(\u0000\u02fa\u02f9" + + "\u0001\u0000\u0000\u0000\u02fb\u02fe\u0001\u0000\u0000\u0000\u02fc\u02fa" + + "\u0001\u0000\u0000\u0000\u02fc\u02fd\u0001\u0000\u0000\u0000\u02fd\u0300" + + "\u0001\u0000\u0000\u0000\u02fe\u02fc\u0001\u0000\u0000\u0000\u02ff\u0301" + + "\u0005\u008f\u0000\u0000\u0300\u02ff\u0001\u0000\u0000\u0000\u0300\u0301" + + "\u0001\u0000\u0000\u0000\u0301\u0318\u0001\u0000\u0000\u0000\u0302\u0309" + + "\u0003N\'\u0000\u0303\u0309\u0003\u01ae\u00d7\u0000\u0304\u0309\u0005" + + "\u0097\u0000\u0000\u0305\u0309\u0005\u0098\u0000\u0000\u0306\u0307\u0005" + + "\u009b\u0000\u0000\u0307\u0309\u0003\u01b2\u00d9\u0000\u0308\u0302\u0001" + + "\u0000\u0000\u0000\u0308\u0303\u0001\u0000\u0000\u0000\u0308\u0304\u0001" + + "\u0000\u0000\u0000\u0308\u0305\u0001\u0000\u0000\u0000\u0308\u0306\u0001" + + "\u0000\u0000\u0000\u0309\u030b\u0001\u0000\u0000\u0000\u030a\u030c\u0005" + + "\u008f\u0000\u0000\u030b\u030a\u0001\u0000\u0000\u0000\u030b\u030c\u0001" + + "\u0000\u0000\u0000\u030c\u0310\u0001\u0000\u0000\u0000\u030d\u030f\u0003" + + "P(\u0000\u030e\u030d\u0001\u0000\u0000\u0000\u030f\u0312\u0001\u0000\u0000" + + "\u0000\u0310\u030e\u0001\u0000\u0000\u0000\u0310\u0311\u0001\u0000\u0000" + + "\u0000\u0311\u0314\u0001\u0000\u0000\u0000\u0312\u0310\u0001\u0000\u0000" + + "\u0000\u0313\u0315\u0005\u008f\u0000\u0000\u0314\u0313\u0001\u0000\u0000" + + "\u0000\u0314\u0315\u0001\u0000\u0000\u0000\u0315\u0317\u0001\u0000\u0000" + + "\u0000\u0316\u0308\u0001\u0000\u0000\u0000\u0317\u031a\u0001\u0000\u0000" + + "\u0000\u0318\u0316\u0001\u0000\u0000\u0000\u0318\u0319\u0001\u0000\u0000" + + "\u0000\u0319G\u0001\u0000\u0000\u0000\u031a\u0318\u0001\u0000\u0000\u0000" + + "\u031b\u0395\u0003\u017c\u00be\u0000\u031c\u031e\u0003\u01b2\u00d9\u0000" + + "\u031d\u031f\u0003\u0016\u000b\u0000\u031e\u031d\u0001\u0000\u0000\u0000" + + "\u031e\u031f\u0001\u0000\u0000\u0000\u031f\u0395\u0001\u0000\u0000\u0000" + + "\u0320\u0321\u0005\u0081\u0000\u0000\u0321\u0322\u0003\u001c\u000e\u0000" + + "\u0322\u0323\u0005\u0082\u0000\u0000\u0323\u0395\u0001\u0000\u0000\u0000" + + "\u0324\u0395\u0003T*\u0000\u0325\u0395\u0003\u00e4r\u0000\u0326\u0395" + + "\u0005s\u0000\u0000\u0327\u0395\u0005^\u0000\u0000\u0328\u0332\u0005\u0011" + + "\u0000\u0000\u0329\u032a\u0005\u0083\u0000\u0000\u032a\u032c\u0003\u01b2" + + "\u00d9\u0000\u032b\u032d\u0003\u0016\u000b\u0000\u032c\u032b\u0001\u0000" + + "\u0000\u0000\u032c\u032d\u0001\u0000\u0000\u0000\u032d\u0333\u0001\u0000" + + "\u0000\u0000\u032e\u032f\u0005\u007f\u0000\u0000\u032f\u0330\u0003V+\u0000" + + "\u0330\u0331\u0005\u0080\u0000\u0000\u0331\u0333\u0001\u0000\u0000\u0000" + + "\u0332\u0329\u0001\u0000\u0000\u0000\u0332\u032e\u0001\u0000\u0000\u0000" + + "\u0333\u0395\u0001\u0000\u0000\u0000\u0334\u0351\u0005B\u0000\u0000\u0335" + + "\u034b\u0003\u0004\u0002\u0000\u0336\u034c\u0003\u01b0\u00d8\u0000\u0337" + + "\u034c\u0003X,\u0000\u0338\u0339\u0005\u007f\u0000\u0000\u0339\u033a\u0003" + + "V+\u0000\u033a\u033e\u0005\u0080\u0000\u0000\u033b\u033d\u0003\u0142\u00a1" + + "\u0000\u033c\u033b\u0001\u0000\u0000\u0000\u033d\u0340\u0001\u0000\u0000" + + "\u0000\u033e\u033c\u0001\u0000\u0000\u0000\u033e\u033f\u0001\u0000\u0000" + + "\u0000\u033f\u0342\u0001\u0000\u0000\u0000\u0340\u033e\u0001\u0000\u0000" + + "\u0000\u0341\u0343\u0003\u0144\u00a2\u0000\u0342\u0341\u0001\u0000\u0000" + + "\u0000\u0342\u0343\u0001\u0000\u0000\u0000\u0343\u034c\u0001\u0000\u0000" + + "\u0000\u0344\u0346\u0003\u0142\u00a1\u0000\u0345\u0344\u0001\u0000\u0000" + + "\u0000\u0346\u0347\u0001\u0000\u0000\u0000\u0347\u0345\u0001\u0000\u0000" + + "\u0000\u0347\u0348\u0001\u0000\u0000\u0000\u0348\u0349\u0001\u0000\u0000" + + "\u0000\u0349\u034a\u0003\u0144\u00a2\u0000\u034a\u034c\u0001\u0000\u0000" + + "\u0000\u034b\u0336\u0001\u0000\u0000\u0000\u034b\u0337\u0001\u0000\u0000" + + "\u0000\u034b\u0338\u0001\u0000\u0000\u0000\u034b\u0345\u0001\u0000\u0000" + + "\u0000\u034c\u0352\u0001\u0000\u0000\u0000\u034d\u0352\u0003f3\u0000\u034e" + + "\u034f\u0003\u0142\u00a1\u0000\u034f\u0350\u0003\u0144\u00a2\u0000\u0350" + + "\u0352\u0001\u0000\u0000\u0000\u0351\u0335\u0001\u0000\u0000\u0000\u0351" + + "\u034d\u0001\u0000\u0000\u0000\u0351\u034e\u0001\u0000\u0000\u0000\u0352" + + "\u0395\u0001\u0000\u0000\u0000\u0353\u0354\u0005\u0081\u0000\u0000\u0354" + + "\u0357\u0003\u001a\r\u0000\u0355\u0356\u0005\u0084\u0000\u0000\u0356\u0358" + + "\u0003\u001a\r\u0000\u0357\u0355\u0001\u0000\u0000\u0000\u0358\u0359\u0001" + + "\u0000\u0000\u0000\u0359\u0357\u0001\u0000\u0000\u0000\u0359\u035a\u0001" + + "\u0000\u0000\u0000\u035a\u035b\u0001\u0000\u0000\u0000\u035b\u035c\u0005" + + "\u0082\u0000\u0000\u035c\u0395\u0001\u0000\u0000\u0000\u035d\u035e\u0005" + + "b\u0000\u0000\u035e\u0362\u0005\u0081\u0000\u0000\u035f\u0363\u0003l6" + + "\u0000\u0360\u0363\u0003\u0004\u0002\u0000\u0361\u0363\u0005l\u0000\u0000" + + "\u0362\u035f\u0001\u0000\u0000\u0000\u0362\u0360\u0001\u0000\u0000\u0000" + + "\u0362\u0361\u0001\u0000\u0000\u0000\u0363\u0364\u0001\u0000\u0000\u0000" + + "\u0364\u0395\u0005\u0082\u0000\u0000\u0365\u0366\u0005\u0019\u0000\u0000" + + "\u0366\u0367\u0005\u0081\u0000\u0000\u0367\u0368\u0003\u001c\u000e\u0000" + + "\u0368\u0369\u0005\u0082\u0000\u0000\u0369\u0395\u0001\u0000\u0000\u0000" + + "\u036a\u036b\u0005e\u0000\u0000\u036b\u036c\u0005\u0081\u0000\u0000\u036c" + + "\u036d\u0003\u001c\u000e\u0000\u036d\u036e\u0005\u0082\u0000\u0000\u036e" + + "\u0395\u0001\u0000\u0000\u0000\u036f\u0374\u0005\u001e\u0000\u0000\u0370" + + "\u0371\u0005\u0081\u0000\u0000\u0371\u0372\u0003\u0004\u0002\u0000\u0372" + + "\u0373\u0005\u0082\u0000\u0000\u0373\u0375\u0001\u0000\u0000\u0000\u0374" + + "\u0370\u0001\u0000\u0000\u0000\u0374\u0375\u0001\u0000\u0000\u0000\u0375" + + "\u0395\u0001\u0000\u0000\u0000\u0376\u0378\u0005\u000f\u0000\u0000\u0377" + + "\u0376\u0001\u0000\u0000\u0000\u0377\u0378\u0001\u0000\u0000\u0000\u0378" + + "\u0379\u0001\u0000\u0000\u0000\u0379\u037f\u0005\u001f\u0000\u0000\u037a" + + "\u037c\u0005\u0081\u0000\u0000\u037b\u037d\u0003z=\u0000\u037c\u037b\u0001" + + "\u0000\u0000\u0000\u037c\u037d\u0001\u0000\u0000\u0000\u037d\u037e\u0001" + + "\u0000\u0000\u0000\u037e\u0380\u0005\u0082\u0000\u0000\u037f\u037a\u0001" + + "\u0000\u0000\u0000\u037f\u0380\u0001\u0000\u0000\u0000\u0380\u0381\u0001" + + "\u0000\u0000\u0000\u0381\u0395\u0003\u00aaU\u0000\u0382\u0383\u0005X\u0000" + + "\u0000\u0383\u0384\u0005\u0081\u0000\u0000\u0384\u0385\u0003\u0004\u0002" + + "\u0000\u0385\u0386\u0005\u0082\u0000\u0000\u0386\u0395\u0001\u0000\u0000" + + "\u0000\u0387\u0388\u0005@\u0000\u0000\u0388\u038e\u0005\u0081\u0000\u0000" + + "\u0389\u038a\u0003\u01b2\u00d9\u0000\u038a\u038b\u0005\u0083\u0000\u0000" + + "\u038b\u038d\u0001\u0000\u0000\u0000\u038c\u0389\u0001\u0000\u0000\u0000" + + "\u038d\u0390\u0001\u0000\u0000\u0000\u038e\u038c\u0001\u0000\u0000\u0000" + + "\u038e\u038f\u0001\u0000\u0000\u0000\u038f\u0391\u0001\u0000\u0000\u0000" + + "\u0390\u038e\u0001\u0000\u0000\u0000\u0391\u0392\u0003\u01b2\u00d9\u0000" + + "\u0392\u0393\u0005\u0082\u0000\u0000\u0393\u0395\u0001\u0000\u0000\u0000" + + "\u0394\u031b\u0001\u0000\u0000\u0000\u0394\u031c\u0001\u0000\u0000\u0000" + + "\u0394\u0320\u0001\u0000\u0000\u0000\u0394\u0324\u0001\u0000\u0000\u0000" + + "\u0394\u0325\u0001\u0000\u0000\u0000\u0394\u0326\u0001\u0000\u0000\u0000" + + "\u0394\u0327\u0001\u0000\u0000\u0000\u0394\u0328\u0001\u0000\u0000\u0000" + + "\u0394\u0334\u0001\u0000\u0000\u0000\u0394\u0353\u0001\u0000\u0000\u0000" + + "\u0394\u035d\u0001\u0000\u0000\u0000\u0394\u0365\u0001\u0000\u0000\u0000" + + "\u0394\u036a\u0001\u0000\u0000\u0000\u0394\u036f\u0001\u0000\u0000\u0000" + + "\u0394\u0377\u0001\u0000\u0000\u0000\u0394\u0382\u0001\u0000\u0000\u0000" + + "\u0394\u0387\u0001\u0000\u0000\u0000\u0395I\u0001\u0000\u0000\u0000\u0396" + + "\u0399\u0003\u001c\u000e\u0000\u0397\u0399\u0003L&\u0000\u0398\u0396\u0001" + + "\u0000\u0000\u0000\u0398\u0397\u0001\u0000\u0000\u0000\u0399K\u0001\u0000" + + "\u0000\u0000\u039a\u039b\u0005_\u0000\u0000\u039b\u039c\u0003\u001c\u000e" + + "\u0000\u039cM\u0001\u0000\u0000\u0000\u039d\u039f\u0005\u0094\u0000\u0000" + + "\u039e\u039d\u0001\u0000\u0000\u0000\u039e\u039f\u0001\u0000\u0000\u0000" + + "\u039f\u03a0\u0001\u0000\u0000\u0000\u03a0\u03a1\u0005\u0083\u0000\u0000" + + "\u03a1\u03a3\u0003\u01b2\u00d9\u0000\u03a2\u03a4\u0003\u0016\u000b\u0000" + + "\u03a3\u03a2\u0001\u0000\u0000\u0000\u03a3\u03a4\u0001\u0000\u0000\u0000" + + "\u03a4O\u0001\u0000\u0000\u0000\u03a5\u03a7\u0005\u0094\u0000\u0000\u03a6" + + "\u03a5\u0001\u0000\u0000\u0000\u03a6\u03a7\u0001\u0000\u0000\u0000\u03a7" + + "\u03a8\u0001\u0000\u0000\u0000\u03a8\u03a9\u0005\u007f\u0000\u0000\u03a9" + + "\u03ae\u0003R)\u0000\u03aa\u03ab\u0005\u0084\u0000\u0000\u03ab\u03ad\u0003" + + "R)\u0000\u03ac\u03aa\u0001\u0000\u0000\u0000\u03ad\u03b0\u0001\u0000\u0000" + + "\u0000\u03ae\u03ac\u0001\u0000\u0000\u0000\u03ae\u03af\u0001\u0000\u0000" + + "\u0000\u03af\u03b1\u0001\u0000\u0000\u0000\u03b0\u03ae\u0001\u0000\u0000" + + "\u0000\u03b1\u03b2\u0005\u0080\u0000\u0000\u03b2Q\u0001\u0000\u0000\u0000" + + "\u03b3\u03b4\u0003\u01b2\u00d9\u0000\u03b4\u03b5\u0005\u0085\u0000\u0000" + + "\u03b5\u03b7\u0001\u0000\u0000\u0000\u03b6\u03b3\u0001\u0000\u0000\u0000" + + "\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u03b8\u0001\u0000\u0000\u0000" + + "\u03b8\u03b9\u0003\u001c\u000e\u0000\u03b9S\u0001\u0000\u0000\u0000\u03ba" + + "\u03bb\u0007\u0007\u0000\u0000\u03bbU\u0001\u0000\u0000\u0000\u03bc\u03c1" + + "\u0003\u001c\u000e\u0000\u03bd\u03be\u0005\u0084\u0000\u0000\u03be\u03c0" + + "\u0003\u001c\u000e\u0000\u03bf\u03bd\u0001\u0000\u0000\u0000\u03c0\u03c3" + + "\u0001\u0000\u0000\u0000\u03c1\u03bf\u0001\u0000\u0000\u0000\u03c1\u03c2" + + "\u0001\u0000\u0000\u0000\u03c2W\u0001\u0000\u0000\u0000\u03c3\u03c1\u0001" + + "\u0000\u0000\u0000\u03c4\u03c7\u0003Z-\u0000\u03c5\u03c7\u0003b1\u0000" + + "\u03c6\u03c4\u0001\u0000\u0000\u0000\u03c6\u03c5\u0001\u0000\u0000\u0000" + + "\u03c7Y\u0001\u0000\u0000\u0000\u03c8\u03cd\u0005}\u0000\u0000\u03c9\u03cb" + + "\u0003\\.\u0000\u03ca\u03cc\u0005\u0084\u0000\u0000\u03cb\u03ca\u0001" + + "\u0000\u0000\u0000\u03cb\u03cc\u0001\u0000\u0000\u0000\u03cc\u03ce\u0001" + + "\u0000\u0000\u0000\u03cd\u03c9\u0001\u0000\u0000\u0000\u03cd\u03ce\u0001" + + "\u0000\u0000\u0000\u03ce\u03cf\u0001\u0000\u0000\u0000\u03cf\u03d0\u0005" + + "~\u0000\u0000\u03d0[\u0001\u0000\u0000\u0000\u03d1\u03d6\u0003^/\u0000" + + "\u03d2\u03d3\u0005\u0084\u0000\u0000\u03d3\u03d5\u0003^/\u0000\u03d4\u03d2" + + "\u0001\u0000\u0000\u0000\u03d5\u03d8\u0001\u0000\u0000\u0000\u03d6\u03d4" + + "\u0001\u0000\u0000\u0000\u03d6\u03d7\u0001\u0000\u0000\u0000\u03d7]\u0001" + + "\u0000\u0000\u0000\u03d8\u03d6\u0001\u0000\u0000\u0000\u03d9\u03df\u0003" + + "\u01b2\u00d9\u0000\u03da\u03db\u0005\u007f\u0000\u0000\u03db\u03dc\u0003" + + "\u001c\u000e\u0000\u03dc\u03dd\u0005\u0080\u0000\u0000\u03dd\u03df\u0001" + + "\u0000\u0000\u0000\u03de\u03d9\u0001\u0000\u0000\u0000\u03de\u03da\u0001" + + "\u0000\u0000\u0000\u03df\u03e0\u0001\u0000\u0000\u0000\u03e0\u03e1\u0005" + + "\u0091\u0000\u0000\u03e1\u03e2\u0003`0\u0000\u03e2_\u0001\u0000\u0000" + + "\u0000\u03e3\u03e6\u0003\u001c\u000e\u0000\u03e4\u03e6\u0003X,\u0000\u03e5" + + "\u03e3\u0001\u0000\u0000\u0000\u03e5\u03e4\u0001\u0000\u0000\u0000\u03e6" + + "a\u0001\u0000\u0000\u0000\u03e7\u03e8\u0005}\u0000\u0000\u03e8\u03ed\u0003" + + "d2\u0000\u03e9\u03ea\u0005\u0084\u0000\u0000\u03ea\u03ec\u0003d2\u0000" + + "\u03eb\u03e9\u0001\u0000\u0000\u0000\u03ec\u03ef\u0001\u0000\u0000\u0000" + + "\u03ed\u03eb\u0001\u0000\u0000\u0000\u03ed\u03ee\u0001\u0000\u0000\u0000" + + "\u03ee\u03f1\u0001\u0000\u0000\u0000\u03ef\u03ed\u0001\u0000\u0000\u0000" + + "\u03f0\u03f2\u0005\u0084\u0000\u0000\u03f1\u03f0\u0001\u0000\u0000\u0000" + + "\u03f1\u03f2\u0001\u0000\u0000\u0000\u03f2\u03f3\u0001\u0000\u0000\u0000" + + "\u03f3\u03f4\u0005~\u0000\u0000\u03f4c\u0001\u0000\u0000\u0000\u03f5\u03fb" + + "\u0003\u001e\u000f\u0000\u03f6\u03f7\u0005}\u0000\u0000\u03f7\u03f8\u0003" + + "V+\u0000\u03f8\u03f9\u0005~\u0000\u0000\u03f9\u03fb\u0001\u0000\u0000" + + "\u0000\u03fa\u03f5\u0001\u0000\u0000\u0000\u03fa\u03f6\u0001\u0000\u0000" + + "\u0000\u03fbe\u0001\u0000\u0000\u0000\u03fc\u0401\u0005}\u0000\u0000\u03fd" + + "\u03ff\u0003h4\u0000\u03fe\u0400\u0005\u0084\u0000\u0000\u03ff\u03fe\u0001" + + "\u0000\u0000\u0000\u03ff\u0400\u0001\u0000\u0000\u0000\u0400\u0402\u0001" + + "\u0000\u0000\u0000\u0401\u03fd\u0001\u0000\u0000\u0000\u0401\u0402\u0001" + + "\u0000\u0000\u0000\u0402\u0403\u0001\u0000\u0000\u0000\u0403\u0404\u0005" + + "~\u0000\u0000\u0404g\u0001\u0000\u0000\u0000\u0405\u040a\u0003j5\u0000" + + "\u0406\u0407\u0005\u0084\u0000\u0000\u0407\u0409\u0003j5\u0000\u0408\u0406" + + "\u0001\u0000\u0000\u0000\u0409\u040c\u0001\u0000\u0000\u0000\u040a\u0408" + + "\u0001\u0000\u0000\u0000\u040a\u040b\u0001\u0000\u0000\u0000\u040bi\u0001" + + "\u0000\u0000\u0000\u040c\u040a\u0001\u0000\u0000\u0000\u040d\u0413\u0003" + + "F#\u0000\u040e\u040f\u0003\u01b2\u00d9\u0000\u040f\u0410\u0005\u0091\u0000" + + "\u0000\u0410\u0411\u0003\u001c\u000e\u0000\u0411\u0413\u0001\u0000\u0000" + + "\u0000\u0412\u040d\u0001\u0000\u0000\u0000\u0412\u040e\u0001\u0000\u0000" + + "\u0000\u0413k\u0001\u0000\u0000\u0000\u0414\u041d\u0003\u01b2\u00d9\u0000" + + "\u0415\u0417\u0003n7\u0000\u0416\u0415\u0001\u0000\u0000\u0000\u0416\u0417" + + "\u0001\u0000\u0000\u0000\u0417\u041e\u0001\u0000\u0000\u0000\u0418\u0419" + + "\u0005\u0095\u0000\u0000\u0419\u041b\u0003\u01b2\u00d9\u0000\u041a\u041c" + + "\u0003n7\u0000\u041b\u041a\u0001\u0000\u0000\u0000\u041b\u041c\u0001\u0000" + + "\u0000\u0000\u041c\u041e\u0001\u0000\u0000\u0000\u041d\u0416\u0001\u0000" + + "\u0000\u0000\u041d\u0418\u0001\u0000\u0000\u0000\u041e\u0426\u0001\u0000" + + "\u0000\u0000\u041f\u0420\u0005\u0083\u0000\u0000\u0420\u0422\u0003\u01b2" + + "\u00d9\u0000\u0421\u0423\u0003n7\u0000\u0422\u0421\u0001\u0000\u0000\u0000" + + "\u0422\u0423\u0001\u0000\u0000\u0000\u0423\u0425\u0001\u0000\u0000\u0000" + + "\u0424\u041f\u0001\u0000\u0000\u0000\u0425\u0428\u0001\u0000\u0000\u0000" + + "\u0426\u0424\u0001\u0000\u0000\u0000\u0426\u0427\u0001\u0000\u0000\u0000" + + "\u0427m\u0001\u0000\u0000\u0000\u0428\u0426\u0001\u0000\u0000\u0000\u0429" + + "\u042d\u0005\u0092\u0000\u0000\u042a\u042c\u0005\u0084\u0000\u0000\u042b" + + "\u042a\u0001\u0000\u0000\u0000\u042c\u042f\u0001\u0000\u0000\u0000\u042d" + + "\u042b\u0001\u0000\u0000\u0000\u042d\u042e\u0001\u0000\u0000\u0000\u042e" + + "\u0430\u0001\u0000\u0000\u0000\u042f\u042d\u0001\u0000\u0000\u0000\u0430" + + "\u0431\u0005\u0093\u0000\u0000\u0431o\u0001\u0000\u0000\u0000\u0432\u0437" + + "\u0003\u0006\u0003\u0000\u0433\u0436\u0003\u0142\u00a1\u0000\u0434\u0436" + + "\u0005\u0089\u0000\u0000\u0435\u0433\u0001\u0000\u0000\u0000\u0435\u0434" + + "\u0001\u0000\u0000\u0000\u0436\u0439\u0001\u0000\u0000\u0000\u0437\u0435" + + "\u0001\u0000\u0000\u0000\u0437\u0438\u0001\u0000\u0000\u0000\u0438\u043b" + + "\u0001\u0000\u0000\u0000\u0439\u0437\u0001\u0000\u0000\u0000\u043a\u043c" + + "\u0005\u0094\u0000\u0000\u043b\u043a\u0001\u0000\u0000\u0000\u043b\u043c" + + "\u0001\u0000\u0000\u0000\u043c\u043e\u0001\u0000\u0000\u0000\u043d\u043f" + + "\u0003r9\u0000\u043e\u043d\u0001\u0000\u0000\u0000\u043e\u043f\u0001\u0000" + + "\u0000\u0000\u043f\u0441\u0001\u0000\u0000\u0000\u0440\u0442\u0003\u01b2" + + "\u00d9\u0000\u0441\u0440\u0001\u0000\u0000\u0000\u0441\u0442\u0001\u0000" + + "\u0000\u0000\u0442q\u0001\u0000\u0000\u0000\u0443\u0444\u0005}\u0000\u0000" + + "\u0444\u0449\u0003t:\u0000\u0445\u0446\u0005\u0084\u0000\u0000\u0446\u0448" + + "\u0003t:\u0000\u0447\u0445\u0001\u0000\u0000\u0000\u0448\u044b\u0001\u0000" + + "\u0000\u0000\u0449\u0447\u0001\u0000\u0000\u0000\u0449\u044a\u0001\u0000" + + "\u0000\u0000\u044a\u044c\u0001\u0000\u0000\u0000\u044b\u0449\u0001\u0000" + + "\u0000\u0000\u044c\u044d\u0005~\u0000\u0000\u044ds\u0001\u0000\u0000\u0000" + + "\u044e\u044f\u0003\u01b2\u00d9\u0000\u044f\u0450\u0005\u0085\u0000\u0000" + + "\u0450\u0451\u0003\u001c\u000e\u0000\u0451u\u0001\u0000\u0000\u0000\u0452" + + "\u0454\u0005\u000f\u0000\u0000\u0453\u0452\u0001\u0000\u0000\u0000\u0453" + + "\u0454\u0001\u0000\u0000\u0000\u0454\u0455\u0001\u0000\u0000\u0000\u0455" + + "\u0456\u0003x<\u0000\u0456\u0457\u0003\u0176\u00bb\u0000\u0457\u0458\u0003" + + "\u0080@\u0000\u0458w\u0001\u0000\u0000\u0000\u0459\u045a\u0005\u0081\u0000" + + "\u0000\u045a\u0465\u0005\u0082\u0000\u0000\u045b\u045c\u0005\u0081\u0000" + + "\u0000\u045c\u045d\u0003z=\u0000\u045d\u045e\u0005\u0082\u0000\u0000\u045e" + + "\u0465\u0001\u0000\u0000\u0000\u045f\u0460\u0005\u0081\u0000\u0000\u0460" + + "\u0461\u0003~?\u0000\u0461\u0462\u0005\u0082\u0000\u0000\u0462\u0465\u0001" + + "\u0000\u0000\u0000\u0463\u0465\u0003\u01b2\u00d9\u0000\u0464\u0459\u0001" + + "\u0000\u0000\u0000\u0464\u045b\u0001\u0000\u0000\u0000\u0464\u045f\u0001" + + "\u0000\u0000\u0000\u0464\u0463\u0001\u0000\u0000\u0000\u0465y\u0001\u0000" + + "\u0000\u0000\u0466\u046b\u0003|>\u0000\u0467\u0468\u0005\u0084\u0000\u0000" + + "\u0468\u046a\u0003|>\u0000\u0469\u0467\u0001\u0000\u0000\u0000\u046a\u046d" + + "\u0001\u0000\u0000\u0000\u046b\u0469\u0001\u0000\u0000\u0000\u046b\u046c" + + "\u0001\u0000\u0000\u0000\u046c{\u0001\u0000\u0000\u0000\u046d\u046b\u0001" + + "\u0000\u0000\u0000\u046e\u0470\u0007\u0002\u0000\u0000\u046f\u046e\u0001" + + "\u0000\u0000\u0000\u046f\u0470\u0001\u0000\u0000\u0000\u0470\u0471\u0001" + + "\u0000\u0000\u0000\u0471\u0472\u0003\u0004\u0002\u0000\u0472\u0473\u0003" + + "\u01b2\u00d9\u0000\u0473}\u0001\u0000\u0000\u0000\u0474\u0479\u0003\u01b2" + + "\u00d9\u0000\u0475\u0476\u0005\u0084\u0000\u0000\u0476\u0478\u0003\u01b2" + + "\u00d9\u0000\u0477\u0475\u0001\u0000\u0000\u0000\u0478\u047b\u0001\u0000" + + "\u0000\u0000\u0479\u0477\u0001\u0000\u0000\u0000\u0479\u047a\u0001\u0000" + + "\u0000\u0000\u047a\u007f\u0001\u0000\u0000\u0000\u047b\u0479\u0001\u0000" + + "\u0000\u0000\u047c\u047f\u0003J%\u0000\u047d\u047f\u0003\u00aaU\u0000" + + "\u047e\u047c\u0001\u0000\u0000\u0000\u047e\u047d\u0001\u0000\u0000\u0000" + + "\u047f\u0081\u0001\u0000\u0000\u0000\u0480\u0481\u0003\u0084B\u0000\u0481" + + "\u0482\u0003\u0086C\u0000\u0482\u0083\u0001\u0000\u0000\u0000\u0483\u0485" + + "\u00050\u0000\u0000\u0484\u0486\u0003\u0004\u0002\u0000\u0485\u0484\u0001" + + "\u0000\u0000\u0000\u0485\u0486\u0001\u0000\u0000\u0000\u0486\u0487\u0001" + + "\u0000\u0000\u0000\u0487\u0488\u0003\u01b2\u00d9\u0000\u0488\u0489\u0005" + + "6\u0000\u0000\u0489\u048a\u0003\u001c\u000e\u0000\u048a\u0085\u0001\u0000" + + "\u0000\u0000\u048b\u048d\u0003\u0088D\u0000\u048c\u048b\u0001\u0000\u0000" + + "\u0000\u048d\u0490\u0001\u0000\u0000\u0000\u048e\u048c\u0001\u0000\u0000" + + "\u0000\u048e\u048f\u0001\u0000\u0000\u0000\u048f\u0491\u0001\u0000\u0000" + + "\u0000\u0490\u048e\u0001\u0000\u0000\u0000\u0491\u0493\u0003\u0094J\u0000" + + "\u0492\u0494\u0003\u0096K\u0000\u0493\u0492\u0001\u0000\u0000\u0000\u0493" + + "\u0494\u0001\u0000\u0000\u0000\u0494\u0087\u0001\u0000\u0000\u0000\u0495" + + "\u049b\u0003\u0084B\u0000\u0496\u049b\u0003\u008aE\u0000\u0497\u049b\u0003" + + "\u008cF\u0000\u0498\u049b\u0003\u008eG\u0000\u0499\u049b\u0003\u0090H" + + "\u0000\u049a\u0495\u0001\u0000\u0000\u0000\u049a\u0496\u0001\u0000\u0000" + + "\u0000\u049a\u0497\u0001\u0000\u0000\u0000\u049a\u0498\u0001\u0000\u0000" + + "\u0000\u049a\u0499\u0001\u0000\u0000\u0000\u049b\u0089\u0001\u0000\u0000" + + "\u0000\u049c\u049d\u0005=\u0000\u0000\u049d\u049e\u0003\u01b2\u00d9\u0000" + + "\u049e\u049f\u0005\u0091\u0000\u0000\u049f\u04a0\u0003\u001c\u000e\u0000" + + "\u04a0\u008b\u0001\u0000\u0000\u0000\u04a1\u04a2\u0005o\u0000\u0000\u04a2" + + "\u04a3\u0003\u001c\u000e\u0000\u04a3\u008d\u0001\u0000\u0000\u0000\u04a4" + + "\u04a6\u0005<\u0000\u0000\u04a5\u04a7\u0003\u0004\u0002\u0000\u04a6\u04a5" + + "\u0001\u0000\u0000\u0000\u04a6\u04a7\u0001\u0000\u0000\u0000\u04a7\u04a8" + + "\u0001\u0000\u0000\u0000\u04a8\u04a9\u0003\u01b2\u00d9\u0000\u04a9\u04aa" + + "\u00056\u0000\u0000\u04aa\u04ab\u0003\u001c\u000e\u0000\u04ab\u04ac\u0005" + + "E\u0000\u0000\u04ac\u04ad\u0003\u001c\u000e\u0000\u04ad\u04ae\u0005&\u0000" + + "\u0000\u04ae\u04b1\u0003\u001c\u000e\u0000\u04af\u04b0\u0005:\u0000\u0000" + + "\u04b0\u04b2\u0003\u01b2\u00d9\u0000\u04b1\u04af\u0001\u0000\u0000\u0000" + + "\u04b1\u04b2\u0001\u0000\u0000\u0000\u04b2\u008f\u0001\u0000\u0000\u0000" + + "\u04b3\u04b4\u0005G\u0000\u0000\u04b4\u04b9\u0003\u0092I\u0000\u04b5\u04b6" + + "\u0005\u0084\u0000\u0000\u04b6\u04b8\u0003\u0092I\u0000\u04b7\u04b5\u0001" + + "\u0000\u0000\u0000\u04b8\u04bb\u0001\u0000\u0000\u0000\u04b9\u04b7\u0001" + + "\u0000\u0000\u0000\u04b9\u04ba\u0001\u0000\u0000\u0000\u04ba\u0091\u0001" + + "\u0000\u0000\u0000\u04bb\u04b9\u0001\u0000\u0000\u0000\u04bc\u04be\u0003" + + "\u001c\u000e\u0000\u04bd\u04bf\u0007\b\u0000\u0000\u04be\u04bd\u0001\u0000" + + "\u0000\u0000\u04be\u04bf\u0001\u0000\u0000\u0000\u04bf\u0093\u0001\u0000" + + "\u0000\u0000\u04c0\u04c1\u0005U\u0000\u0000\u04c1\u04c8\u0003\u001c\u000e" + + "\u0000\u04c2\u04c3\u00053\u0000\u0000\u04c3\u04c4\u0003\u001c\u000e\u0000" + + "\u04c4\u04c5\u0005\u0014\u0000\u0000\u04c5\u04c6\u0003\u001c\u000e\u0000" + + "\u04c6\u04c8\u0001\u0000\u0000\u0000\u04c7\u04c0\u0001\u0000\u0000\u0000" + + "\u04c7\u04c2\u0001\u0000\u0000\u0000\u04c8\u0095\u0001\u0000\u0000\u0000" + + "\u04c9\u04ca\u0005:\u0000\u0000\u04ca\u04cb\u0003\u01b2\u00d9\u0000\u04cb" + + "\u04cc\u0003\u0086C\u0000\u04cc\u0097\u0001\u0000\u0000\u0000\u04cd\u04d1" + + "\u0003\u00a4R\u0000\u04ce\u04d1\u0003\u009aM\u0000\u04cf\u04d1\u0003\u00a6" + + "S\u0000\u04d0\u04cd\u0001\u0000\u0000\u0000\u04d0\u04ce\u0001\u0000\u0000" + + "\u0000\u04d0\u04cf\u0001\u0000\u0000\u0000\u04d1\u0099\u0001\u0000\u0000" + + "\u0000\u04d2\u04d3\u0003\u00acV\u0000\u04d3\u04d4\u0005\u0086\u0000\u0000" + + "\u04d4\u04da\u0001\u0000\u0000\u0000\u04d5\u04d6\u0003\u00b4Z\u0000\u04d6" + + "\u04d7\u0005\u0086\u0000\u0000\u04d7\u04da\u0001\u0000\u0000\u0000\u04d8" + + "\u04da\u0003\u009cN\u0000\u04d9\u04d2\u0001\u0000\u0000\u0000\u04d9\u04d5" + + "\u0001\u0000\u0000\u0000\u04d9\u04d8\u0001\u0000\u0000\u0000\u04da\u009b" + + "\u0001\u0000\u0000\u0000\u04db\u04dc\u0003\u009eO\u0000\u04dc\u04dd\u0003" + + "\u00a2Q\u0000\u04dd\u009d\u0001\u0000\u0000\u0000\u04de\u04e0\u0003\u00a0" + + "P\u0000\u04df\u04de\u0001\u0000\u0000\u0000\u04df\u04e0\u0001\u0000\u0000" + + "\u0000\u04e0\u04e1\u0001\u0000\u0000\u0000\u04e1\u04e2\u0003\u0112\u0089" + + "\u0000\u04e2\u04e4\u0003\u01b2\u00d9\u0000\u04e3\u04e5\u0003\u00e6s\u0000" + + "\u04e4\u04e3\u0001\u0000\u0000\u0000\u04e4\u04e5\u0001\u0000\u0000\u0000" + + "\u04e5\u04e6\u0001\u0000\u0000\u0000\u04e6\u04e8\u0005\u0081\u0000\u0000" + + "\u04e7\u04e9\u0003\u0118\u008c\u0000\u04e8\u04e7\u0001\u0000\u0000\u0000" + + "\u04e8\u04e9\u0001\u0000\u0000\u0000\u04e9\u04ea\u0001\u0000\u0000\u0000" + + "\u04ea\u04ec\u0005\u0082\u0000\u0000\u04eb\u04ed\u0003\u00eew\u0000\u04ec" + + "\u04eb\u0001\u0000\u0000\u0000\u04ec\u04ed\u0001\u0000\u0000\u0000\u04ed" + + "\u009f\u0001\u0000\u0000\u0000\u04ee\u04f0\u0007\t\u0000\u0000\u04ef\u04f1" + + "\u0005Z\u0000\u0000\u04f0\u04ef\u0001\u0000\u0000\u0000\u04f0\u04f1\u0001" + + "\u0000\u0000\u0000\u04f1\u04f5\u0001\u0000\u0000\u0000\u04f2\u04f3\u0005" + + "Z\u0000\u0000\u04f3\u04f5\u0007\t\u0000\u0000\u04f4\u04ee\u0001\u0000" + + "\u0000\u0000\u04f4\u04f2\u0001\u0000\u0000\u0000\u04f5\u00a1\u0001\u0000" + + "\u0000\u0000\u04f6\u04fc\u0003\u00aaU\u0000\u04f7\u04f8\u0003\u0176\u00bb" + + "\u0000\u04f8\u04f9\u0003J%\u0000\u04f9\u04fa\u0005\u0086\u0000\u0000\u04fa" + + "\u04fc\u0001\u0000\u0000\u0000\u04fb\u04f6\u0001\u0000\u0000\u0000\u04fb" + + "\u04f7\u0001\u0000\u0000\u0000\u04fc\u00a3\u0001\u0000\u0000\u0000\u04fd" + + "\u04fe\u0003\u01b2\u00d9\u0000\u04fe\u04ff\u0005\u0085\u0000\u0000\u04ff" + + "\u0500\u0003\u0098L\u0000\u0500\u00a5\u0001\u0000\u0000\u0000\u0501\u0504" + + "\u0003\u00aaU\u0000\u0502\u0504\u0003\u00a8T\u0000\u0503\u0501\u0001\u0000" + + "\u0000\u0000\u0503\u0502\u0001\u0000\u0000\u0000\u0504\u00a7\u0001\u0000" + + "\u0000\u0000\u0505\u0588\u0005\u0086\u0000\u0000\u0506\u0507\u0003\u001c" + + "\u000e\u0000\u0507\u0508\u0005\u0086\u0000\u0000\u0508\u0588\u0001\u0000" + + "\u0000\u0000\u0509\u050a\u00054\u0000\u0000\u050a\u050b\u0005\u0081\u0000" + + "\u0000\u050b\u050c\u0003\u001c\u000e\u0000\u050c\u050d\u0005\u0082\u0000" + + "\u0000\u050d\u0510\u0003\u00b6[\u0000\u050e\u050f\u0005$\u0000\u0000\u050f" + + "\u0511\u0003\u00b6[\u0000\u0510\u050e\u0001\u0000\u0000\u0000\u0510\u0511" + + "\u0001\u0000\u0000\u0000\u0511\u0588\u0001\u0000\u0000\u0000\u0512\u0513" + + "\u0005]\u0000\u0000\u0513\u0514\u0005\u0081\u0000\u0000\u0514\u0515\u0003" + + "\u001c\u000e\u0000\u0515\u0516\u0005\u0082\u0000\u0000\u0516\u051a\u0005" + + "}\u0000\u0000\u0517\u0519\u0003\u00b8\\\u0000\u0518\u0517\u0001\u0000" + + "\u0000\u0000\u0519\u051c\u0001\u0000\u0000\u0000\u051a\u0518\u0001\u0000" + + "\u0000\u0000\u051a\u051b\u0001\u0000\u0000\u0000\u051b\u051d\u0001\u0000" + + "\u0000\u0000\u051c\u051a\u0001\u0000\u0000\u0000\u051d\u051e\u0005~\u0000" + + "\u0000\u051e\u0588\u0001\u0000\u0000\u0000\u051f\u0520\u0005p\u0000\u0000" + + "\u0520\u0521\u0005\u0081\u0000\u0000\u0521\u0522\u0003\u001c\u000e\u0000" + + "\u0522\u0523\u0005\u0082\u0000\u0000\u0523\u0524\u0003\u00a6S\u0000\u0524" + + "\u0588\u0001\u0000\u0000\u0000\u0525\u0526\u0005!\u0000\u0000\u0526\u0527" + + "\u0003\u00a6S\u0000\u0527\u0528\u0005p\u0000\u0000\u0528\u0529\u0005\u0081" + + "\u0000\u0000\u0529\u052a\u0003\u001c\u000e\u0000\u052a\u052b\u0005\u0082" + + "\u0000\u0000\u052b\u052c\u0005\u0086\u0000\u0000\u052c\u0588\u0001\u0000" + + "\u0000\u0000\u052d\u052e\u0005.\u0000\u0000\u052e\u0530\u0005\u0081\u0000" + + "\u0000\u052f\u0531\u0003\u00c0`\u0000\u0530\u052f\u0001\u0000\u0000\u0000" + + "\u0530\u0531\u0001\u0000\u0000\u0000\u0531\u0532\u0001\u0000\u0000\u0000" + + "\u0532\u0534\u0005\u0086\u0000\u0000\u0533\u0535\u0003\u001c\u000e\u0000" + + "\u0534\u0533\u0001\u0000\u0000\u0000\u0534\u0535\u0001\u0000\u0000\u0000" + + "\u0535\u0536\u0001\u0000\u0000\u0000\u0536\u0538\u0005\u0086\u0000\u0000" + + "\u0537\u0539\u0003\u00c2a\u0000\u0538\u0537\u0001\u0000\u0000\u0000\u0538" + + "\u0539\u0001\u0000\u0000\u0000\u0539\u053a\u0001\u0000\u0000\u0000\u053a" + + "\u053b\u0005\u0082\u0000\u0000\u053b\u0588\u0003\u00a6S\u0000\u053c\u053e" + + "\u0005\u0010\u0000\u0000\u053d\u053c\u0001\u0000\u0000\u0000\u053d\u053e" + + "\u0001\u0000\u0000\u0000\u053e\u053f\u0001\u0000\u0000\u0000\u053f\u0540" + + "\u0005/\u0000\u0000\u0540\u0541\u0005\u0081\u0000\u0000\u0541\u0542\u0003" + + "\u00aeW\u0000\u0542\u0543\u0003\u01b2\u00d9\u0000\u0543\u0544\u00056\u0000" + + "\u0000\u0544\u0545\u0003\u001c\u000e\u0000\u0545\u0546\u0005\u0082\u0000" + + "\u0000\u0546\u0547\u0003\u00a6S\u0000\u0547\u0588\u0001\u0000\u0000\u0000" + + "\u0548\u0549\u0005\u0013\u0000\u0000\u0549\u0588\u0005\u0086\u0000\u0000" + + "\u054a\u054b\u0005\u001c\u0000\u0000\u054b\u0588\u0005\u0086\u0000\u0000" + + "\u054c\u0551\u00052\u0000\u0000\u054d\u0552\u0003\u01b2\u00d9\u0000\u054e" + + "\u054f\u0005\u0016\u0000\u0000\u054f\u0552\u0003\u001c\u000e\u0000\u0550" + + "\u0552\u0005\u001e\u0000\u0000\u0551\u054d\u0001\u0000\u0000\u0000\u0551" + + "\u054e\u0001\u0000\u0000\u0000\u0551\u0550\u0001\u0000\u0000\u0000\u0552" + + "\u0553\u0001\u0000\u0000\u0000\u0553\u0588\u0005\u0086\u0000\u0000\u0554" + + "\u0556\u0005R\u0000\u0000\u0555\u0557\u0003\u001c\u000e\u0000\u0556\u0555" + + "\u0001\u0000\u0000\u0000\u0556\u0557\u0001\u0000\u0000\u0000\u0557\u0558" + + "\u0001\u0000\u0000\u0000\u0558\u0588\u0005\u0086\u0000\u0000\u0559\u055b" + + "\u0005_\u0000\u0000\u055a\u055c\u0003\u001c\u000e\u0000\u055b\u055a\u0001" + + "\u0000\u0000\u0000\u055b\u055c\u0001\u0000\u0000\u0000\u055c\u055d\u0001" + + "\u0000\u0000\u0000\u055d\u0588\u0005\u0086\u0000\u0000\u055e\u055f\u0005" + + "a\u0000\u0000\u055f\u0565\u0003\u00aaU\u0000\u0560\u0562\u0003\u00c4b" + + "\u0000\u0561\u0563\u0003\u00ccf\u0000\u0562\u0561\u0001\u0000\u0000\u0000" + + "\u0562\u0563\u0001\u0000\u0000\u0000\u0563\u0566\u0001\u0000\u0000\u0000" + + "\u0564\u0566\u0003\u00ccf\u0000\u0565\u0560\u0001\u0000\u0000\u0000\u0565" + + "\u0564\u0001\u0000\u0000\u0000\u0566\u0588\u0001\u0000\u0000\u0000\u0567" + + "\u0568\u0005\u0019\u0000\u0000\u0568\u0588\u0003\u00aaU\u0000\u0569\u056a" + + "\u0005e\u0000\u0000\u056a\u0588\u0003\u00aaU\u0000\u056b\u056c\u0005>" + + "\u0000\u0000\u056c\u056d\u0005\u0081\u0000\u0000\u056d\u056e\u0003\u001c" + + "\u000e\u0000\u056e\u056f\u0005\u0082\u0000\u0000\u056f\u0570\u0003\u00a6" + + "S\u0000\u0570\u0588\u0001\u0000\u0000\u0000\u0571\u0572\u0005i\u0000\u0000" + + "\u0572\u0573\u0005\u0081\u0000\u0000\u0573\u0574\u0003\u00ceg\u0000\u0574" + + "\u0575\u0005\u0082\u0000\u0000\u0575\u0576\u0003\u00a6S\u0000\u0576\u0588" + + "\u0001\u0000\u0000\u0000\u0577\u057b\u0005q\u0000\u0000\u0578\u0579\u0005" + + "R\u0000\u0000\u0579\u057c\u0003\u001c\u000e\u0000\u057a\u057c\u0005\u0013" + + "\u0000\u0000\u057b\u0578\u0001\u0000\u0000\u0000\u057b\u057a\u0001\u0000" + + "\u0000\u0000\u057c\u057d\u0001\u0000\u0000\u0000\u057d\u0588\u0005\u0086" + + "\u0000\u0000\u057e\u057f\u0005g\u0000\u0000\u057f\u0588\u0003\u00aaU\u0000" + + "\u0580\u0581\u0005,\u0000\u0000\u0581\u0582\u0005\u0081\u0000\u0000\u0582" + + "\u0583\u0003\u016a\u00b5\u0000\u0583\u0584\u0003\u016c\u00b6\u0000\u0584" + + "\u0585\u0005\u0082\u0000\u0000\u0585\u0586\u0003\u00a6S\u0000\u0586\u0588" + + "\u0001\u0000\u0000\u0000\u0587\u0505\u0001\u0000\u0000\u0000\u0587\u0506" + + "\u0001\u0000\u0000\u0000\u0587\u0509\u0001\u0000\u0000\u0000\u0587\u0512" + + "\u0001\u0000\u0000\u0000\u0587\u051f\u0001\u0000\u0000\u0000\u0587\u0525" + + "\u0001\u0000\u0000\u0000\u0587\u052d\u0001\u0000\u0000\u0000\u0587\u053d" + + "\u0001\u0000\u0000\u0000\u0587\u0548\u0001\u0000\u0000\u0000\u0587\u054a" + + "\u0001\u0000\u0000\u0000\u0587\u054c\u0001\u0000\u0000\u0000\u0587\u0554" + + "\u0001\u0000\u0000\u0000\u0587\u0559\u0001\u0000\u0000\u0000\u0587\u055e" + + "\u0001\u0000\u0000\u0000\u0587\u0567\u0001\u0000\u0000\u0000\u0587\u0569" + + "\u0001\u0000\u0000\u0000\u0587\u056b\u0001\u0000\u0000\u0000\u0587\u0571" + + "\u0001\u0000\u0000\u0000\u0587\u0577\u0001\u0000\u0000\u0000\u0587\u057e" + + "\u0001\u0000\u0000\u0000\u0587\u0580\u0001\u0000\u0000\u0000\u0588\u00a9" + + "\u0001\u0000\u0000\u0000\u0589\u058b\u0005}\u0000\u0000\u058a\u058c\u0003" + + "\u00be_\u0000\u058b\u058a\u0001\u0000\u0000\u0000\u058b\u058c\u0001\u0000" + + "\u0000\u0000\u058c\u058d\u0001\u0000\u0000\u0000\u058d\u058e\u0005~\u0000" + + "\u0000\u058e\u00ab\u0001\u0000\u0000\u0000\u058f\u0594\u0005i\u0000\u0000" + + "\u0590\u0594\u0005P\u0000\u0000\u0591\u0592\u0005P\u0000\u0000\u0592\u0594" + + "\u0005O\u0000\u0000\u0593\u058f\u0001\u0000\u0000\u0000\u0593\u0590\u0001" + + "\u0000\u0000\u0000\u0593\u0591\u0001\u0000\u0000\u0000\u0593\u0594\u0001" + + "\u0000\u0000\u0000\u0594\u0595\u0001\u0000\u0000\u0000\u0595\u0596\u0003" + + "\u00aeW\u0000\u0596\u059b\u0003\u00b0X\u0000\u0597\u0598\u0005\u0084\u0000" + + "\u0000\u0598\u059a\u0003\u00b0X\u0000\u0599\u0597\u0001\u0000\u0000\u0000" + + "\u059a\u059d\u0001\u0000\u0000\u0000\u059b\u0599\u0001\u0000\u0000\u0000" + + "\u059b\u059c\u0001\u0000\u0000\u0000\u059c\u05a3\u0001\u0000\u0000\u0000" + + "\u059d\u059b\u0001\u0000\u0000\u0000\u059e\u059f\u0005,\u0000\u0000\u059f" + + "\u05a0\u0003\u016a\u00b5\u0000\u05a0\u05a1\u0003\u016c\u00b6\u0000\u05a1" + + "\u05a3\u0001\u0000\u0000\u0000\u05a2\u0593\u0001\u0000\u0000\u0000\u05a2" + + "\u059e\u0001\u0000\u0000\u0000\u05a3\u00ad\u0001\u0000\u0000\u0000\u05a4" + + "\u05a7\u0005j\u0000\u0000\u05a5\u05a7\u0003\u0004\u0002\u0000\u05a6\u05a4" + + "\u0001\u0000\u0000\u0000\u05a6\u05a5\u0001\u0000\u0000\u0000\u05a7\u00af" + + "\u0001\u0000\u0000\u0000\u05a8\u05ae\u0003\u01b2\u00d9\u0000\u05a9\u05ab" + + "\u0005\u0091\u0000\u0000\u05aa\u05ac\u0005P\u0000\u0000\u05ab\u05aa\u0001" + + "\u0000\u0000\u0000\u05ab\u05ac\u0001\u0000\u0000\u0000\u05ac\u05ad\u0001" + + "\u0000\u0000\u0000\u05ad\u05af\u0003\u00b2Y\u0000\u05ae\u05a9\u0001\u0000" + + "\u0000\u0000\u05ae\u05af\u0001\u0000\u0000\u0000\u05af\u00b1\u0001\u0000" + + "\u0000\u0000\u05b0\u05b4\u0003\u001c\u000e\u0000\u05b1\u05b4\u0003\u0144" + + "\u00a2\u0000\u05b2\u05b4\u0003\u0174\u00ba\u0000\u05b3\u05b0\u0001\u0000" + + "\u0000\u0000\u05b3\u05b1\u0001\u0000\u0000\u0000\u05b3\u05b2\u0001\u0000" + + "\u0000\u0000\u05b4\u00b3\u0001\u0000\u0000\u0000\u05b5\u05b6\u0005\u001b" + + "\u0000\u0000\u05b6\u05b7\u0003\u0004\u0002\u0000\u05b7\u05b8\u0003\u0108" + + "\u0084\u0000\u05b8\u00b5\u0001\u0000\u0000\u0000\u05b9\u05bc\u0003\u00aa" + + "U\u0000\u05ba\u05bc\u0003\u00a8T\u0000\u05bb\u05b9\u0001\u0000\u0000\u0000" + + "\u05bb\u05ba\u0001\u0000\u0000\u0000\u05bc\u00b7\u0001\u0000\u0000\u0000" + + "\u05bd\u05bf\u0003\u00ba]\u0000\u05be\u05bd\u0001\u0000\u0000\u0000\u05bf" + + "\u05c0\u0001\u0000\u0000\u0000\u05c0\u05be\u0001\u0000\u0000\u0000\u05c0" + + "\u05c1\u0001\u0000\u0000\u0000\u05c1\u05c2\u0001\u0000\u0000\u0000\u05c2" + + "\u05c3\u0003\u00be_\u0000\u05c3\u00b9\u0001\u0000\u0000\u0000\u05c4\u05c5" + + "\u0005\u0016\u0000\u0000\u05c5\u05c7\u0003\u001c\u000e\u0000\u05c6\u05c8" + + "\u0003\u00bc^\u0000\u05c7\u05c6\u0001\u0000\u0000\u0000\u05c7\u05c8\u0001" + + "\u0000\u0000\u0000\u05c8\u05c9\u0001\u0000\u0000\u0000\u05c9\u05ca\u0005" + + "\u0085\u0000\u0000\u05ca\u05ce\u0001\u0000\u0000\u0000\u05cb\u05cc\u0005" + + "\u001e\u0000\u0000\u05cc\u05ce\u0005\u0085\u0000\u0000\u05cd\u05c4\u0001" + + "\u0000\u0000\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000\u05ce\u00bb\u0001" + + "\u0000\u0000\u0000\u05cf\u05d0\u0005n\u0000\u0000\u05d0\u05d1\u0003\u001c" + + "\u000e\u0000\u05d1\u00bd\u0001\u0000\u0000\u0000\u05d2\u05d4\u0003\u0098" + + "L\u0000\u05d3\u05d2\u0001\u0000\u0000\u0000\u05d4\u05d5\u0001\u0000\u0000" + + "\u0000\u05d5\u05d3\u0001\u0000\u0000\u0000\u05d5\u05d6\u0001\u0000\u0000" + + "\u0000\u05d6\u00bf\u0001\u0000\u0000\u0000\u05d7\u05e1\u0003\u00acV\u0000" + + "\u05d8\u05dd\u0003\u001c\u000e\u0000\u05d9\u05da\u0005\u0084\u0000\u0000" + + "\u05da\u05dc\u0003\u001c\u000e\u0000\u05db\u05d9\u0001\u0000\u0000\u0000" + + "\u05dc\u05df\u0001\u0000\u0000\u0000\u05dd\u05db\u0001\u0000\u0000\u0000" + + "\u05dd\u05de\u0001\u0000\u0000\u0000\u05de\u05e1\u0001\u0000\u0000\u0000" + + "\u05df\u05dd\u0001\u0000\u0000\u0000\u05e0\u05d7\u0001\u0000\u0000\u0000" + + "\u05e0\u05d8\u0001\u0000\u0000\u0000\u05e1\u00c1\u0001\u0000\u0000\u0000" + + "\u05e2\u05e7\u0003\u001c\u000e\u0000\u05e3\u05e4\u0005\u0084\u0000\u0000" + + "\u05e4\u05e6\u0003\u001c\u000e\u0000\u05e5\u05e3\u0001\u0000\u0000\u0000" + + "\u05e6\u05e9\u0001\u0000\u0000\u0000\u05e7\u05e5\u0001\u0000\u0000\u0000" + + "\u05e7\u05e8\u0001\u0000\u0000\u0000\u05e8\u00c3\u0001\u0000\u0000\u0000" + + "\u05e9\u05e7\u0001\u0000\u0000\u0000\u05ea\u05ee\u0003\u00c6c\u0000\u05eb" + + "\u05ed\u0003\u00c6c\u0000\u05ec\u05eb\u0001\u0000\u0000\u0000\u05ed\u05f0" + + "\u0001\u0000\u0000\u0000\u05ee\u05ec\u0001\u0000\u0000\u0000\u05ee\u05ef" + + "\u0001\u0000\u0000\u0000\u05ef\u05f2\u0001\u0000\u0000\u0000\u05f0\u05ee" + + "\u0001\u0000\u0000\u0000\u05f1\u05f3\u0003\u00c8d\u0000\u05f2\u05f1\u0001" + + "\u0000\u0000\u0000\u05f2\u05f3\u0001\u0000\u0000\u0000\u05f3\u05f6\u0001" + + "\u0000\u0000\u0000\u05f4\u05f6\u0003\u00c8d\u0000\u05f5\u05ea\u0001\u0000" + + "\u0000\u0000\u05f5\u05f4\u0001\u0000\u0000\u0000\u05f6\u00c5\u0001\u0000" + + "\u0000\u0000\u05f7\u05f8\u0005\u0017\u0000\u0000\u05f8\u05f9\u0005\u0081" + + "\u0000\u0000\u05f9\u05fb\u0003\u0014\n\u0000\u05fa\u05fc\u0003\u01b2\u00d9" + + "\u0000\u05fb\u05fa\u0001\u0000\u0000\u0000\u05fb\u05fc\u0001\u0000\u0000" + + "\u0000\u05fc\u05fd\u0001\u0000\u0000\u0000\u05fd\u05ff\u0005\u0082\u0000" + + "\u0000\u05fe\u0600\u0003\u00cae\u0000\u05ff\u05fe\u0001\u0000\u0000\u0000" + + "\u05ff\u0600\u0001\u0000\u0000\u0000\u0600\u0601\u0001\u0000\u0000\u0000" + + "\u0601\u0602\u0003\u00aaU\u0000\u0602\u00c7\u0001\u0000\u0000\u0000\u0603" + + "\u0605\u0005\u0017\u0000\u0000\u0604\u0606\u0003\u00cae\u0000\u0605\u0604" + + "\u0001\u0000\u0000\u0000\u0605\u0606\u0001\u0000\u0000\u0000\u0606\u0607" + + "\u0001\u0000\u0000\u0000\u0607\u0608\u0003\u00aaU\u0000\u0608\u00c9\u0001" + + "\u0000\u0000\u0000\u0609\u060a\u0005n\u0000\u0000\u060a\u060b\u0005\u0081" + + "\u0000\u0000\u060b\u060c\u0003\u001c\u000e\u0000\u060c\u060d\u0005\u0082" + + "\u0000\u0000\u060d\u00cb\u0001\u0000\u0000\u0000\u060e\u060f\u0005+\u0000" + + "\u0000\u060f\u0610\u0003\u00aaU\u0000\u0610\u00cd\u0001\u0000\u0000\u0000" + + "\u0611\u0614\u0003\u00acV\u0000\u0612\u0614\u0003\u001c\u000e\u0000\u0613" + + "\u0611\u0001\u0000\u0000\u0000\u0613\u0612\u0001\u0000\u0000\u0000\u0614" + + "\u00cf\u0001\u0000\u0000\u0000\u0615\u0616\u0005A\u0000\u0000\u0616\u0617" + + "\u0003\u00d2i\u0000\u0617\u0619\u0003\u00d4j\u0000\u0618\u061a\u0005\u0086" + + "\u0000\u0000\u0619\u0618\u0001\u0000\u0000\u0000\u0619\u061a\u0001\u0000" + + "\u0000\u0000\u061a\u00d1\u0001\u0000\u0000\u0000\u061b\u0620\u0003\u01b2" + + "\u00d9\u0000\u061c\u061d\u0005\u0083\u0000\u0000\u061d\u061f\u0003\u01b2" + + "\u00d9\u0000\u061e\u061c\u0001\u0000\u0000\u0000\u061f\u0622\u0001\u0000" + + "\u0000\u0000\u0620\u061e\u0001\u0000\u0000\u0000\u0620\u0621\u0001\u0000" + + "\u0000\u0000\u0621\u00d3\u0001\u0000\u0000\u0000\u0622\u0620\u0001\u0000" + + "\u0000\u0000\u0623\u0625\u0005}\u0000\u0000\u0624\u0626\u0003\u00d6k\u0000" + + "\u0625\u0624\u0001\u0000\u0000\u0000\u0625\u0626\u0001\u0000\u0000\u0000" + + "\u0626\u0628\u0001\u0000\u0000\u0000\u0627\u0629\u0003\u00dam\u0000\u0628" + + "\u0627\u0001\u0000\u0000\u0000\u0628\u0629\u0001\u0000\u0000\u0000\u0629" + + "\u062b\u0001\u0000\u0000\u0000\u062a\u062c\u0003\u00deo\u0000\u062b\u062a" + + "\u0001\u0000\u0000\u0000\u062b\u062c\u0001\u0000\u0000\u0000\u062c\u062d" + + "\u0001\u0000\u0000\u0000\u062d\u062e\u0005~\u0000\u0000\u062e\u00d5\u0001" + + "\u0000\u0000\u0000\u062f\u0631\u0003\u00d8l\u0000\u0630\u062f\u0001\u0000" + + "\u0000\u0000\u0631\u0632\u0001\u0000\u0000\u0000\u0632\u0630\u0001\u0000" + + "\u0000\u0000\u0632\u0633\u0001\u0000\u0000\u0000\u0633\u00d7\u0001\u0000" + + "\u0000\u0000\u0634\u0635\u0005)\u0000\u0000\u0635\u0636\u0005\u000b\u0000" + + "\u0000\u0636\u0637\u0003\u01b2\u00d9\u0000\u0637\u0638\u0005\u0086\u0000" + + "\u0000\u0638\u00d9\u0001\u0000\u0000\u0000\u0639\u063b\u0003\u00dcn\u0000" + + "\u063a\u0639\u0001\u0000\u0000\u0000\u063b\u063c\u0001\u0000\u0000\u0000" + + "\u063c\u063a\u0001\u0000\u0000\u0000\u063c\u063d\u0001\u0000\u0000\u0000" + + "\u063d\u00db\u0001\u0000\u0000\u0000\u063e\u063f\u0005i\u0000\u0000\u063f" + + "\u0640\u0003\u01b2\u00d9\u0000\u0640\u0641\u0005\u0091\u0000\u0000\u0641" + + "\u0642\u0003\u0002\u0001\u0000\u0642\u0643\u0005\u0086\u0000\u0000\u0643" + + "\u064e\u0001\u0000\u0000\u0000\u0644\u0645\u0005i\u0000\u0000\u0645\u0646" + + "\u0003\u0002\u0001\u0000\u0646\u0647\u0005\u0086\u0000\u0000\u0647\u064e" + + "\u0001\u0000\u0000\u0000\u0648\u0649\u0005i\u0000\u0000\u0649\u064a\u0005" + + "Z\u0000\u0000\u064a\u064b\u0003\u0002\u0001\u0000\u064b\u064c\u0005\u0086" + + "\u0000\u0000\u064c\u064e\u0001\u0000\u0000\u0000\u064d\u063e\u0001\u0000" + + "\u0000\u0000\u064d\u0644\u0001\u0000\u0000\u0000\u064d\u0648\u0001\u0000" + + "\u0000\u0000\u064e\u00dd\u0001\u0000\u0000\u0000\u064f\u0651\u0003\u00e0" + + "p\u0000\u0650\u064f\u0001\u0000\u0000\u0000\u0651\u0652\u0001\u0000\u0000" + + "\u0000\u0652\u0650\u0001\u0000\u0000\u0000\u0652\u0653\u0001\u0000\u0000" + + "\u0000\u0653\u00df\u0001\u0000\u0000\u0000\u0654\u0657\u0003\u00d0h\u0000" + + "\u0655\u0657\u0003\u00e2q\u0000\u0656\u0654\u0001\u0000\u0000\u0000\u0656" + + "\u0655\u0001\u0000\u0000\u0000\u0657\u00e1\u0001\u0000\u0000\u0000\u0658" + + "\u065a\u0003\u015e\u00af\u0000\u0659\u0658\u0001\u0000\u0000\u0000\u0659" + + "\u065a\u0001\u0000\u0000\u0000\u065a\u065c\u0001\u0000\u0000\u0000\u065b" + + "\u065d\u0003\u0100\u0080\u0000\u065c\u065b\u0001\u0000\u0000\u0000\u065c" + + "\u065d\u0001\u0000\u0000\u0000\u065d\u0663\u0001\u0000\u0000\u0000\u065e" + + "\u0664\u0003\u018e\u00c7\u0000\u065f\u0664\u0003\u0190\u00c8\u0000\u0660" + + "\u0664\u0003\u0192\u00c9\u0000\u0661\u0664\u0003\u0194\u00ca\u0000\u0662" + + "\u0664\u0003\u0196\u00cb\u0000\u0663\u065e\u0001\u0000\u0000\u0000\u0663" + + "\u065f\u0001\u0000\u0000\u0000\u0663\u0660\u0001\u0000\u0000\u0000\u0663" + + "\u0661\u0001\u0000\u0000\u0000\u0663\u0662\u0001\u0000\u0000\u0000\u0664" + + "\u00e3\u0001\u0000\u0000\u0000\u0665\u0666\u0003\u01b2\u00d9\u0000\u0666" + + "\u0667\u0005\u0095\u0000\u0000\u0667\u0669\u0003\u01b2\u00d9\u0000\u0668" + + "\u066a\u0003\u0016\u000b\u0000\u0669\u0668\u0001\u0000\u0000\u0000\u0669" + + "\u066a\u0001\u0000\u0000\u0000\u066a\u00e5\u0001\u0000\u0000\u0000\u066b" + + "\u066c\u0005\u0092\u0000\u0000\u066c\u0671\u0003\u00e8t\u0000\u066d\u066e" + + "\u0005\u0084\u0000\u0000\u066e\u0670\u0003\u00e8t\u0000\u066f\u066d\u0001" + + "\u0000\u0000\u0000\u0670\u0673\u0001\u0000\u0000\u0000\u0671\u066f\u0001" + + "\u0000\u0000\u0000\u0671\u0672\u0001\u0000\u0000\u0000\u0672\u0674\u0001" + + "\u0000\u0000\u0000\u0673\u0671\u0001\u0000\u0000\u0000\u0674\u0675\u0005" + + "\u0093\u0000\u0000\u0675\u00e7\u0001\u0000\u0000\u0000\u0676\u0678\u0003" + + "\u015e\u00af\u0000\u0677\u0676\u0001\u0000\u0000\u0000\u0677\u0678\u0001" + + "\u0000\u0000\u0000\u0678\u0679\u0001\u0000\u0000\u0000\u0679\u067a\u0003" + + "\u01b2\u00d9\u0000\u067a\u00e9\u0001\u0000\u0000\u0000\u067b\u067c\u0005" + + "\u0085\u0000\u0000\u067c\u0681\u0003\u0014\n\u0000\u067d\u067e\u0005\u0084" + + "\u0000\u0000\u067e\u0680\u0003\u0002\u0001\u0000\u067f\u067d\u0001\u0000" + + "\u0000\u0000\u0680\u0683\u0001\u0000\u0000\u0000\u0681\u067f\u0001\u0000" + + "\u0000\u0000\u0681\u0682\u0001\u0000\u0000\u0000\u0682\u00eb\u0001\u0000" + + "\u0000\u0000\u0683\u0681\u0001\u0000\u0000\u0000\u0684\u0689\u0003\u0002" + + "\u0001\u0000\u0685\u0686\u0005\u0084\u0000\u0000\u0686\u0688\u0003\u0002" + + "\u0001\u0000\u0687\u0685\u0001\u0000\u0000\u0000\u0688\u068b\u0001\u0000" + + "\u0000\u0000\u0689\u0687\u0001\u0000\u0000\u0000\u0689\u068a\u0001\u0000" + + "\u0000\u0000\u068a\u00ed\u0001\u0000\u0000\u0000\u068b\u0689\u0001\u0000" + + "\u0000\u0000\u068c\u068e\u0003\u00f0x\u0000\u068d\u068c\u0001\u0000\u0000" + + "\u0000\u068e\u068f\u0001\u0000\u0000\u0000\u068f\u068d\u0001\u0000\u0000" + + "\u0000\u068f\u0690\u0001\u0000\u0000\u0000\u0690\u00ef\u0001\u0000\u0000" + + "\u0000\u0691\u0692\u0005o\u0000\u0000\u0692\u0693\u0003\u01b2\u00d9\u0000" + + "\u0693\u0694\u0005\u0085\u0000\u0000\u0694\u0695\u0003\u00f2y\u0000\u0695" + + "\u00f1\u0001\u0000\u0000\u0000\u0696\u06a1\u0003\u00f8|\u0000\u0697\u069a" + + "\u0003\u00f4z\u0000\u0698\u0699\u0005\u0084\u0000\u0000\u0699\u069b\u0003" + + "\u00f6{\u0000\u069a\u0698\u0001\u0000\u0000\u0000\u069a\u069b\u0001\u0000" + + "\u0000\u0000\u069b\u069e\u0001\u0000\u0000\u0000\u069c\u069d\u0005\u0084" + + "\u0000\u0000\u069d\u069f\u0003\u00f8|\u0000\u069e\u069c\u0001\u0000\u0000" + + "\u0000\u069e\u069f\u0001\u0000\u0000\u0000\u069f\u06a1\u0001\u0000\u0000" + + "\u0000\u06a0\u0696\u0001\u0000\u0000\u0000\u06a0\u0697\u0001\u0000\u0000" + + "\u0000\u06a1\u00f3\u0001\u0000\u0000\u0000\u06a2\u06aa\u0003\u0014\n\u0000" + + "\u06a3\u06a5\u0005\u001a\u0000\u0000\u06a4\u06a6\u0005\u0094\u0000\u0000" + + "\u06a5\u06a4\u0001\u0000\u0000\u0000\u06a5\u06a6\u0001\u0000\u0000\u0000" + + "\u06a6\u06aa\u0001\u0000\u0000\u0000\u06a7\u06aa\u0005\\\u0000\u0000\u06a8" + + "\u06aa\u0005f\u0000\u0000\u06a9\u06a2\u0001\u0000\u0000\u0000\u06a9\u06a3" + + "\u0001\u0000\u0000\u0000\u06a9\u06a7\u0001\u0000\u0000\u0000\u06a9\u06a8" + + "\u0001\u0000\u0000\u0000\u06aa\u00f5\u0001\u0000\u0000\u0000\u06ab\u06b0" + + "\u0003\u0002\u0001\u0000\u06ac\u06ad\u0005\u0084\u0000\u0000\u06ad\u06af" + + "\u0003\u0002\u0001\u0000\u06ae\u06ac\u0001\u0000\u0000\u0000\u06af\u06b2" + + "\u0001\u0000\u0000\u0000\u06b0\u06ae\u0001\u0000\u0000\u0000\u06b0\u06b1" + + "\u0001\u0000\u0000\u0000\u06b1\u00f7\u0001\u0000\u0000\u0000\u06b2\u06b0" + + "\u0001\u0000\u0000\u0000\u06b3\u06b4\u0005B\u0000\u0000\u06b4\u06b5\u0005" + + "\u0081\u0000\u0000\u06b5\u06b6\u0005\u0082\u0000\u0000\u06b6\u00f9\u0001" + + "\u0000\u0000\u0000\u06b7\u06b9\u0005}\u0000\u0000\u06b8\u06ba\u0003\u00fc" + + "~\u0000\u06b9\u06b8\u0001\u0000\u0000\u0000\u06b9\u06ba\u0001\u0000\u0000" + + "\u0000\u06ba\u06bb\u0001\u0000\u0000\u0000\u06bb\u06bc\u0005~\u0000\u0000" + + "\u06bc\u00fb\u0001\u0000\u0000\u0000\u06bd\u06bf\u0003\u00fe\u007f\u0000" + + "\u06be\u06bd\u0001\u0000\u0000\u0000\u06bf\u06c0\u0001\u0000\u0000\u0000" + + "\u06c0\u06be\u0001\u0000\u0000\u0000\u06c0\u06c1\u0001\u0000\u0000\u0000" + + "\u06c1\u00fd\u0001\u0000\u0000\u0000\u06c2\u06c4\u0003\u015e\u00af\u0000" + + "\u06c3\u06c2\u0001\u0000\u0000\u0000\u06c3\u06c4\u0001\u0000\u0000\u0000" + + "\u06c4\u06c6\u0001\u0000\u0000\u0000\u06c5\u06c7\u0003\u0100\u0080\u0000" + + "\u06c6\u06c5\u0001\u0000\u0000\u0000\u06c6\u06c7\u0001\u0000\u0000\u0000" + + "\u06c7\u06ca\u0001\u0000\u0000\u0000\u06c8\u06cb\u0003\u0104\u0082\u0000" + + "\u06c9\u06cb\u0003\u01a2\u00d1\u0000\u06ca\u06c8\u0001\u0000\u0000\u0000" + + "\u06ca\u06c9\u0001\u0000\u0000\u0000\u06cb\u00ff\u0001\u0000\u0000\u0000" + + "\u06cc\u06ce\u0003\u0102\u0081\u0000\u06cd\u06cc\u0001\u0000\u0000\u0000" + + "\u06ce\u06cf\u0001\u0000\u0000\u0000\u06cf\u06cd\u0001\u0000\u0000\u0000" + + "\u06cf\u06d0\u0001\u0000\u0000\u0000\u06d0\u0101\u0001\u0000\u0000\u0000" + + "\u06d1\u06d2\u0007\n\u0000\u0000\u06d2\u0103\u0001\u0000\u0000\u0000\u06d3" + + "\u06e7\u0003\u019e\u00cf\u0000\u06d4\u06e7\u0003\u0106\u0083\u0000\u06d5" + + "\u06e7\u0003\u0198\u00cc\u0000\u06d6\u06dc\u0003\u0134\u009a\u0000\u06d7" + + "\u06dd\u0003\u0138\u009c\u0000\u06d8\u06d9\u0003\u0176\u00bb\u0000\u06d9" + + "\u06da\u0003J%\u0000\u06da\u06db\u0005\u0086\u0000\u0000\u06db\u06dd\u0001" + + "\u0000\u0000\u0000\u06dc\u06d7\u0001\u0000\u0000\u0000\u06dc\u06d8\u0001" + + "\u0000\u0000\u0000\u06dd\u06e7\u0001\u0000\u0000\u0000\u06de\u06e7\u0003" + + "\u01a4\u00d2\u0000\u06df\u06e0\u0005l\u0000\u0000\u06e0\u06e7\u0003\u01a6" + + "\u00d3\u0000\u06e1\u06e7\u0003\u018e\u00c7\u0000\u06e2\u06e7\u0003\u0190" + + "\u00c8\u0000\u06e3\u06e7\u0003\u0192\u00c9\u0000\u06e4\u06e7\u0003\u0194" + + "\u00ca\u0000\u06e5\u06e7\u0003\u0196\u00cb\u0000\u06e6\u06d3\u0001\u0000" + + "\u0000\u0000\u06e6\u06d4\u0001\u0000\u0000\u0000\u06e6\u06d5\u0001\u0000" + + "\u0000\u0000\u06e6\u06d6\u0001\u0000\u0000\u0000\u06e6\u06de\u0001\u0000" + + "\u0000\u0000\u06e6\u06df\u0001\u0000\u0000\u0000\u06e6\u06e1\u0001\u0000" + + "\u0000\u0000\u06e6\u06e2\u0001\u0000\u0000\u0000\u06e6\u06e3\u0001\u0000" + + "\u0000\u0000\u06e6\u06e4\u0001\u0000\u0000\u0000\u06e6\u06e5\u0001\u0000" + + "\u0000\u0000\u06e7\u0105\u0001\u0000\u0000\u0000\u06e8\u06ee\u0005P\u0000" + + "\u0000\u06e9\u06ea\u0005O\u0000\u0000\u06ea\u06ee\u0005P\u0000\u0000\u06eb" + + "\u06ec\u0005P\u0000\u0000\u06ec\u06ee\u0005O\u0000\u0000\u06ed\u06e8\u0001" + + "\u0000\u0000\u0000\u06ed\u06e9\u0001\u0000\u0000\u0000\u06ed\u06eb\u0001" + + "\u0000\u0000\u0000\u06ed\u06ee\u0001\u0000\u0000\u0000\u06ee\u06ef\u0001" + + "\u0000\u0000\u0000\u06ef\u06f9\u0003\u0004\u0002\u0000\u06f0\u06f1\u0003" + + "\u0002\u0001\u0000\u06f1\u06f2\u0005\u0083\u0000\u0000\u06f2\u06f3\u0003" + + "\u01a0\u00d0\u0000\u06f3\u06fa\u0001\u0000\u0000\u0000\u06f4\u06fa\u0003" + + "\u01a6\u00d3\u0000\u06f5\u06fa\u0003\u019c\u00ce\u0000\u06f6\u06fa\u0003" + + "\u01a0\u00d0\u0000\u06f7\u06fa\u0003\u01aa\u00d5\u0000\u06f8\u06fa\u0003" + + "\u019a\u00cd\u0000\u06f9\u06f0\u0001\u0000\u0000\u0000\u06f9\u06f4\u0001" + + "\u0000\u0000\u0000\u06f9\u06f5\u0001\u0000\u0000\u0000\u06f9\u06f6\u0001" + + "\u0000\u0000\u0000\u06f9\u06f7\u0001\u0000\u0000\u0000\u06f9\u06f8\u0001" + + "\u0000\u0000\u0000\u06fa\u0107\u0001\u0000\u0000\u0000\u06fb\u0700\u0003" + + "\u010a\u0085\u0000\u06fc\u06fd\u0005\u0084\u0000\u0000\u06fd\u06ff\u0003" + + "\u010a\u0085\u0000\u06fe\u06fc\u0001\u0000\u0000\u0000\u06ff\u0702\u0001" + + "\u0000\u0000\u0000\u0700\u06fe\u0001\u0000\u0000\u0000\u0700\u0701\u0001" + + "\u0000\u0000\u0000\u0701\u0109\u0001\u0000\u0000\u0000\u0702\u0700\u0001" + + "\u0000\u0000\u0000\u0703\u0704\u0003\u01b2\u00d9\u0000\u0704\u0705\u0005" + + "\u0091\u0000\u0000\u0705\u0706\u0003\u001c\u000e\u0000\u0706\u010b\u0001" + + "\u0000\u0000\u0000\u0707\u070c\u0003\u010e\u0087\u0000\u0708\u0709\u0005" + + "\u0084\u0000\u0000\u0709\u070b\u0003\u010e\u0087\u0000\u070a\u0708\u0001" + + "\u0000\u0000\u0000\u070b\u070e\u0001\u0000\u0000\u0000\u070c\u070a\u0001" + + "\u0000\u0000\u0000\u070c\u070d\u0001\u0000\u0000\u0000\u070d\u010d\u0001" + + "\u0000\u0000\u0000\u070e\u070c\u0001\u0000\u0000\u0000\u070f\u0712\u0003" + + "\u01b2\u00d9\u0000\u0710\u0711\u0005\u0091\u0000\u0000\u0711\u0713\u0003" + + "\u0110\u0088\u0000\u0712\u0710\u0001\u0000\u0000\u0000\u0712\u0713\u0001" + + "\u0000\u0000\u0000\u0713\u010f\u0001\u0000\u0000\u0000\u0714\u0717\u0003" + + "\u001c\u000e\u0000\u0715\u0717\u0003\u0144\u00a2\u0000\u0716\u0714\u0001" + + "\u0000\u0000\u0000\u0716\u0715\u0001\u0000\u0000\u0000\u0717\u0111\u0001" + + "\u0000\u0000\u0000\u0718\u071b\u0003\u0004\u0002\u0000\u0719\u071b\u0005" + + "l\u0000\u0000\u071a\u0718\u0001\u0000\u0000\u0000\u071a\u0719\u0001\u0000" + + "\u0000\u0000\u071b\u0113\u0001\u0000\u0000\u0000\u071c\u071d\u0003\u0002" + + "\u0001\u0000\u071d\u0115\u0001\u0000\u0000\u0000\u071e\u0721\u0003\u00aa" + + "U\u0000\u071f\u0721\u0005\u0086\u0000\u0000\u0720\u071e\u0001\u0000\u0000" + + "\u0000\u0720\u071f\u0001\u0000\u0000\u0000\u0721\u0117\u0001\u0000\u0000" + + "\u0000\u0722\u0729\u0003\u0120\u0090\u0000\u0723\u0726\u0003\u011a\u008d" + + "\u0000\u0724\u0725\u0005\u0084\u0000\u0000\u0725\u0727\u0003\u0120\u0090" + + "\u0000\u0726\u0724\u0001\u0000\u0000\u0000\u0726\u0727\u0001\u0000\u0000" + + "\u0000\u0727\u0729\u0001\u0000\u0000\u0000\u0728\u0722\u0001\u0000\u0000" + + "\u0000\u0728\u0723\u0001\u0000\u0000\u0000\u0729\u0119\u0001\u0000\u0000" + + "\u0000\u072a\u072f\u0003\u011c\u008e\u0000\u072b\u072c\u0005\u0084\u0000" + + "\u0000\u072c\u072e\u0003\u011c\u008e\u0000\u072d\u072b\u0001\u0000\u0000" + + "\u0000\u072e\u0731\u0001\u0000\u0000\u0000\u072f\u072d\u0001\u0000\u0000" + + "\u0000\u072f\u0730\u0001\u0000\u0000\u0000\u0730\u011b\u0001\u0000\u0000" + + "\u0000\u0731\u072f\u0001\u0000\u0000\u0000\u0732\u0734\u0003\u015e\u00af" + + "\u0000\u0733\u0732\u0001\u0000\u0000\u0000\u0733\u0734\u0001\u0000\u0000" + + "\u0000\u0734\u0736\u0001\u0000\u0000\u0000\u0735\u0737\u0003\u011e\u008f" + + "\u0000\u0736\u0735\u0001\u0000\u0000\u0000\u0736\u0737\u0001\u0000\u0000" + + "\u0000\u0737\u0738\u0001\u0000\u0000\u0000\u0738\u073b\u0003\u01ac\u00d6" + + "\u0000\u0739\u073b\u0005\f\u0000\u0000\u073a\u0733\u0001\u0000\u0000\u0000" + + "\u073a\u0739\u0001\u0000\u0000\u0000\u073b\u011d\u0001\u0000\u0000\u0000" + + "\u073c\u0745\u0005P\u0000\u0000\u073d\u0745\u0005H\u0000\u0000\u073e\u0745" + + "\u00056\u0000\u0000\u073f\u0740\u0005P\u0000\u0000\u0740\u0745\u0005^" + + "\u0000\u0000\u0741\u0742\u00056\u0000\u0000\u0742\u0745\u0005^\u0000\u0000" + + "\u0743\u0745\u0005^\u0000\u0000\u0744\u073c\u0001\u0000\u0000\u0000\u0744" + + "\u073d\u0001\u0000\u0000\u0000\u0744\u073e\u0001\u0000\u0000\u0000\u0744" + + "\u073f\u0001\u0000\u0000\u0000\u0744\u0741\u0001\u0000\u0000\u0000\u0744" + + "\u0743\u0001\u0000\u0000\u0000\u0745\u011f\u0001\u0000\u0000\u0000\u0746" + + "\u0748\u0003\u015e\u00af\u0000\u0747\u0746\u0001\u0000\u0000\u0000\u0747" + + "\u0748\u0001\u0000\u0000\u0000\u0748\u0749\u0001\u0000\u0000\u0000\u0749" + + "\u074a\u0005J\u0000\u0000\u074a\u074b\u0003\u0140\u00a0\u0000\u074b\u074c" + + "\u0003\u01b2\u00d9\u0000\u074c\u0121\u0001\u0000\u0000\u0000\u074d\u074f" + + "\u0003\u015e\u00af\u0000\u074e\u074d\u0001\u0000\u0000\u0000\u074e\u074f" + + "\u0001\u0000\u0000\u0000\u074f\u0751\u0001\u0000\u0000\u0000\u0750\u0752" + + "\u0003\u0128\u0094\u0000\u0751\u0750\u0001\u0000\u0000\u0000\u0751\u0752" + + "\u0001\u0000\u0000\u0000\u0752\u075d\u0001\u0000\u0000\u0000\u0753\u0754" + + "\u00051\u0000\u0000\u0754\u0756\u0003\u012a\u0095\u0000\u0755\u0757\u0003" + + "\u0126\u0093\u0000\u0756\u0755\u0001\u0000\u0000\u0000\u0756\u0757\u0001" + + "\u0000\u0000\u0000\u0757\u075e\u0001\u0000\u0000\u0000\u0758\u0759\u0005" + + "V\u0000\u0000\u0759\u075b\u0003\u012a\u0095\u0000\u075a\u075c\u0003\u0124" + + "\u0092\u0000\u075b\u075a\u0001\u0000\u0000\u0000\u075b\u075c\u0001\u0000" + + "\u0000\u0000\u075c\u075e\u0001\u0000\u0000\u0000\u075d\u0753\u0001\u0000" + + "\u0000\u0000\u075d\u0758\u0001\u0000\u0000\u0000\u075e\u0123\u0001\u0000" + + "\u0000\u0000\u075f\u0761\u0003\u015e\u00af\u0000\u0760\u075f\u0001\u0000" + + "\u0000\u0000\u0760\u0761\u0001\u0000\u0000\u0000\u0761\u0763\u0001\u0000" + + "\u0000\u0000\u0762\u0764\u0003\u0128\u0094\u0000\u0763\u0762\u0001\u0000" + + "\u0000\u0000\u0763\u0764\u0001\u0000\u0000\u0000\u0764\u0765\u0001\u0000" + + "\u0000\u0000\u0765\u0766\u00051\u0000\u0000\u0766\u0767\u0003\u012a\u0095" + + "\u0000\u0767\u0125\u0001\u0000\u0000\u0000\u0768\u076a\u0003\u015e\u00af" + + "\u0000\u0769\u0768\u0001\u0000\u0000\u0000\u0769\u076a\u0001\u0000\u0000" + + "\u0000\u076a\u076c\u0001\u0000\u0000\u0000\u076b\u076d\u0003\u0128\u0094" + + "\u0000\u076c\u076b\u0001\u0000\u0000\u0000\u076c\u076d\u0001\u0000\u0000" + + "\u0000\u076d\u076e\u0001\u0000\u0000\u0000\u076e\u076f\u0005V\u0000\u0000" + + "\u076f\u0770\u0003\u012a\u0095\u0000\u0770\u0127\u0001\u0000\u0000\u0000" + + "\u0771\u0779\u0005M\u0000\u0000\u0772\u0779\u00059\u0000\u0000\u0773\u0779" + + "\u0005L\u0000\u0000\u0774\u0775\u0005M\u0000\u0000\u0775\u0779\u00059" + + "\u0000\u0000\u0776\u0777\u00059\u0000\u0000\u0777\u0779\u0005M\u0000\u0000" + + "\u0778\u0771\u0001\u0000\u0000\u0000\u0778\u0772\u0001\u0000\u0000\u0000" + + "\u0778\u0773\u0001\u0000\u0000\u0000\u0778\u0774\u0001\u0000\u0000\u0000" + + "\u0778\u0776\u0001\u0000\u0000\u0000\u0779\u0129\u0001\u0000\u0000\u0000" + + "\u077a\u077d\u0003\u00aaU\u0000\u077b\u077d\u0005\u0086\u0000\u0000\u077c" + + "\u077a\u0001\u0000\u0000\u0000\u077c\u077b\u0001\u0000\u0000\u0000\u077d" + + "\u012b\u0001\u0000\u0000\u0000\u077e\u0780\u0003\u015e\u00af\u0000\u077f" + + "\u077e\u0001\u0000\u0000\u0000\u077f\u0780\u0001\u0000\u0000\u0000\u0780" + + "\u0789\u0001\u0000\u0000\u0000\u0781\u0782\u0005\n\u0000\u0000\u0782\u0783" + + "\u0003\u00aaU\u0000\u0783\u0784\u0003\u0130\u0098\u0000\u0784\u078a\u0001" + + "\u0000\u0000\u0000\u0785\u0786\u0005Q\u0000\u0000\u0786\u0787\u0003\u00aa" + + "U\u0000\u0787\u0788\u0003\u012e\u0097\u0000\u0788\u078a\u0001\u0000\u0000" + + "\u0000\u0789\u0781\u0001\u0000\u0000\u0000\u0789\u0785\u0001\u0000\u0000" + + "\u0000\u078a\u012d\u0001\u0000\u0000\u0000\u078b\u078d\u0003\u015e\u00af" + + "\u0000\u078c\u078b\u0001\u0000\u0000\u0000\u078c\u078d\u0001\u0000\u0000" + + "\u0000\u078d\u078e\u0001\u0000\u0000\u0000\u078e\u078f\u0005\n\u0000\u0000" + + "\u078f\u0790\u0003\u00aaU\u0000\u0790\u012f\u0001\u0000\u0000\u0000\u0791" + + "\u0793\u0003\u015e\u00af\u0000\u0792\u0791\u0001\u0000\u0000\u0000\u0792" + + "\u0793\u0001\u0000\u0000\u0000\u0793\u0794\u0001\u0000\u0000\u0000\u0794" + + "\u0795\u0005Q\u0000\u0000\u0795\u0796\u0003\u00aaU\u0000\u0796\u0131\u0001" + + "\u0000\u0000\u0000\u0797\u07ae\u0005\u0087\u0000\u0000\u0798\u07ae\u0005" + + "\u0088\u0000\u0000\u0799\u07ae\u0005\u008f\u0000\u0000\u079a\u07ae\u0005" + + "\u0090\u0000\u0000\u079b\u07ae\u0005\u0097\u0000\u0000\u079c\u07ae\u0005" + + "\u0098\u0000\u0000\u079d\u07ae\u0005`\u0000\u0000\u079e\u07ae\u0005*\u0000" + + "\u0000\u079f\u07ae\u0005\u0089\u0000\u0000\u07a0\u07ae\u0005\u008a\u0000" + + "\u0000\u07a1\u07ae\u0005\u008b\u0000\u0000\u07a2\u07ae\u0005\u008c\u0000" + + "\u0000\u07a3\u07ae\u0005\u008d\u0000\u0000\u07a4\u07ae\u0005\u008e\u0000" + + "\u0000\u07a5\u07ae\u0005\u00a8\u0000\u0000\u07a6\u07ae\u0003\u0178\u00bc" + + "\u0000\u07a7\u07ae\u0005\u009c\u0000\u0000\u07a8\u07ae\u0005\u009d\u0000" + + "\u0000\u07a9\u07ae\u0005\u0093\u0000\u0000\u07aa\u07ae\u0005\u0092\u0000" + + "\u0000\u07ab\u07ae\u0005\u009f\u0000\u0000\u07ac\u07ae\u0005\u009e\u0000" + + "\u0000\u07ad\u0797\u0001\u0000\u0000\u0000\u07ad\u0798\u0001\u0000\u0000" + + "\u0000\u07ad\u0799\u0001\u0000\u0000\u0000\u07ad\u079a\u0001\u0000\u0000" + + "\u0000\u07ad\u079b\u0001\u0000\u0000\u0000\u07ad\u079c\u0001\u0000\u0000" + + "\u0000\u07ad\u079d\u0001\u0000\u0000\u0000\u07ad\u079e\u0001\u0000\u0000" + + "\u0000\u07ad\u079f\u0001\u0000\u0000\u0000\u07ad\u07a0\u0001\u0000\u0000" + + "\u0000\u07ad\u07a1\u0001\u0000\u0000\u0000\u07ad\u07a2\u0001\u0000\u0000" + + "\u0000\u07ad\u07a3\u0001\u0000\u0000\u0000\u07ad\u07a4\u0001\u0000\u0000" + + "\u0000\u07ad\u07a5\u0001\u0000\u0000\u0000\u07ad\u07a6\u0001\u0000\u0000" + + "\u0000\u07ad\u07a7\u0001\u0000\u0000\u0000\u07ad\u07a8\u0001\u0000\u0000" + + "\u0000\u07ad\u07a9\u0001\u0000\u0000\u0000\u07ad\u07aa\u0001\u0000\u0000" + + "\u0000\u07ad\u07ab\u0001\u0000\u0000\u0000\u07ad\u07ac\u0001\u0000\u0000" + + "\u0000\u07ae\u0133\u0001\u0000\u0000\u0000\u07af\u07b0\u0007\u000b\u0000" + + "\u0000\u07b0\u07b1\u0005F\u0000\u0000\u07b1\u07b2\u0003\u0004\u0002\u0000" + + "\u07b2\u07b3\u0005\u0081\u0000\u0000\u07b3\u07b4\u0003\u01ac\u00d6\u0000" + + "\u07b4\u07b5\u0005\u0082\u0000\u0000\u07b5\u0135\u0001\u0000\u0000\u0000" + + "\u07b6\u07b7\u0005\u0085\u0000\u0000\u07b7\u07b8\u0007\f\u0000\u0000\u07b8" + + "\u07ba\u0005\u0081\u0000\u0000\u07b9\u07bb\u0003\u0018\f\u0000\u07ba\u07b9" + + "\u0001\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000\u07bb\u07bc" + + "\u0001\u0000\u0000\u0000\u07bc\u07bd\u0005\u0082\u0000\u0000\u07bd\u0137" + + "\u0001\u0000\u0000\u0000\u07be\u07c1\u0003\u00aaU\u0000\u07bf\u07c1\u0005" + + "\u0086\u0000\u0000\u07c0\u07be\u0001\u0000\u0000\u0000\u07c0\u07bf\u0001" + + "\u0000\u0000\u0000\u07c1\u0139\u0001\u0000\u0000\u0000\u07c2\u07c3\u0005" + + "\u0085\u0000\u0000\u07c3\u07c4\u0003\u00ecv\u0000\u07c4\u013b\u0001\u0000" + + "\u0000\u0000\u07c5\u07c9\u0005}\u0000\u0000\u07c6\u07c8\u0003\u013e\u009f" + + "\u0000\u07c7\u07c6\u0001\u0000\u0000\u0000\u07c8\u07cb\u0001\u0000\u0000" + + "\u0000\u07c9\u07c7\u0001\u0000\u0000\u0000\u07c9\u07ca\u0001\u0000\u0000" + + "\u0000\u07ca\u07cc\u0001\u0000\u0000\u0000\u07cb\u07c9\u0001\u0000\u0000" + + "\u0000\u07cc\u07cd\u0005~\u0000\u0000\u07cd\u013d\u0001\u0000\u0000\u0000" + + "\u07ce\u07d0\u0003\u015e\u00af\u0000\u07cf\u07ce\u0001\u0000\u0000\u0000" + + "\u07cf\u07d0\u0001\u0000\u0000\u0000\u07d0\u07d2\u0001\u0000\u0000\u0000" + + "\u07d1\u07d3\u0003\u0100\u0080\u0000\u07d2\u07d1\u0001\u0000\u0000\u0000" + + "\u07d2\u07d3\u0001\u0000\u0000\u0000\u07d3\u07de\u0001\u0000\u0000\u0000" + + "\u07d4\u07df\u0003\u0104\u0082\u0000\u07d5\u07d6\u0005,\u0000\u0000\u07d6" + + "\u07d8\u0003\u0004\u0002\u0000\u07d7\u07d9\u0003\u0172\u00b9\u0000\u07d8" + + "\u07d7\u0001\u0000\u0000\u0000\u07d9\u07da\u0001\u0000\u0000\u0000\u07da" + + "\u07d8\u0001\u0000\u0000\u0000\u07da\u07db\u0001\u0000\u0000\u0000\u07db" + + "\u07dc\u0001\u0000\u0000\u0000\u07dc\u07dd\u0005\u0086\u0000\u0000\u07dd" + + "\u07df\u0001\u0000\u0000\u0000\u07de\u07d4\u0001\u0000\u0000\u0000\u07de" + + "\u07d5\u0001\u0000\u0000\u0000\u07df\u013f\u0001\u0000\u0000\u0000\u07e0" + + "\u07e8\u0003\u0006\u0003\u0000\u07e1\u07e3\u0007\r\u0000\u0000\u07e2\u07e1" + + "\u0001\u0000\u0000\u0000\u07e3\u07e6\u0001\u0000\u0000\u0000\u07e4\u07e2" + + "\u0001\u0000\u0000\u0000\u07e4\u07e5\u0001\u0000\u0000\u0000\u07e5\u07e7" + + "\u0001\u0000\u0000\u0000\u07e6\u07e4\u0001\u0000\u0000\u0000\u07e7\u07e9" + + "\u0003\u0142\u00a1\u0000\u07e8\u07e4\u0001\u0000\u0000\u0000\u07e9\u07ea" + + "\u0001\u0000\u0000\u0000\u07ea\u07e8\u0001\u0000\u0000\u0000\u07ea\u07eb" + + "\u0001\u0000\u0000\u0000\u07eb\u0141\u0001\u0000\u0000\u0000\u07ec\u07f0" + + "\u0005\u007f\u0000\u0000\u07ed\u07ef\u0005\u0084\u0000\u0000\u07ee\u07ed" + + "\u0001\u0000\u0000\u0000\u07ef\u07f2\u0001\u0000\u0000\u0000\u07f0\u07ee" + + "\u0001\u0000\u0000\u0000\u07f0\u07f1\u0001\u0000\u0000\u0000\u07f1\u07f3" + + "\u0001\u0000\u0000\u0000\u07f2\u07f0\u0001\u0000\u0000\u0000\u07f3\u07f4" + + "\u0005\u0080\u0000\u0000\u07f4\u0143\u0001\u0000\u0000\u0000\u07f5\u0801" + + "\u0005}\u0000\u0000\u07f6\u07fb\u0003\u0110\u0088\u0000\u07f7\u07f8\u0005" + + "\u0084\u0000\u0000\u07f8\u07fa\u0003\u0110\u0088\u0000\u07f9\u07f7\u0001" + + "\u0000\u0000\u0000\u07fa\u07fd\u0001\u0000\u0000\u0000\u07fb\u07f9\u0001" + + "\u0000\u0000\u0000\u07fb\u07fc\u0001\u0000\u0000\u0000\u07fc\u07ff\u0001" + + "\u0000\u0000\u0000\u07fd\u07fb\u0001\u0000\u0000\u0000\u07fe\u0800\u0005" + + "\u0084\u0000\u0000\u07ff\u07fe\u0001\u0000\u0000\u0000\u07ff\u0800\u0001" + + "\u0000\u0000\u0000\u0800\u0802\u0001\u0000\u0000\u0000\u0801\u07f6\u0001" + + "\u0000\u0000\u0000\u0801\u0802\u0001\u0000\u0000\u0000\u0802\u0803\u0001" + + "\u0000\u0000\u0000\u0803\u0804\u0005~\u0000\u0000\u0804\u0145\u0001\u0000" + + "\u0000\u0000\u0805\u0806\u0005\u0092\u0000\u0000\u0806\u080b\u0003\u0148" + + "\u00a4\u0000\u0807\u0808\u0005\u0084\u0000\u0000\u0808\u080a\u0003\u0148" + + "\u00a4\u0000\u0809\u0807\u0001\u0000\u0000\u0000\u080a\u080d\u0001\u0000" + + "\u0000\u0000\u080b\u0809\u0001\u0000\u0000\u0000\u080b\u080c\u0001\u0000" + + "\u0000\u0000\u080c\u080e\u0001\u0000\u0000\u0000\u080d\u080b\u0001\u0000" + + "\u0000\u0000\u080e\u080f\u0005\u0093\u0000\u0000\u080f\u0147\u0001\u0000" + + "\u0000\u0000\u0810\u0812\u0003\u015e\u00af\u0000\u0811\u0810\u0001\u0000" + + "\u0000\u0000\u0811\u0812\u0001\u0000\u0000\u0000\u0812\u0814\u0001\u0000" + + "\u0000\u0000\u0813\u0815\u0003\u014a\u00a5\u0000\u0814\u0813\u0001\u0000" + + "\u0000\u0000\u0814\u0815\u0001\u0000\u0000\u0000\u0815\u0816\u0001\u0000" + + "\u0000\u0000\u0816\u0817\u0003\u01b2\u00d9\u0000\u0817\u0149\u0001\u0000" + + "\u0000\u0000\u0818\u0819\u0007\u000e\u0000\u0000\u0819\u014b\u0001\u0000" + + "\u0000\u0000\u081a\u081b\u0005\u0085\u0000\u0000\u081b\u081c\u0003\u00ec" + + "v\u0000\u081c\u014d\u0001\u0000\u0000\u0000\u081d\u0821\u0005}\u0000\u0000" + + "\u081e\u0820\u0003\u0150\u00a8\u0000\u081f\u081e\u0001\u0000\u0000\u0000" + + "\u0820\u0823\u0001\u0000\u0000\u0000\u0821\u081f\u0001\u0000\u0000\u0000" + + "\u0821\u0822\u0001\u0000\u0000\u0000\u0822\u0824\u0001\u0000\u0000\u0000" + + "\u0823\u0821\u0001\u0000\u0000\u0000\u0824\u0825\u0005~\u0000\u0000\u0825" + + "\u014f\u0001\u0000\u0000\u0000\u0826\u0828\u0003\u015e\u00af\u0000\u0827" + + "\u0826\u0001\u0000\u0000\u0000\u0827\u0828\u0001\u0000\u0000\u0000\u0828" + + "\u082a\u0001\u0000\u0000\u0000\u0829\u082b\u0005B\u0000\u0000\u082a\u0829" + + "\u0001\u0000\u0000\u0000\u082a\u082b\u0001\u0000\u0000\u0000\u082b\u086b" + + "\u0001\u0000\u0000\u0000\u082c\u082e\u0005g\u0000\u0000\u082d\u082c\u0001" + + "\u0000\u0000\u0000\u082d\u082e\u0001\u0000\u0000\u0000\u082e\u0834\u0001" + + "\u0000\u0000\u0000\u082f\u0835\u0005P\u0000\u0000\u0830\u0831\u0005P\u0000" + + "\u0000\u0831\u0835\u0005O\u0000\u0000\u0832\u0833\u0005O\u0000\u0000\u0833" + + "\u0835\u0005P\u0000\u0000\u0834\u082f\u0001\u0000\u0000\u0000\u0834\u0830" + + "\u0001\u0000\u0000\u0000\u0834\u0832\u0001\u0000\u0000\u0000\u0834\u0835" + + "\u0001\u0000\u0000\u0000\u0835\u0836\u0001\u0000\u0000\u0000\u0836\u0852" + + "\u0003\u0004\u0002\u0000\u0837\u0839\u0003\u01b2\u00d9\u0000\u0838\u083a" + + "\u0003\u00e6s\u0000\u0839\u0838\u0001\u0000\u0000\u0000\u0839\u083a\u0001" + + "\u0000\u0000\u0000\u083a\u083b\u0001\u0000\u0000\u0000\u083b\u083d\u0005" + + "\u0081\u0000\u0000\u083c\u083e\u0003\u0118\u008c\u0000\u083d\u083c\u0001" + + "\u0000\u0000\u0000\u083d\u083e\u0001\u0000\u0000\u0000\u083e\u083f\u0001" + + "\u0000\u0000\u0000\u083f\u0841\u0005\u0082\u0000\u0000\u0840\u0842\u0003" + + "\u00eew\u0000\u0841\u0840\u0001\u0000\u0000\u0000\u0841\u0842\u0001\u0000" + + "\u0000\u0000\u0842\u0843\u0001\u0000\u0000\u0000\u0843\u0844\u0005\u0086" + + "\u0000\u0000\u0844\u0853\u0001\u0000\u0000\u0000\u0845\u0846\u0003\u01b2" + + "\u00d9\u0000\u0846\u0847\u0005}\u0000\u0000\u0847\u0848\u0003\u0152\u00a9" + + "\u0000\u0848\u0849\u0005~\u0000\u0000\u0849\u0853\u0001\u0000\u0000\u0000" + + "\u084a\u084b\u0005^\u0000\u0000\u084b\u084c\u0005\u007f\u0000\u0000\u084c" + + "\u084d\u0003\u0118\u008c\u0000\u084d\u084e\u0005\u0080\u0000\u0000\u084e" + + "\u084f\u0005}\u0000\u0000\u084f\u0850\u0003\u0152\u00a9\u0000\u0850\u0851" + + "\u0005~\u0000\u0000\u0851\u0853\u0001\u0000\u0000\u0000\u0852\u0837\u0001" + + "\u0000\u0000\u0000\u0852\u0845\u0001\u0000\u0000\u0000\u0852\u084a\u0001" + + "\u0000\u0000\u0000\u0853\u086c\u0001\u0000\u0000\u0000\u0854\u0856\u0005" + + "g\u0000\u0000\u0855\u0854\u0001\u0000\u0000\u0000\u0855\u0856\u0001\u0000" + + "\u0000\u0000\u0856\u0857\u0001\u0000\u0000\u0000\u0857\u0858\u0005l\u0000" + + "\u0000\u0858\u085a\u0003\u01b2\u00d9\u0000\u0859\u085b\u0003\u00e6s\u0000" + + "\u085a\u0859\u0001\u0000\u0000\u0000\u085a\u085b\u0001\u0000\u0000\u0000" + + "\u085b\u085c\u0001\u0000\u0000\u0000\u085c\u085e\u0005\u0081\u0000\u0000" + + "\u085d\u085f\u0003\u0118\u008c\u0000\u085e\u085d\u0001\u0000\u0000\u0000" + + "\u085e\u085f\u0001\u0000\u0000\u0000\u085f\u0860\u0001\u0000\u0000\u0000" + + "\u0860\u0862\u0005\u0082\u0000\u0000\u0861\u0863\u0003\u00eew\u0000\u0862" + + "\u0861\u0001\u0000\u0000\u0000\u0862\u0863\u0001\u0000\u0000\u0000\u0863" + + "\u0864\u0001\u0000\u0000\u0000\u0864\u0865\u0005\u0086\u0000\u0000\u0865" + + "\u086c\u0001\u0000\u0000\u0000\u0866\u0867\u0005\'\u0000\u0000\u0867\u0868" + + "\u0003\u0004\u0002\u0000\u0868\u0869\u0003\u01b2\u00d9\u0000\u0869\u086a" + + "\u0005\u0086\u0000\u0000\u086a\u086c\u0001\u0000\u0000\u0000\u086b\u082d" + + "\u0001\u0000\u0000\u0000\u086b\u0855\u0001\u0000\u0000\u0000\u086b\u0866" + + "\u0001\u0000\u0000\u0000\u086c\u0151\u0001\u0000\u0000\u0000\u086d\u086f" + + "\u0003\u015e\u00af\u0000\u086e\u086d\u0001\u0000\u0000\u0000\u086e\u086f" + + "\u0001\u0000\u0000\u0000\u086f\u0882\u0001\u0000\u0000\u0000\u0870\u0871" + + "\u00051\u0000\u0000\u0871\u0877\u0005\u0086\u0000\u0000\u0872\u0874\u0003" + + "\u015e\u00af\u0000\u0873\u0872\u0001\u0000\u0000\u0000\u0873\u0874\u0001" + + "\u0000\u0000\u0000\u0874\u0875\u0001\u0000\u0000\u0000\u0875\u0876\u0005" + + "V\u0000\u0000\u0876\u0878\u0005\u0086\u0000\u0000\u0877\u0873\u0001\u0000" + + "\u0000\u0000\u0877\u0878\u0001\u0000\u0000\u0000\u0878\u0883\u0001\u0000" + + "\u0000\u0000\u0879\u087a\u0005V\u0000\u0000\u087a\u0880\u0005\u0086\u0000" + + "\u0000\u087b\u087d\u0003\u015e\u00af\u0000\u087c\u087b\u0001\u0000\u0000" + + "\u0000\u087c\u087d\u0001\u0000\u0000\u0000\u087d\u087e\u0001\u0000\u0000" + + "\u0000\u087e\u087f\u00051\u0000\u0000\u087f\u0881\u0005\u0086\u0000\u0000" + + "\u0880\u087c\u0001\u0000\u0000\u0000\u0880\u0881\u0001\u0000\u0000\u0000" + + "\u0881\u0883\u0001\u0000\u0000\u0000\u0882\u0870\u0001\u0000\u0000\u0000" + + "\u0882\u0879\u0001\u0000\u0000\u0000\u0883\u0153\u0001\u0000\u0000\u0000" + + "\u0884\u0885\u0005\u0085\u0000\u0000\u0885\u0886\u0003\u0004\u0002\u0000" + + "\u0886\u0155\u0001\u0000\u0000\u0000\u0887\u0893\u0005}\u0000\u0000\u0888" + + "\u088d\u0003\u0158\u00ac\u0000\u0889\u088a\u0005\u0084\u0000\u0000\u088a" + + "\u088c\u0003\u0158\u00ac\u0000\u088b\u0889\u0001\u0000\u0000\u0000\u088c" + + "\u088f\u0001\u0000\u0000\u0000\u088d\u088b\u0001\u0000\u0000\u0000\u088d" + + "\u088e\u0001\u0000\u0000\u0000\u088e\u0891\u0001\u0000\u0000\u0000\u088f" + + "\u088d\u0001\u0000\u0000\u0000\u0890\u0892\u0005\u0084\u0000\u0000\u0891" + + "\u0890\u0001\u0000\u0000\u0000\u0891\u0892\u0001\u0000\u0000\u0000\u0892" + + "\u0894\u0001\u0000\u0000\u0000\u0893\u0888\u0001\u0000\u0000\u0000\u0893" + + "\u0894\u0001\u0000\u0000\u0000\u0894\u0895\u0001\u0000\u0000\u0000\u0895" + + "\u0896\u0005~\u0000\u0000\u0896\u0157\u0001\u0000\u0000\u0000\u0897\u0899" + + "\u0003\u015e\u00af\u0000\u0898\u0897\u0001\u0000\u0000\u0000\u0898\u0899" + + "\u0001\u0000\u0000\u0000\u0899\u089a\u0001\u0000\u0000\u0000\u089a\u089d" + + "\u0003\u01b2\u00d9\u0000\u089b\u089c\u0005\u0091\u0000\u0000\u089c\u089e" + + "\u0003\u001c\u000e\u0000\u089d\u089b\u0001\u0000\u0000\u0000\u089d\u089e" + + "\u0001\u0000\u0000\u0000\u089e\u0159\u0001\u0000\u0000\u0000\u089f\u08a0" + + "\u0005\u007f\u0000\u0000\u08a0\u08a1\u0003\u015c\u00ae\u0000\u08a1\u08a2" + + "\u0005\u0085\u0000\u0000\u08a2\u08a4\u0003\u0164\u00b2\u0000\u08a3\u08a5" + + "\u0005\u0084\u0000\u0000\u08a4\u08a3\u0001\u0000\u0000\u0000\u08a4\u08a5" + + "\u0001\u0000\u0000\u0000\u08a5\u08a6\u0001\u0000\u0000\u0000\u08a6\u08a7" + + "\u0005\u0080\u0000\u0000\u08a7\u015b\u0001\u0000\u0000\u0000\u08a8\u08ab" + + "\u0003\u018c\u00c6\u0000\u08a9\u08ab\u0003\u01b2\u00d9\u0000\u08aa\u08a8" + + "\u0001\u0000\u0000\u0000\u08aa\u08a9\u0001\u0000\u0000\u0000\u08ab\u015d" + + "\u0001\u0000\u0000\u0000\u08ac\u08ae\u0003\u0160\u00b0\u0000\u08ad\u08ac" + + "\u0001\u0000\u0000\u0000\u08ae\u08af\u0001\u0000\u0000\u0000\u08af\u08ad" + + "\u0001\u0000\u0000\u0000\u08af\u08b0\u0001\u0000\u0000\u0000\u08b0\u015f" + + "\u0001\u0000\u0000\u0000\u08b1\u08b5\u0005\u007f\u0000\u0000\u08b2\u08b3" + + "\u0003\u0162\u00b1\u0000\u08b3\u08b4\u0005\u0085\u0000\u0000\u08b4\u08b6" + + "\u0001\u0000\u0000\u0000\u08b5\u08b2\u0001\u0000\u0000\u0000\u08b5\u08b6" + + "\u0001\u0000\u0000\u0000\u08b6\u08b7\u0001\u0000\u0000\u0000\u08b7\u08b9" + + "\u0003\u0164\u00b2\u0000\u08b8\u08ba\u0005\u0084\u0000\u0000\u08b9\u08b8" + + "\u0001\u0000\u0000\u0000\u08b9\u08ba\u0001\u0000\u0000\u0000\u08ba\u08bb" + + "\u0001\u0000\u0000\u0000\u08bb\u08bc\u0005\u0080\u0000\u0000\u08bc\u0161" + + "\u0001\u0000\u0000\u0000\u08bd\u08c0\u0003\u018c\u00c6\u0000\u08be\u08c0" + + "\u0003\u01b2\u00d9\u0000\u08bf\u08bd\u0001\u0000\u0000\u0000\u08bf\u08be" + + "\u0001\u0000\u0000\u0000\u08c0\u0163\u0001\u0000\u0000\u0000\u08c1\u08c6" + + "\u0003\u0166\u00b3\u0000\u08c2\u08c3\u0005\u0084\u0000\u0000\u08c3\u08c5" + + "\u0003\u0166\u00b3\u0000\u08c4\u08c2\u0001\u0000\u0000\u0000\u08c5\u08c8" + + "\u0001\u0000\u0000\u0000\u08c6\u08c4\u0001\u0000\u0000\u0000\u08c6\u08c7" + + "\u0001\u0000\u0000\u0000\u08c7\u0165\u0001\u0000\u0000\u0000\u08c8\u08c6" + + "\u0001\u0000\u0000\u0000\u08c9\u08d6\u0003\u0002\u0001\u0000\u08ca\u08d3" + + "\u0005\u0081\u0000\u0000\u08cb\u08d0\u0003\u0168\u00b4\u0000\u08cc\u08cd" + + "\u0005\u0084\u0000\u0000\u08cd\u08cf\u0003\u0168\u00b4\u0000\u08ce\u08cc" + + "\u0001\u0000\u0000\u0000\u08cf\u08d2\u0001\u0000\u0000\u0000\u08d0\u08ce" + + "\u0001\u0000\u0000\u0000\u08d0\u08d1\u0001\u0000\u0000\u0000\u08d1\u08d4" + + "\u0001\u0000\u0000\u0000\u08d2\u08d0\u0001\u0000\u0000\u0000\u08d3\u08cb" + + "\u0001\u0000\u0000\u0000\u08d3\u08d4\u0001\u0000\u0000\u0000\u08d4\u08d5" + + "\u0001\u0000\u0000\u0000\u08d5\u08d7\u0005\u0082\u0000\u0000\u08d6\u08ca" + + "\u0001\u0000\u0000\u0000\u08d6\u08d7\u0001\u0000\u0000\u0000\u08d7\u0167" + + "\u0001\u0000\u0000\u0000\u08d8\u08d9\u0003\u01b2\u00d9\u0000\u08d9\u08da" + + "\u0005\u0085\u0000\u0000\u08da\u08dc\u0001\u0000\u0000\u0000\u08db\u08d8" + + "\u0001\u0000\u0000\u0000\u08db\u08dc\u0001\u0000\u0000\u0000\u08dc\u08dd" + + "\u0001\u0000\u0000\u0000\u08dd\u08de\u0003\u001c\u000e\u0000\u08de\u0169" + + "\u0001\u0000\u0000\u0000\u08df\u08e2\u0003\f\u0006\u0000\u08e0\u08e2\u0003" + + "\u0014\n\u0000\u08e1\u08df\u0001\u0000\u0000\u0000\u08e1\u08e0\u0001\u0000" + + "\u0000\u0000\u08e2\u08e7\u0001\u0000\u0000\u0000\u08e3\u08e6\u0003\u0142" + + "\u00a1\u0000\u08e4\u08e6\u0005\u0094\u0000\u0000\u08e5\u08e3\u0001\u0000" + + "\u0000\u0000\u08e5\u08e4\u0001\u0000\u0000\u0000\u08e6\u08e9\u0001\u0000" + + "\u0000\u0000\u08e7\u08e5\u0001\u0000\u0000\u0000\u08e7\u08e8\u0001\u0000" + + "\u0000\u0000\u08e8\u08ea\u0001\u0000\u0000\u0000\u08e9\u08e7\u0001\u0000" + + "\u0000\u0000\u08ea\u08eb\u0005\u0089\u0000\u0000\u08eb\u08ef\u0001\u0000" + + "\u0000\u0000\u08ec\u08ed\u0005l\u0000\u0000\u08ed\u08ef\u0005\u0089\u0000" + + "\u0000\u08ee\u08e1\u0001\u0000\u0000\u0000\u08ee\u08ec\u0001\u0000\u0000" + + "\u0000\u08ef\u016b\u0001\u0000\u0000\u0000\u08f0\u08f5\u0003\u016e\u00b7" + + "\u0000\u08f1\u08f2\u0005\u0084\u0000\u0000\u08f2\u08f4\u0003\u016e\u00b7" + + "\u0000\u08f3\u08f1\u0001\u0000\u0000\u0000\u08f4\u08f7\u0001\u0000\u0000" + + "\u0000\u08f5\u08f3\u0001\u0000\u0000\u0000\u08f5\u08f6\u0001\u0000\u0000" + + "\u0000\u08f6\u016d\u0001\u0000\u0000\u0000\u08f7\u08f5\u0001\u0000\u0000" + + "\u0000\u08f8\u08f9\u0003\u01b2\u00d9\u0000\u08f9\u08fa\u0005\u0091\u0000" + + "\u0000\u08fa\u08fb\u0003\u0170\u00b8\u0000\u08fb\u016f\u0001\u0000\u0000" + + "\u0000\u08fc\u08fe\u0005\u008c\u0000\u0000\u08fd\u08fc\u0001\u0000\u0000" + + "\u0000\u08fd\u08fe\u0001\u0000\u0000\u0000\u08fe\u08ff\u0001\u0000\u0000" + + "\u0000\u08ff\u0902\u0003\u001c\u000e\u0000\u0900\u0902\u0003\u0174\u00ba" + + "\u0000\u0901\u08fd\u0001\u0000\u0000\u0000\u0901\u0900\u0001\u0000\u0000" + + "\u0000\u0902\u0171\u0001\u0000\u0000\u0000\u0903\u0904\u0003\u01b2\u00d9" + + "\u0000\u0904\u0905\u0005\u007f\u0000\u0000\u0905\u0906\u0003\u001c\u000e" + + "\u0000\u0906\u0907\u0005\u0080\u0000\u0000\u0907\u0173\u0001\u0000\u0000" + + "\u0000\u0908\u0909\u0005Y\u0000\u0000\u0909\u090a\u0003\u0004\u0002\u0000" + + "\u090a\u090b\u0005\u007f\u0000\u0000\u090b\u090c\u0003\u001c\u000e\u0000" + + "\u090c\u090d\u0005\u0080\u0000\u0000\u090d\u0926\u0001\u0000\u0000\u0000" + + "\u090e\u0910\u0005Y\u0000\u0000\u090f\u0911\u0003\u0004\u0002\u0000\u0910" + + "\u090f\u0001\u0000\u0000\u0000\u0910\u0911\u0001\u0000\u0000\u0000\u0911" + + "\u0912\u0001\u0000\u0000\u0000\u0912\u0914\u0005\u007f\u0000\u0000\u0913" + + "\u0915\u0003\u001c\u000e\u0000\u0914\u0913\u0001\u0000\u0000\u0000\u0914" + + "\u0915\u0001\u0000\u0000\u0000\u0915\u0916\u0001\u0000\u0000\u0000\u0916" + + "\u0917\u0005\u0080\u0000\u0000\u0917\u0918\u0005}\u0000\u0000\u0918\u091d" + + "\u0003\u001c\u000e\u0000\u0919\u091a\u0005\u0084\u0000\u0000\u091a\u091c" + + "\u0003\u001c\u000e\u0000\u091b\u0919\u0001\u0000\u0000\u0000\u091c\u091f" + + "\u0001\u0000\u0000\u0000\u091d\u091b\u0001\u0000\u0000\u0000\u091d\u091e" + + "\u0001\u0000\u0000\u0000\u091e\u0921\u0001\u0000\u0000\u0000\u091f\u091d" + + "\u0001\u0000\u0000\u0000\u0920\u0922\u0005\u0084\u0000\u0000\u0921\u0920" + + "\u0001\u0000\u0000\u0000\u0921\u0922\u0001\u0000\u0000\u0000\u0922\u0923" + + "\u0001\u0000\u0000\u0000\u0923\u0924\u0005~\u0000\u0000\u0924\u0926\u0001" + + "\u0000\u0000\u0000\u0925\u0908\u0001\u0000\u0000\u0000\u0925\u090e\u0001" + + "\u0000\u0000\u0000\u0926\u0175\u0001\u0000\u0000\u0000\u0927\u0928\u0005" + + "\u0091\u0000\u0000\u0928\u0929\u0005\u0093\u0000\u0000\u0929\u092a\u0004" + + "\u00bb\u0000\u0001\u092a\u0177\u0001\u0000\u0000\u0000\u092b\u092c\u0005" + + "\u0093\u0000\u0000\u092c\u092d\u0005\u0093\u0000\u0000\u092d\u092e\u0004" + + "\u00bc\u0001\u0001\u092e\u0179\u0001\u0000\u0000\u0000\u092f\u0930\u0005" + + "\u0093\u0000\u0000\u0930\u0931\u0005\u009f\u0000\u0000\u0931\u0932\u0004" + + "\u00bd\u0002\u0001\u0932\u017b\u0001\u0000\u0000\u0000\u0933\u093c\u0003" + + "\u017e\u00bf\u0000\u0934\u093c\u0003\u0180\u00c0\u0000\u0935\u093c\u0005" + + "t\u0000\u0000\u0936\u093c\u0005u\u0000\u0000\u0937\u093c\u0005v\u0000" + + "\u0000\u0938\u093c\u0005w\u0000\u0000\u0939\u093c\u0005x\u0000\u0000\u093a" + + "\u093c\u0005C\u0000\u0000\u093b\u0933\u0001\u0000\u0000\u0000\u093b\u0934" + + "\u0001\u0000\u0000\u0000\u093b\u0935\u0001\u0000\u0000\u0000\u093b\u0936" + + "\u0001\u0000\u0000\u0000\u093b\u0937\u0001\u0000\u0000\u0000\u093b\u0938" + + "\u0001\u0000\u0000\u0000\u093b\u0939\u0001\u0000\u0000\u0000\u093b\u093a" + + "\u0001\u0000\u0000\u0000\u093c\u017d\u0001\u0000\u0000\u0000\u093d\u093e" + + "\u0007\u000f\u0000\u0000\u093e\u017f\u0001\u0000\u0000\u0000\u093f\u0944" + + "\u0003\u0182\u00c1\u0000\u0940\u0944\u0003\u0184\u00c2\u0000\u0941\u0944" + + "\u0005y\u0000\u0000\u0942\u0944\u0005z\u0000\u0000\u0943\u093f\u0001\u0000" + + "\u0000\u0000\u0943\u0940\u0001\u0000\u0000\u0000\u0943\u0941\u0001\u0000" + + "\u0000\u0000\u0943\u0942\u0001\u0000\u0000\u0000\u0944\u0181\u0001\u0000" + + "\u0000\u0000\u0945\u0949\u0005{\u0000\u0000\u0946\u0948\u0003\u0186\u00c3" + + "\u0000\u0947\u0946\u0001\u0000\u0000\u0000\u0948\u094b\u0001\u0000\u0000" + + "\u0000\u0949\u0947\u0001\u0000\u0000\u0000\u0949\u094a\u0001\u0000\u0000" + + "\u0000\u094a\u094c\u0001\u0000\u0000\u0000\u094b\u0949\u0001\u0000\u0000" + + "\u0000\u094c\u094d\u0005\u00b0\u0000\u0000\u094d\u0183\u0001\u0000\u0000" + + "\u0000\u094e\u0952\u0005|\u0000\u0000\u094f\u0951\u0003\u0188\u00c4\u0000" + + "\u0950\u094f\u0001\u0000\u0000\u0000\u0951\u0954\u0001\u0000\u0000\u0000" + + "\u0952\u0950\u0001\u0000\u0000\u0000\u0952\u0953\u0001\u0000\u0000\u0000" + + "\u0953\u0955\u0001\u0000\u0000\u0000\u0954\u0952\u0001\u0000\u0000\u0000" + + "\u0955\u0956\u0005\u00b0\u0000\u0000\u0956\u0185\u0001"; + private static final String _serializedATNSegment1 = + "\u0000\u0000\u0000\u0957\u095c\u0003\u018a\u00c5\u0000\u0958\u095c\u0005" + + "\u00ac\u0000\u0000\u0959\u095c\u0005\u00ae\u0000\u0000\u095a\u095c\u0005" + + "\u00b1\u0000\u0000\u095b\u0957\u0001\u0000\u0000\u0000\u095b\u0958\u0001" + + "\u0000\u0000\u0000\u095b\u0959\u0001\u0000\u0000\u0000\u095b\u095a\u0001" + + "\u0000\u0000\u0000\u095c\u0187\u0001\u0000\u0000\u0000\u095d\u0962\u0003" + + "\u018a\u00c5\u0000\u095e\u0962\u0005\u00ac\u0000\u0000\u095f\u0962\u0005" + + "\u00af\u0000\u0000\u0960\u0962\u0005\u00b2\u0000\u0000\u0961\u095d\u0001" + + "\u0000\u0000\u0000\u0961\u095e\u0001\u0000\u0000\u0000\u0961\u095f\u0001" + + "\u0000\u0000\u0000\u0961\u0960\u0001\u0000\u0000\u0000\u0962\u0189\u0001" + + "\u0000\u0000\u0000\u0963\u0968\u0003\u001c\u000e\u0000\u0964\u0965\u0005" + + "\u0084\u0000\u0000\u0965\u0967\u0003\u001c\u000e\u0000\u0966\u0964\u0001" + + "\u0000\u0000\u0000\u0967\u096a\u0001\u0000\u0000\u0000\u0968\u0966\u0001" + + "\u0000\u0000\u0000\u0968\u0969\u0001\u0000\u0000\u0000\u0969\u0971\u0001" + + "\u0000\u0000\u0000\u096a\u0968\u0001\u0000\u0000\u0000\u096b\u096d\u0005" + + "\u0085\u0000\u0000\u096c\u096e\u0005\u00b4\u0000\u0000\u096d\u096c\u0001" + + "\u0000\u0000\u0000\u096e\u096f\u0001\u0000\u0000\u0000\u096f\u096d\u0001" + + "\u0000\u0000\u0000\u096f\u0970\u0001\u0000\u0000\u0000\u0970\u0972\u0001" + + "\u0000\u0000\u0000\u0971\u096b\u0001\u0000\u0000\u0000\u0971\u0972\u0001" + + "\u0000\u0000\u0000\u0972\u018b\u0001\u0000\u0000\u0000\u0973\u0974\u0007" + + "\u0010\u0000\u0000\u0974\u018d\u0001\u0000\u0000\u0000\u0975\u0976\u0005" + + "\u001a\u0000\u0000\u0976\u0978\u0003\u01b2\u00d9\u0000\u0977\u0979\u0003" + + "\u00e6s\u0000\u0978\u0977\u0001\u0000\u0000\u0000\u0978\u0979\u0001\u0000" + + "\u0000\u0000\u0979\u097b\u0001\u0000\u0000\u0000\u097a\u097c\u0003\u00ea" + + "u\u0000\u097b\u097a\u0001\u0000\u0000\u0000\u097b\u097c\u0001\u0000\u0000" + + "\u0000\u097c\u097e\u0001\u0000\u0000\u0000\u097d\u097f\u0003\u00eew\u0000" + + "\u097e\u097d\u0001\u0000\u0000\u0000\u097e\u097f\u0001\u0000\u0000\u0000" + + "\u097f\u0980\u0001\u0000\u0000\u0000\u0980\u0982\u0003\u00fa}\u0000\u0981" + + "\u0983\u0005\u0086\u0000\u0000\u0982\u0981\u0001\u0000\u0000\u0000\u0982" + + "\u0983\u0001\u0000\u0000\u0000\u0983\u018f\u0001\u0000\u0000\u0000\u0984" + + "\u0986\u0007\u0011\u0000\u0000\u0985\u0984\u0001\u0000\u0000\u0000\u0985" + + "\u0986\u0001\u0000\u0000\u0000\u0986\u0987\u0001\u0000\u0000\u0000\u0987" + + "\u0988\u0005\\\u0000\u0000\u0988\u098a\u0003\u01b2\u00d9\u0000\u0989\u098b" + + "\u0003\u00e6s\u0000\u098a\u0989\u0001\u0000\u0000\u0000\u098a\u098b\u0001" + + "\u0000\u0000\u0000\u098b\u098d\u0001\u0000\u0000\u0000\u098c\u098e\u0003" + + "\u013a\u009d\u0000\u098d\u098c\u0001\u0000\u0000\u0000\u098d\u098e\u0001" + + "\u0000\u0000\u0000\u098e\u0990\u0001\u0000\u0000\u0000\u098f\u0991\u0003" + + "\u00eew\u0000\u0990\u098f\u0001\u0000\u0000\u0000\u0990\u0991\u0001\u0000" + + "\u0000\u0000\u0991\u0992\u0001\u0000\u0000\u0000\u0992\u0994\u0003\u013c" + + "\u009e\u0000\u0993\u0995\u0005\u0086\u0000\u0000\u0994\u0993\u0001\u0000" + + "\u0000\u0000\u0994\u0995\u0001\u0000\u0000\u0000\u0995\u0191\u0001\u0000" + + "\u0000\u0000\u0996\u0997\u00058\u0000\u0000\u0997\u0999\u0003\u01b2\u00d9" + + "\u0000\u0998\u099a\u0003\u0146\u00a3\u0000\u0999\u0998\u0001\u0000\u0000" + + "\u0000\u0999\u099a\u0001\u0000\u0000\u0000\u099a\u099c\u0001\u0000\u0000" + + "\u0000\u099b\u099d\u0003\u014c\u00a6\u0000\u099c\u099b\u0001\u0000\u0000" + + "\u0000\u099c\u099d\u0001\u0000\u0000\u0000\u099d\u099f\u0001\u0000\u0000" + + "\u0000\u099e\u09a0\u0003\u00eew\u0000\u099f\u099e\u0001\u0000\u0000\u0000" + + "\u099f\u09a0\u0001\u0000\u0000\u0000\u09a0\u09a1\u0001\u0000\u0000\u0000" + + "\u09a1\u09a3\u0003\u00fa}\u0000\u09a2\u09a4\u0005\u0086\u0000\u0000\u09a3" + + "\u09a2\u0001\u0000\u0000\u0000\u09a3\u09a4\u0001\u0000\u0000\u0000\u09a4" + + "\u0193\u0001\u0000\u0000\u0000\u09a5\u09a6\u0005%\u0000\u0000\u09a6\u09a8" + + "\u0003\u01b2\u00d9\u0000\u09a7\u09a9\u0003\u0154\u00aa\u0000\u09a8\u09a7" + + "\u0001\u0000\u0000\u0000\u09a8\u09a9\u0001\u0000\u0000\u0000\u09a9\u09aa" + + "\u0001\u0000\u0000\u0000\u09aa\u09ac\u0003\u0156\u00ab\u0000\u09ab\u09ad" + + "\u0005\u0086\u0000\u0000\u09ac\u09ab\u0001\u0000\u0000\u0000\u09ac\u09ad" + + "\u0001\u0000\u0000\u0000\u09ad\u0195\u0001\u0000\u0000\u0000\u09ae\u09af" + + "\u0005\u001f\u0000\u0000\u09af\u09b0\u0003\u0112\u0089\u0000\u09b0\u09b2" + + "\u0003\u01b2\u00d9\u0000\u09b1\u09b3\u0003\u0146\u00a3\u0000\u09b2\u09b1" + + "\u0001\u0000\u0000\u0000\u09b2\u09b3\u0001\u0000\u0000\u0000\u09b3\u09b4" + + "\u0001\u0000\u0000\u0000\u09b4\u09b6\u0005\u0081\u0000\u0000\u09b5\u09b7" + + "\u0003\u0118\u008c\u0000\u09b6\u09b5\u0001\u0000\u0000\u0000\u09b6\u09b7" + + "\u0001\u0000\u0000\u0000\u09b7\u09b8\u0001\u0000\u0000\u0000\u09b8\u09ba" + + "\u0005\u0082\u0000\u0000\u09b9\u09bb\u0003\u00eew\u0000\u09ba\u09b9\u0001" + + "\u0000\u0000\u0000\u09ba\u09bb\u0001\u0000\u0000\u0000\u09bb\u09bc\u0001" + + "\u0000\u0000\u0000\u09bc\u09bd\u0005\u0086\u0000\u0000\u09bd\u0197\u0001" + + "\u0000\u0000\u0000\u09be\u09bf\u0005\'\u0000\u0000\u09bf\u09c8\u0003\u0004" + + "\u0002\u0000\u09c0\u09c1\u0003\u010c\u0086\u0000\u09c1\u09c2\u0005\u0086" + + "\u0000\u0000\u09c2\u09c9\u0001\u0000\u0000\u0000\u09c3\u09c4\u0003\u0114" + + "\u008a\u0000\u09c4\u09c5\u0005}\u0000\u0000\u09c5\u09c6\u0003\u012c\u0096" + + "\u0000\u09c6\u09c7\u0005~\u0000\u0000\u09c7\u09c9\u0001\u0000\u0000\u0000" + + "\u09c8\u09c0\u0001\u0000\u0000\u0000\u09c8\u09c3\u0001\u0000\u0000\u0000" + + "\u09c9\u0199\u0001\u0000\u0000\u0000\u09ca\u09cb\u0003\u010c\u0086\u0000" + + "\u09cb\u09cc\u0005\u0086\u0000\u0000\u09cc\u019b\u0001\u0000\u0000\u0000" + + "\u09cd\u09db\u0003\u0114\u008a\u0000\u09ce\u09cf\u0005}\u0000\u0000\u09cf" + + "\u09d0\u0003\u0122\u0091\u0000\u09d0\u09d5\u0005~\u0000\u0000\u09d1\u09d2" + + "\u0005\u0091\u0000\u0000\u09d2\u09d3\u0003\u0110\u0088\u0000\u09d3\u09d4" + + "\u0005\u0086\u0000\u0000\u09d4\u09d6\u0001\u0000\u0000\u0000\u09d5\u09d1" + + "\u0001\u0000\u0000\u0000\u09d5\u09d6\u0001\u0000\u0000\u0000\u09d6\u09dc" + + "\u0001\u0000\u0000\u0000\u09d7\u09d8\u0003\u0176\u00bb\u0000\u09d8\u09d9" + + "\u0003J%\u0000\u09d9\u09da\u0005\u0086\u0000\u0000\u09da\u09dc\u0001\u0000" + + "\u0000\u0000\u09db\u09ce\u0001\u0000\u0000\u0000\u09db\u09d7\u0001\u0000" + + "\u0000\u0000\u09dc\u019d\u0001\u0000\u0000\u0000\u09dd\u09de\u0005\u001b" + + "\u0000\u0000\u09de\u09df\u0003\u0004\u0002\u0000\u09df\u09e0\u0003\u0108" + + "\u0084\u0000\u09e0\u09e1\u0005\u0086\u0000\u0000\u09e1\u019f\u0001\u0000" + + "\u0000\u0000\u09e2\u09e3\u0005^\u0000\u0000\u09e3\u09e4\u0005\u007f\u0000" + + "\u0000\u09e4\u09e5\u0003\u0118\u008c\u0000\u09e5\u09ee\u0005\u0080\u0000" + + "\u0000\u09e6\u09e7\u0005}\u0000\u0000\u09e7\u09e8\u0003\u0122\u0091\u0000" + + "\u09e8\u09e9\u0005~\u0000\u0000\u09e9\u09ef\u0001\u0000\u0000\u0000\u09ea" + + "\u09eb\u0003\u0176\u00bb\u0000\u09eb\u09ec\u0003J%\u0000\u09ec\u09ed\u0005" + + "\u0086\u0000\u0000\u09ed\u09ef\u0001\u0000\u0000\u0000\u09ee\u09e6\u0001" + + "\u0000\u0000\u0000\u09ee\u09ea\u0001\u0000\u0000\u0000\u09ef\u01a1\u0001" + + "\u0000\u0000\u0000\u09f0\u09f1\u0005\u0090\u0000\u0000\u09f1\u09f2\u0003" + + "\u01b2\u00d9\u0000\u09f2\u09f3\u0005\u0081\u0000\u0000\u09f3\u09f4\u0005" + + "\u0082\u0000\u0000\u09f4\u09f5\u0003\u0138\u009c\u0000\u09f5\u01a3\u0001" + + "\u0000\u0000\u0000\u09f6\u09f7\u0003\u01b2\u00d9\u0000\u09f7\u09f9\u0005" + + "\u0081\u0000\u0000\u09f8\u09fa\u0003\u0118\u008c\u0000\u09f9\u09f8\u0001" + + "\u0000\u0000\u0000\u09f9\u09fa\u0001\u0000\u0000\u0000\u09fa\u09fb\u0001" + + "\u0000\u0000\u0000\u09fb\u09fd\u0005\u0082\u0000\u0000\u09fc\u09fe\u0003" + + "\u0136\u009b\u0000\u09fd\u09fc\u0001\u0000\u0000\u0000\u09fd\u09fe\u0001" + + "\u0000\u0000\u0000\u09fe\u09ff\u0001\u0000\u0000\u0000\u09ff\u0a00\u0003" + + "\u0138\u009c\u0000\u0a00\u01a5\u0001\u0000\u0000\u0000\u0a01\u0a03\u0003" + + "\u01a8\u00d4\u0000\u0a02\u0a04\u0003\u00e6s\u0000\u0a03\u0a02\u0001\u0000" + + "\u0000\u0000\u0a03\u0a04\u0001\u0000\u0000\u0000\u0a04\u0a05\u0001\u0000" + + "\u0000\u0000\u0a05\u0a07\u0005\u0081\u0000\u0000\u0a06\u0a08\u0003\u0118" + + "\u008c\u0000\u0a07\u0a06\u0001\u0000\u0000\u0000\u0a07\u0a08\u0001\u0000" + + "\u0000\u0000\u0a08\u0a09\u0001\u0000\u0000\u0000\u0a09\u0a0b\u0005\u0082" + + "\u0000\u0000\u0a0a\u0a0c\u0003\u00eew\u0000\u0a0b\u0a0a\u0001\u0000\u0000" + + "\u0000\u0a0b\u0a0c\u0001\u0000\u0000\u0000\u0a0c\u0a12\u0001\u0000\u0000" + + "\u0000\u0a0d\u0a13\u0003\u0116\u008b\u0000\u0a0e\u0a0f\u0003\u0176\u00bb" + + "\u0000\u0a0f\u0a10\u0003J%\u0000\u0a10\u0a11\u0005\u0086\u0000\u0000\u0a11" + + "\u0a13\u0001\u0000\u0000\u0000\u0a12\u0a0d\u0001\u0000\u0000\u0000\u0a12" + + "\u0a0e\u0001\u0000\u0000\u0000\u0a13\u01a7\u0001\u0000\u0000\u0000\u0a14" + + "\u0a1a\u0003\u01b2\u00d9\u0000\u0a15\u0a16\u0003\u01b2\u00d9\u0000\u0a16" + + "\u0a17\u0005\u0095\u0000\u0000\u0a17\u0a18\u0003\u01b2\u00d9\u0000\u0a18" + + "\u0a1a\u0001\u0000\u0000\u0000\u0a19\u0a14\u0001\u0000\u0000\u0000\u0a19" + + "\u0a15\u0001\u0000\u0000\u0000\u0a1a\u0a22\u0001\u0000\u0000\u0000\u0a1b" + + "\u0a1d\u0003\u0016\u000b\u0000\u0a1c\u0a1b\u0001\u0000\u0000\u0000\u0a1c" + + "\u0a1d\u0001\u0000\u0000\u0000\u0a1d\u0a1e\u0001\u0000\u0000\u0000\u0a1e" + + "\u0a1f\u0005\u0083\u0000\u0000\u0a1f\u0a21\u0003\u01b2\u00d9\u0000\u0a20" + + "\u0a1c\u0001\u0000\u0000\u0000\u0a21\u0a24\u0001\u0000\u0000\u0000\u0a22" + + "\u0a20\u0001\u0000\u0000\u0000\u0a22\u0a23\u0001\u0000\u0000\u0000\u0a23" + + "\u01a9\u0001\u0000\u0000\u0000\u0a24\u0a22\u0001\u0000\u0000\u0000\u0a25" + + "\u0a26\u0005F\u0000\u0000\u0a26\u0a27\u0003\u0132\u0099\u0000\u0a27\u0a29" + + "\u0005\u0081\u0000\u0000\u0a28\u0a2a\u00056\u0000\u0000\u0a29\u0a28\u0001" + + "\u0000\u0000\u0000\u0a29\u0a2a\u0001\u0000\u0000\u0000\u0a2a\u0a2b\u0001" + + "\u0000\u0000\u0000\u0a2b\u0a31\u0003\u01ac\u00d6\u0000\u0a2c\u0a2e\u0005" + + "\u0084\u0000\u0000\u0a2d\u0a2f\u00056\u0000\u0000\u0a2e\u0a2d\u0001\u0000" + + "\u0000\u0000\u0a2e\u0a2f\u0001\u0000\u0000\u0000\u0a2f\u0a30\u0001\u0000" + + "\u0000\u0000\u0a30\u0a32\u0003\u01ac\u00d6\u0000\u0a31\u0a2c\u0001\u0000" + + "\u0000\u0000\u0a31\u0a32\u0001\u0000\u0000\u0000\u0a32\u0a33\u0001\u0000" + + "\u0000\u0000\u0a33\u0a39\u0005\u0082\u0000\u0000\u0a34\u0a3a\u0003\u0138" + + "\u009c\u0000\u0a35\u0a36\u0003\u0176\u00bb\u0000\u0a36\u0a37\u0003J%\u0000" + + "\u0a37\u0a38\u0005\u0086\u0000\u0000\u0a38\u0a3a\u0001\u0000\u0000\u0000" + + "\u0a39\u0a34\u0001\u0000\u0000\u0000\u0a39\u0a35\u0001\u0000\u0000\u0000" + + "\u0a3a\u01ab\u0001\u0000\u0000\u0000\u0a3b\u0a3c\u0003\u0004\u0002\u0000" + + "\u0a3c\u0a3f\u0003\u01b2\u00d9\u0000\u0a3d\u0a3e\u0005\u0091\u0000\u0000" + + "\u0a3e\u0a40\u0003\u001c\u000e\u0000\u0a3f\u0a3d\u0001\u0000\u0000\u0000" + + "\u0a3f\u0a40\u0001\u0000\u0000\u0000\u0a40\u01ad\u0001\u0000\u0000\u0000" + + "\u0a41\u0a43\u0005\u0081\u0000\u0000\u0a42\u0a44\u0003\u0018\f\u0000\u0a43" + + "\u0a42\u0001\u0000\u0000\u0000\u0a43\u0a44\u0001\u0000\u0000\u0000\u0a44" + + "\u0a45\u0001\u0000\u0000\u0000\u0a45\u0a46\u0005\u0082\u0000\u0000\u0a46" + + "\u01af\u0001\u0000\u0000\u0000\u0a47\u0a49\u0005\u0081\u0000\u0000\u0a48" + + "\u0a4a\u0003\u0018\f\u0000\u0a49\u0a48\u0001\u0000\u0000\u0000\u0a49\u0a4a" + + "\u0001\u0000\u0000\u0000\u0a4a\u0a4b\u0001\u0000\u0000\u0000\u0a4b\u0a4d" + + "\u0005\u0082\u0000\u0000\u0a4c\u0a4e\u0003X,\u0000\u0a4d\u0a4c\u0001\u0000" + + "\u0000\u0000\u0a4d\u0a4e\u0001\u0000\u0000\u0000\u0a4e\u01b1\u0001\u0000" + + "\u0000\u0000\u0a4f\u0a50\u0007\u0012\u0000\u0000\u0a50\u01b3\u0001\u0000" + + "\u0000\u0000\u0158\u01b5\u01b8\u01bb\u01c0\u01c4\u01ca\u01cd\u01d2\u01d6" + + "\u01dd\u01df\u01e7\u01ef\u01f5\u01f9\u01fe\u0208\u0210\u021a\u0220\u0223" + + "\u0227\u022f\u0234\u023e\u024b\u0253\u0259\u025b\u0262\u026a\u0272\u027a" + + "\u0282\u028a\u0294\u0296\u029c\u02a1\u02a9\u02b1\u02b9\u02bb\u02be\u02c5" + + "\u02ca\u02d1\u02d5\u02d7\u02f3\u02f7\u02fc\u0300\u0308\u030b\u0310\u0314" + + "\u0318\u031e\u032c\u0332\u033e\u0342\u0347\u034b\u0351\u0359\u0362\u0374" + + "\u0377\u037c\u037f\u038e\u0394\u0398\u039e\u03a3\u03a6\u03ae\u03b6\u03c1" + + "\u03c6\u03cb\u03cd\u03d6\u03de\u03e5\u03ed\u03f1\u03fa\u03ff\u0401\u040a" + + "\u0412\u0416\u041b\u041d\u0422\u0426\u042d\u0435\u0437\u043b\u043e\u0441" + + "\u0449\u0453\u0464\u046b\u046f\u0479\u047e\u0485\u048e\u0493\u049a\u04a6" + + "\u04b1\u04b9\u04be\u04c7\u04d0\u04d9\u04df\u04e4\u04e8\u04ec\u04f0\u04f4" + + "\u04fb\u0503\u0510\u051a\u0530\u0534\u0538\u053d\u0551\u0556\u055b\u0562" + + "\u0565\u057b\u0587\u058b\u0593\u059b\u05a2\u05a6\u05ab\u05ae\u05b3\u05bb" + + "\u05c0\u05c7\u05cd\u05d5\u05dd\u05e0\u05e7\u05ee\u05f2\u05f5\u05fb\u05ff" + + "\u0605\u0613\u0619\u0620\u0625\u0628\u062b\u0632\u063c\u064d\u0652\u0656" + + "\u0659\u065c\u0663\u0669\u0671\u0677\u0681\u0689\u068f\u069a\u069e\u06a0" + + "\u06a5\u06a9\u06b0\u06b9\u06c0\u06c3\u06c6\u06ca\u06cf\u06dc\u06e6\u06ed" + + "\u06f9\u0700\u070c\u0712\u0716\u071a\u0720\u0726\u0728\u072f\u0733\u0736" + + "\u073a\u0744\u0747\u074e\u0751\u0756\u075b\u075d\u0760\u0763\u0769\u076c" + + "\u0778\u077c\u077f\u0789\u078c\u0792\u07ad\u07ba\u07c0\u07c9\u07cf\u07d2" + + "\u07da\u07de\u07e4\u07ea\u07f0\u07fb\u07ff\u0801\u080b\u0811\u0814\u0821" + + "\u0827\u082a\u082d\u0834\u0839\u083d\u0841\u0852\u0855\u085a\u085e\u0862" + + "\u086b\u086e\u0873\u0877\u087c\u0880\u0882\u088d\u0891\u0893\u0898\u089d" + + "\u08a4\u08aa\u08af\u08b5\u08b9\u08bf\u08c6\u08d0\u08d3\u08d6\u08db\u08e1" + + "\u08e5\u08e7\u08ee\u08f5\u08fd\u0901\u0910\u0914\u091d\u0921\u0925\u093b" + + "\u0943\u0949\u0952\u095b\u0961\u0968\u096f\u0971\u0978\u097b\u097e\u0982" + + "\u0985\u098a\u098d\u0990\u0994\u0999\u099c\u099f\u09a3\u09a8\u09ac\u09b2" + + "\u09b6\u09ba\u09c8\u09d5\u09db\u09ee\u09f9\u09fd\u0a03\u0a07\u0a0b\u0a12" + + "\u0a19\u0a1c\u0a22\u0a29\u0a2e\u0a31\u0a39\u0a3f\u0a43\u0a49\u0a4d"; + public static final String _serializedATN = Utils.join( + new String[]{ + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.tokens b/src/main/java/CSharpParser.tokens similarity index 100% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.tokens rename to src/main/java/CSharpParser.tokens diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserBaseListener.java b/src/main/java/CSharpParserBaseListener.java similarity index 99% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserBaseListener.java rename to src/main/java/CSharpParserBaseListener.java index 3bd0282..932bbbf 100644 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserBaseListener.java +++ b/src/main/java/CSharpParserBaseListener.java @@ -1,4 +1,4 @@ -package jp.ac.osaka_u.sdl.nil.parser.cs;// Generated from CSharpParser.g4 by ANTLR 4.9 +// Generated from CSharpParser.g4 by ANTLR 4.13.2 import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.ErrorNode; @@ -9,6 +9,7 @@ * which can be extended to create a listener which only needs to handle a subset * of the available methods. */ +@SuppressWarnings("CheckReturnValue") public class CSharpParserBaseListener implements CSharpParserListener { /** * {@inheritDoc} diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserListener.java b/src/main/java/CSharpParserListener.java similarity index 99% rename from src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserListener.java rename to src/main/java/CSharpParserListener.java index df2e583..50eb739 100644 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParserListener.java +++ b/src/main/java/CSharpParserListener.java @@ -1,4 +1,4 @@ -package jp.ac.osaka_u.sdl.nil.parser.cs;// Generated from CSharpParser.g4 by ANTLR 4.9 +// Generated from CSharpParser.g4 by ANTLR 4.13.2 import org.antlr.v4.runtime.tree.ParseTreeListener; diff --git a/src/main/java/KotlinLexer.interp b/src/main/java/KotlinLexer.interp new file mode 100644 index 0000000..e387cb5 --- /dev/null +++ b/src/main/java/KotlinLexer.interp @@ -0,0 +1,721 @@ +token literal names: +null +null +null +null +null +null +'...' +'.' +',' +'(' +null +'[' +null +'{' +'}' +'*' +'%' +'/' +'+' +'-' +'++' +'--' +'&&' +'||' +'!' +':' +';' +'=' +'+=' +'-=' +'*=' +'/=' +'%=' +'->' +'=>' +'..' +'::' +'?::' +';;' +'#' +'@' +'?' +'?:' +'<' +'>' +'<=' +'>=' +'!=' +'!==' +'as?' +'==' +'===' +'\'' +null +null +null +'@file' +'package' +'import' +'class' +'interface' +'fun' +'object' +'val' +'var' +'typealias' +'constructor' +'by' +'companion' +'init' +'this' +'super' +'typeof' +'where' +'if' +'else' +'when' +'try' +'catch' +'finally' +'for' +'do' +'while' +'throw' +'return' +'continue' +'break' +'as' +'is' +'in' +null +null +'out' +'@field' +'@property' +'@get' +'@set' +'get' +'set' +'@receiver' +'@param' +'@setparam' +'@delegate' +'dynamic' +'public' +'private' +'protected' +'internal' +'enum' +'sealed' +'annotation' +'data' +'inner' +'tailrec' +'operator' +'inline' +'infix' +'external' +'suspend' +'override' +'abstract' +'final' +'open' +'const' +'lateinit' +'vararg' +'noinline' +'crossinline' +'reified' +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 + +token symbolic names: +null +ShebangLine +DelimitedComment +LineComment +WS +NL +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +Q_COLONCOLON +DOUBLE_SEMICOLON +HASH +AT +QUEST +ELVIS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +RETURN_AT +CONTINUE_AT +BREAK_AT +FILE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +FIELD +PROPERTY +GET +SET +GETTER +SETTER +RECEIVER +PARAM +SETPARAM +DELEGATE +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +RealLiteral +FloatLiteral +DoubleLiteral +LongLiteral +IntegerLiteral +HexLiteral +BinLiteral +BooleanLiteral +NullLiteral +Identifier +LabelReference +LabelDefinition +FieldIdentifier +CharacterLiteral +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +Inside_Comment +Inside_WS +Inside_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrEscapedChar +MultiLineStrExprStart +MultiLineNL +StrExpr_IN +StrExpr_Comment +StrExpr_WS +StrExpr_NL + +rule names: +ShebangLine +DelimitedComment +LineComment +WS +NL +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +Q_COLONCOLON +DOUBLE_SEMICOLON +HASH +AT +QUEST +ELVIS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +RETURN_AT +CONTINUE_AT +BREAK_AT +FILE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +FIELD +PROPERTY +GET +SET +GETTER +SETTER +RECEIVER +PARAM +SETPARAM +DELEGATE +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +RealLiteral +FloatLiteral +DoubleLiteral +LongLiteral +IntegerLiteral +DecDigit +DecDigitNoZero +UNICODE_CLASS_ND_NoZeros +HexLiteral +HexDigit +BinLiteral +BinDigit +BooleanLiteral +NullLiteral +Identifier +LabelReference +LabelDefinition +FieldIdentifier +CharacterLiteral +EscapeSeq +UniCharacterLiteral +EscapedIdentifier +Letter +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +Inside_RPAREN +Inside_RSQUARE +Inside_LPAREN +Inside_LSQUARE +Inside_LCURL +Inside_RCURL +Inside_DOT +Inside_COMMA +Inside_MULT +Inside_MOD +Inside_DIV +Inside_ADD +Inside_SUB +Inside_INCR +Inside_DECR +Inside_CONJ +Inside_DISJ +Inside_EXCL +Inside_COLON +Inside_SEMICOLON +Inside_ASSIGNMENT +Inside_ADD_ASSIGNMENT +Inside_SUB_ASSIGNMENT +Inside_MULT_ASSIGNMENT +Inside_DIV_ASSIGNMENT +Inside_MOD_ASSIGNMENT +Inside_ARROW +Inside_DOUBLE_ARROW +Inside_RANGE +Inside_RESERVED +Inside_COLONCOLON +Inside_Q_COLONCOLON +Inside_DOUBLE_SEMICOLON +Inside_HASH +Inside_AT +Inside_QUEST +Inside_ELVIS +Inside_LANGLE +Inside_RANGLE +Inside_LE +Inside_GE +Inside_EXCL_EQ +Inside_EXCL_EQEQ +Inside_NOT_IS +Inside_NOT_IN +Inside_AS_SAFE +Inside_EQEQ +Inside_EQEQEQ +Inside_SINGLE_QUOTE +Inside_QUOTE_OPEN +Inside_TRIPLE_QUOTE_OPEN +Inside_VAL +Inside_VAR +Inside_OBJECT +Inside_SUPER +Inside_IN +Inside_OUT +Inside_FIELD +Inside_FILE +Inside_PROPERTY +Inside_GET +Inside_SET +Inside_RECEIVER +Inside_PARAM +Inside_SETPARAM +Inside_DELEGATE +Inside_THROW +Inside_RETURN +Inside_CONTINUE +Inside_BREAK +Inside_RETURN_AT +Inside_CONTINUE_AT +Inside_BREAK_AT +Inside_IF +Inside_ELSE +Inside_WHEN +Inside_TRY +Inside_CATCH +Inside_FINALLY +Inside_FOR +Inside_DO +Inside_WHILE +Inside_PUBLIC +Inside_PRIVATE +Inside_PROTECTED +Inside_INTERNAL +Inside_ENUM +Inside_SEALED +Inside_ANNOTATION +Inside_DATA +Inside_INNER +Inside_TAILREC +Inside_OPERATOR +Inside_INLINE +Inside_INFIX +Inside_EXTERNAL +Inside_SUSPEND +Inside_OVERRIDE +Inside_ABSTRACT +Inside_FINAL +Inside_OPEN +Inside_CONST +Inside_LATEINIT +Inside_VARARG +Inside_NOINLINE +Inside_CROSSINLINE +Inside_REIFIED +Inside_BooleanLiteral +Inside_IntegerLiteral +Inside_HexLiteral +Inside_BinLiteral +Inside_CharacterLiteral +Inside_RealLiteral +Inside_NullLiteral +Inside_LongLiteral +Inside_Identifier +Inside_LabelReference +Inside_LabelDefinition +Inside_Comment +Inside_WS +Inside_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrEscapedChar +MultiLineStrExprStart +MultiLineNL +StrExpr_RCURL +StrExpr_LPAREN +StrExpr_LSQUARE +StrExpr_RPAREN +StrExpr_RSQUARE +StrExpr_LCURL +StrExpr_DOT +StrExpr_COMMA +StrExpr_MULT +StrExpr_MOD +StrExpr_DIV +StrExpr_ADD +StrExpr_SUB +StrExpr_INCR +StrExpr_DECR +StrExpr_CONJ +StrExpr_DISJ +StrExpr_EXCL +StrExpr_COLON +StrExpr_SEMICOLON +StrExpr_ASSIGNMENT +StrExpr_ADD_ASSIGNMENT +StrExpr_SUB_ASSIGNMENT +StrExpr_MULT_ASSIGNMENT +StrExpr_DIV_ASSIGNMENT +StrExpr_MOD_ASSIGNMENT +StrExpr_ARROW +StrExpr_DOUBLE_ARROW +StrExpr_RANGE +StrExpr_COLONCOLON +StrExpr_Q_COLONCOLON +StrExpr_DOUBLE_SEMICOLON +StrExpr_HASH +StrExpr_AT +StrExpr_QUEST +StrExpr_ELVIS +StrExpr_LANGLE +StrExpr_RANGLE +StrExpr_LE +StrExpr_GE +StrExpr_EXCL_EQ +StrExpr_EXCL_EQEQ +StrExpr_AS +StrExpr_IS +StrExpr_IN +StrExpr_NOT_IS +StrExpr_NOT_IN +StrExpr_AS_SAFE +StrExpr_EQEQ +StrExpr_EQEQEQ +StrExpr_SINGLE_QUOTE +StrExpr_QUOTE_OPEN +StrExpr_TRIPLE_QUOTE_OPEN +StrExpr_BooleanLiteral +StrExpr_IntegerLiteral +StrExpr_HexLiteral +StrExpr_BinLiteral +StrExpr_CharacterLiteral +StrExpr_RealLiteral +StrExpr_NullLiteral +StrExpr_LongLiteral +StrExpr_Identifier +StrExpr_LabelReference +StrExpr_LabelDefinition +StrExpr_Comment +StrExpr_WS +StrExpr_NL + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +Inside +LineString +MultiLineString +StringExpression + +atn: +[4, 0, 170, 2606, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 730, 8, 0, 10, 0, 12, 0, 733, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 742, 8, 1, 10, 1, 12, 1, 745, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 756, 8, 2, 10, 2, 12, 2, 759, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 3, 4, 770, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 4, 89, 1137, 8, 89, 11, 89, 12, 89, 1138, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 4, 90, 1147, 8, 90, 11, 90, 12, 90, 1148, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 3, 130, 1442, 8, 130, 1, 131, 1, 131, 3, 131, 1446, 8, 131, 1, 131, 1, 131, 1, 132, 1, 132, 5, 132, 1452, 8, 132, 10, 132, 12, 132, 1455, 9, 132, 1, 132, 3, 132, 1458, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1464, 8, 132, 10, 132, 12, 132, 1467, 9, 132, 1, 132, 1, 132, 3, 132, 1471, 8, 132, 1, 132, 3, 132, 1474, 8, 132, 1, 132, 4, 132, 1477, 8, 132, 11, 132, 12, 132, 1478, 1, 132, 1, 132, 1, 132, 4, 132, 1484, 8, 132, 11, 132, 12, 132, 1485, 1, 132, 1, 132, 1, 132, 4, 132, 1491, 8, 132, 11, 132, 12, 132, 1492, 1, 132, 1, 132, 3, 132, 1497, 8, 132, 1, 132, 4, 132, 1500, 8, 132, 11, 132, 12, 132, 1501, 1, 132, 4, 132, 1505, 8, 132, 11, 132, 12, 132, 1506, 1, 132, 1, 132, 3, 132, 1511, 8, 132, 1, 132, 1, 132, 1, 132, 4, 132, 1516, 8, 132, 11, 132, 12, 132, 1517, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 4, 132, 1525, 8, 132, 11, 132, 12, 132, 1526, 1, 132, 1, 132, 1, 132, 3, 132, 1532, 8, 132, 1, 132, 4, 132, 1535, 8, 132, 11, 132, 12, 132, 1536, 1, 132, 1, 132, 1, 132, 4, 132, 1542, 8, 132, 11, 132, 12, 132, 1543, 1, 132, 1, 132, 1, 132, 3, 132, 1549, 8, 132, 1, 132, 1, 132, 1, 132, 4, 132, 1554, 8, 132, 11, 132, 12, 132, 1555, 1, 132, 1, 132, 3, 132, 1560, 8, 132, 1, 133, 1, 133, 1, 133, 3, 133, 1565, 8, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 5, 134, 1572, 8, 134, 10, 134, 12, 134, 1575, 9, 134, 1, 134, 1, 134, 1, 134, 4, 134, 1580, 8, 134, 11, 134, 12, 134, 1581, 1, 134, 1, 134, 1, 134, 1, 134, 5, 134, 1588, 8, 134, 10, 134, 12, 134, 1591, 9, 134, 1, 134, 1, 134, 3, 134, 1595, 8, 134, 1, 134, 4, 134, 1598, 8, 134, 11, 134, 12, 134, 1599, 1, 134, 1, 134, 5, 134, 1604, 8, 134, 10, 134, 12, 134, 1607, 9, 134, 1, 134, 1, 134, 3, 134, 1611, 8, 134, 1, 134, 1, 134, 1, 134, 4, 134, 1616, 8, 134, 11, 134, 12, 134, 1617, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 4, 134, 1625, 8, 134, 11, 134, 12, 134, 1626, 1, 134, 1, 134, 1, 134, 3, 134, 1632, 8, 134, 1, 134, 4, 134, 1635, 8, 134, 11, 134, 12, 134, 1636, 1, 134, 1, 134, 1, 134, 4, 134, 1642, 8, 134, 11, 134, 12, 134, 1643, 1, 134, 1, 134, 1, 134, 3, 134, 1649, 8, 134, 1, 134, 1, 134, 1, 134, 4, 134, 1654, 8, 134, 11, 134, 12, 134, 1655, 1, 134, 1, 134, 3, 134, 1660, 8, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 5, 138, 1673, 8, 138, 10, 138, 12, 138, 1676, 9, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 1685, 8, 140, 10, 140, 12, 140, 1688, 9, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 1701, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 3, 144, 1710, 8, 144, 1, 144, 1, 144, 1, 144, 5, 144, 1715, 8, 144, 10, 144, 12, 144, 1718, 9, 144, 1, 144, 1, 144, 4, 144, 1722, 8, 144, 11, 144, 12, 144, 1723, 1, 144, 3, 144, 1727, 8, 144, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 1741, 8, 148, 1, 148, 1, 148, 1, 149, 1, 149, 3, 149, 1747, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 1765, 8, 152, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 3, 278, 2261, 8, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 283, 4, 283, 2280, 8, 283, 11, 283, 12, 283, 2281, 1, 283, 3, 283, 2285, 8, 283, 1, 284, 1, 284, 1, 284, 3, 284, 2290, 8, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 3, 286, 2298, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 4, 287, 2307, 8, 287, 11, 287, 12, 287, 2308, 1, 288, 1, 288, 1, 289, 4, 289, 2314, 8, 289, 11, 289, 12, 289, 2315, 1, 289, 3, 289, 2319, 8, 289, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 3, 357, 2595, 8, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 743, 0, 360, 5, 1, 7, 2, 9, 3, 11, 4, 13, 5, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 32, 69, 33, 71, 34, 73, 35, 75, 36, 77, 37, 79, 38, 81, 39, 83, 40, 85, 41, 87, 42, 89, 43, 91, 44, 93, 45, 95, 46, 97, 47, 99, 48, 101, 49, 103, 50, 105, 51, 107, 52, 109, 53, 111, 54, 113, 55, 115, 56, 117, 57, 119, 58, 121, 59, 123, 60, 125, 61, 127, 62, 129, 63, 131, 64, 133, 65, 135, 66, 137, 67, 139, 68, 141, 69, 143, 70, 145, 71, 147, 72, 149, 73, 151, 74, 153, 75, 155, 76, 157, 77, 159, 78, 161, 79, 163, 80, 165, 81, 167, 82, 169, 83, 171, 84, 173, 85, 175, 86, 177, 87, 179, 88, 181, 89, 183, 90, 185, 91, 187, 92, 189, 93, 191, 94, 193, 95, 195, 96, 197, 97, 199, 98, 201, 99, 203, 100, 205, 101, 207, 102, 209, 103, 211, 104, 213, 105, 215, 106, 217, 107, 219, 108, 221, 109, 223, 110, 225, 111, 227, 112, 229, 113, 231, 114, 233, 115, 235, 116, 237, 117, 239, 118, 241, 119, 243, 120, 245, 121, 247, 122, 249, 123, 251, 124, 253, 125, 255, 126, 257, 127, 259, 128, 261, 129, 263, 130, 265, 131, 267, 132, 269, 133, 271, 134, 273, 135, 275, 0, 277, 0, 279, 0, 281, 136, 283, 0, 285, 137, 287, 0, 289, 138, 291, 139, 293, 140, 295, 141, 297, 142, 299, 143, 301, 144, 303, 0, 305, 0, 307, 0, 309, 0, 311, 145, 313, 146, 315, 147, 317, 148, 319, 149, 321, 150, 323, 151, 325, 0, 327, 0, 329, 0, 331, 0, 333, 0, 335, 0, 337, 0, 339, 0, 341, 0, 343, 0, 345, 0, 347, 0, 349, 0, 351, 0, 353, 0, 355, 0, 357, 0, 359, 0, 361, 0, 363, 0, 365, 0, 367, 0, 369, 0, 371, 0, 373, 0, 375, 0, 377, 0, 379, 0, 381, 0, 383, 0, 385, 0, 387, 0, 389, 0, 391, 0, 393, 0, 395, 0, 397, 0, 399, 0, 401, 0, 403, 0, 405, 0, 407, 0, 409, 0, 411, 0, 413, 0, 415, 0, 417, 0, 419, 0, 421, 0, 423, 0, 425, 0, 427, 0, 429, 0, 431, 0, 433, 0, 435, 0, 437, 0, 439, 0, 441, 0, 443, 0, 445, 0, 447, 0, 449, 0, 451, 0, 453, 0, 455, 0, 457, 0, 459, 0, 461, 0, 463, 0, 465, 0, 467, 0, 469, 0, 471, 0, 473, 0, 475, 0, 477, 0, 479, 0, 481, 0, 483, 0, 485, 0, 487, 0, 489, 0, 491, 0, 493, 0, 495, 0, 497, 0, 499, 0, 501, 0, 503, 0, 505, 0, 507, 0, 509, 0, 511, 0, 513, 0, 515, 0, 517, 0, 519, 0, 521, 0, 523, 0, 525, 0, 527, 0, 529, 0, 531, 0, 533, 0, 535, 0, 537, 0, 539, 0, 541, 0, 543, 0, 545, 0, 547, 0, 549, 0, 551, 0, 553, 0, 555, 0, 557, 0, 559, 0, 561, 152, 563, 153, 565, 154, 567, 155, 569, 156, 571, 157, 573, 158, 575, 159, 577, 160, 579, 161, 581, 162, 583, 163, 585, 164, 587, 165, 589, 166, 591, 0, 593, 0, 595, 0, 597, 0, 599, 0, 601, 0, 603, 0, 605, 0, 607, 0, 609, 0, 611, 0, 613, 0, 615, 0, 617, 0, 619, 0, 621, 0, 623, 0, 625, 0, 627, 0, 629, 0, 631, 0, 633, 0, 635, 0, 637, 0, 639, 0, 641, 0, 643, 0, 645, 0, 647, 0, 649, 0, 651, 0, 653, 0, 655, 0, 657, 0, 659, 0, 661, 0, 663, 0, 665, 0, 667, 0, 669, 0, 671, 0, 673, 0, 675, 0, 677, 0, 679, 167, 681, 0, 683, 0, 685, 0, 687, 0, 689, 0, 691, 0, 693, 0, 695, 0, 697, 0, 699, 0, 701, 0, 703, 0, 705, 0, 707, 0, 709, 0, 711, 0, 713, 0, 715, 0, 717, 0, 719, 168, 721, 169, 723, 170, 5, 0, 1, 2, 3, 4, 20, 2, 0, 10, 10, 13, 13, 3, 0, 9, 9, 12, 12, 32, 32, 2, 0, 70, 70, 102, 102, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 37, 0, 49, 57, 1633, 1641, 1777, 1785, 1985, 1993, 2407, 2415, 2535, 2543, 2663, 2671, 2791, 2799, 2919, 2927, 3047, 3055, 3175, 3183, 3303, 3311, 3431, 3439, 3559, 3567, 3665, 3673, 3793, 3801, 3873, 3881, 4161, 4169, 4241, 4249, 6113, 6121, 6161, 6169, 6471, 6479, 6609, 6617, 6785, 6793, 6801, 6809, 6993, 7001, 7089, 7097, 7233, 7241, 7249, 7257, 42529, 42537, 43217, 43225, 43265, 43273, 43473, 43481, 43505, 43513, 43601, 43609, 44017, 44025, 65297, 65305, 2, 0, 88, 88, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 1, 0, 96, 96, 8, 0, 34, 34, 36, 36, 39, 39, 92, 92, 98, 98, 110, 110, 114, 114, 116, 116, 582, 0, 97, 122, 181, 181, 223, 246, 248, 255, 257, 257, 259, 259, 261, 261, 263, 263, 265, 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279, 281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, 295, 297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, 311, 312, 314, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, 326, 328, 329, 331, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, 343, 343, 345, 345, 347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, 357, 359, 359, 361, 361, 363, 363, 365, 365, 367, 367, 369, 369, 371, 371, 373, 373, 375, 375, 378, 378, 380, 380, 382, 384, 387, 387, 389, 389, 392, 392, 396, 397, 402, 402, 405, 405, 409, 411, 414, 414, 417, 417, 419, 419, 421, 421, 424, 424, 426, 427, 429, 429, 432, 432, 436, 436, 438, 438, 441, 442, 445, 447, 454, 454, 457, 457, 460, 460, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 477, 479, 479, 481, 481, 483, 483, 485, 485, 487, 487, 489, 489, 491, 491, 493, 493, 495, 496, 499, 499, 501, 501, 505, 505, 507, 507, 509, 509, 511, 511, 513, 513, 515, 515, 517, 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527, 529, 529, 531, 531, 533, 533, 535, 535, 537, 537, 539, 539, 541, 541, 543, 543, 545, 545, 547, 547, 549, 549, 551, 551, 553, 553, 555, 555, 557, 557, 559, 559, 561, 561, 563, 569, 572, 572, 575, 576, 578, 578, 583, 583, 585, 585, 587, 587, 589, 589, 591, 659, 661, 687, 881, 881, 883, 883, 887, 887, 891, 893, 912, 912, 940, 974, 976, 977, 981, 983, 985, 985, 987, 987, 989, 989, 991, 991, 993, 993, 995, 995, 997, 997, 999, 999, 1001, 1001, 1003, 1003, 1005, 1005, 1007, 1011, 1013, 1013, 1016, 1016, 1019, 1020, 1072, 1119, 1121, 1121, 1123, 1123, 1125, 1125, 1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, 1135, 1135, 1137, 1137, 1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, 1147, 1147, 1149, 1149, 1151, 1151, 1153, 1153, 1163, 1163, 1165, 1165, 1167, 1167, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175, 1177, 1177, 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187, 1189, 1189, 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199, 1201, 1201, 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211, 1213, 1213, 1215, 1215, 1218, 1218, 1220, 1220, 1222, 1222, 1224, 1224, 1226, 1226, 1228, 1228, 1230, 1231, 1233, 1233, 1235, 1235, 1237, 1237, 1239, 1239, 1241, 1241, 1243, 1243, 1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, 1253, 1253, 1255, 1255, 1257, 1257, 1259, 1259, 1261, 1261, 1263, 1263, 1265, 1265, 1267, 1267, 1269, 1269, 1271, 1271, 1273, 1273, 1275, 1275, 1277, 1277, 1279, 1279, 1281, 1281, 1283, 1283, 1285, 1285, 1287, 1287, 1289, 1289, 1291, 1291, 1293, 1293, 1295, 1295, 1297, 1297, 1299, 1299, 1301, 1301, 1303, 1303, 1305, 1305, 1307, 1307, 1309, 1309, 1311, 1311, 1313, 1313, 1315, 1315, 1317, 1317, 1319, 1319, 1377, 1415, 7424, 7467, 7531, 7543, 7545, 7578, 7681, 7681, 7683, 7683, 7685, 7685, 7687, 7687, 7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699, 7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711, 7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723, 7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735, 7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747, 7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759, 7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771, 7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783, 7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795, 7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807, 7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819, 7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7837, 7839, 7839, 7841, 7841, 7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, 7853, 7853, 7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, 7865, 7865, 7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, 7877, 7877, 7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, 7889, 7889, 7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, 7901, 7901, 7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, 7913, 7913, 7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, 7925, 7925, 7927, 7927, 7929, 7929, 7931, 7931, 7933, 7933, 7935, 7943, 7952, 7957, 7968, 7975, 7984, 7991, 8000, 8005, 8016, 8023, 8032, 8039, 8048, 8061, 8064, 8071, 8080, 8087, 8096, 8103, 8112, 8116, 8118, 8119, 8126, 8126, 8130, 8132, 8134, 8135, 8144, 8147, 8150, 8151, 8160, 8167, 8178, 8180, 8182, 8183, 8458, 8458, 8462, 8463, 8467, 8467, 8495, 8495, 8500, 8500, 8505, 8505, 8508, 8509, 8518, 8521, 8526, 8526, 8580, 8580, 11312, 11358, 11361, 11361, 11365, 11366, 11368, 11368, 11370, 11370, 11372, 11372, 11377, 11377, 11379, 11380, 11382, 11387, 11393, 11393, 11395, 11395, 11397, 11397, 11399, 11399, 11401, 11401, 11403, 11403, 11405, 11405, 11407, 11407, 11409, 11409, 11411, 11411, 11413, 11413, 11415, 11415, 11417, 11417, 11419, 11419, 11421, 11421, 11423, 11423, 11425, 11425, 11427, 11427, 11429, 11429, 11431, 11431, 11433, 11433, 11435, 11435, 11437, 11437, 11439, 11439, 11441, 11441, 11443, 11443, 11445, 11445, 11447, 11447, 11449, 11449, 11451, 11451, 11453, 11453, 11455, 11455, 11457, 11457, 11459, 11459, 11461, 11461, 11463, 11463, 11465, 11465, 11467, 11467, 11469, 11469, 11471, 11471, 11473, 11473, 11475, 11475, 11477, 11477, 11479, 11479, 11481, 11481, 11483, 11483, 11485, 11485, 11487, 11487, 11489, 11489, 11491, 11492, 11500, 11500, 11502, 11502, 11507, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 42561, 42561, 42563, 42563, 42565, 42565, 42567, 42567, 42569, 42569, 42571, 42571, 42573, 42573, 42575, 42575, 42577, 42577, 42579, 42579, 42581, 42581, 42583, 42583, 42585, 42585, 42587, 42587, 42589, 42589, 42591, 42591, 42593, 42593, 42595, 42595, 42597, 42597, 42599, 42599, 42601, 42601, 42603, 42603, 42605, 42605, 42625, 42625, 42627, 42627, 42629, 42629, 42631, 42631, 42633, 42633, 42635, 42635, 42637, 42637, 42639, 42639, 42641, 42641, 42643, 42643, 42645, 42645, 42647, 42647, 42787, 42787, 42789, 42789, 42791, 42791, 42793, 42793, 42795, 42795, 42797, 42797, 42799, 42801, 42803, 42803, 42805, 42805, 42807, 42807, 42809, 42809, 42811, 42811, 42813, 42813, 42815, 42815, 42817, 42817, 42819, 42819, 42821, 42821, 42823, 42823, 42825, 42825, 42827, 42827, 42829, 42829, 42831, 42831, 42833, 42833, 42835, 42835, 42837, 42837, 42839, 42839, 42841, 42841, 42843, 42843, 42845, 42845, 42847, 42847, 42849, 42849, 42851, 42851, 42853, 42853, 42855, 42855, 42857, 42857, 42859, 42859, 42861, 42861, 42863, 42863, 42865, 42872, 42874, 42874, 42876, 42876, 42879, 42879, 42881, 42881, 42883, 42883, 42885, 42885, 42887, 42887, 42892, 42892, 42894, 42894, 42897, 42897, 42899, 42899, 42913, 42913, 42915, 42915, 42917, 42917, 42919, 42919, 42921, 42921, 43002, 43002, 64256, 64262, 64275, 64279, 65345, 65370, 51, 0, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 884, 884, 890, 890, 1369, 1369, 1600, 1600, 1765, 1766, 2036, 2037, 2042, 2042, 2074, 2074, 2084, 2084, 2088, 2088, 2417, 2417, 3654, 3654, 3782, 3782, 4348, 4348, 6103, 6103, 6211, 6211, 6823, 6823, 7288, 7293, 7468, 7530, 7544, 7544, 7579, 7615, 8305, 8305, 8319, 8319, 8336, 8348, 11388, 11389, 11631, 11631, 11823, 11823, 12293, 12293, 12337, 12341, 12347, 12347, 12445, 12446, 12540, 12542, 40981, 40981, 42232, 42237, 42508, 42508, 42623, 42623, 42775, 42783, 42864, 42864, 42888, 42888, 43000, 43001, 43471, 43471, 43632, 43632, 43741, 43741, 43763, 43764, 65392, 65392, 65438, 65439, 289, 0, 170, 170, 186, 186, 443, 443, 448, 451, 660, 660, 1488, 1514, 1520, 1522, 1568, 1599, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2048, 2069, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2418, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4304, 4346, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6108, 6108, 6176, 6210, 6212, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7401, 7404, 7406, 7409, 7413, 7414, 8501, 8504, 11568, 11623, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12294, 12294, 12348, 12348, 12353, 12438, 12447, 12447, 12449, 12538, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 13312, 19893, 19893, 19968, 19968, 40908, 40908, 40960, 40980, 40982, 42124, 42192, 42231, 42240, 42507, 42512, 42527, 42538, 42539, 42606, 42606, 42656, 42725, 43003, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43633, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43744, 43754, 43762, 43762, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 44032, 55203, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65382, 65391, 65393, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 10, 0, 453, 453, 456, 456, 459, 459, 498, 498, 8072, 8079, 8088, 8095, 8104, 8111, 8124, 8124, 8140, 8140, 8188, 8188, 576, 0, 65, 90, 192, 214, 216, 222, 256, 256, 258, 258, 260, 260, 262, 262, 264, 264, 266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, 278, 280, 280, 282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, 294, 294, 296, 296, 298, 298, 300, 300, 302, 302, 304, 304, 306, 306, 308, 308, 310, 310, 313, 313, 315, 315, 317, 317, 319, 319, 321, 321, 323, 323, 325, 325, 327, 327, 330, 330, 332, 332, 334, 334, 336, 336, 338, 338, 340, 340, 342, 342, 344, 344, 346, 346, 348, 348, 350, 350, 352, 352, 354, 354, 356, 356, 358, 358, 360, 360, 362, 362, 364, 364, 366, 366, 368, 368, 370, 370, 372, 372, 374, 374, 376, 377, 379, 379, 381, 381, 385, 386, 388, 388, 390, 391, 393, 395, 398, 401, 403, 404, 406, 408, 412, 413, 415, 416, 418, 418, 420, 420, 422, 423, 425, 425, 428, 428, 430, 431, 433, 435, 437, 437, 439, 440, 444, 444, 452, 452, 455, 455, 458, 458, 461, 461, 463, 463, 465, 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 478, 478, 480, 480, 482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 497, 497, 500, 500, 502, 504, 506, 506, 508, 508, 510, 510, 512, 512, 514, 514, 516, 516, 518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, 530, 532, 532, 534, 534, 536, 536, 538, 538, 540, 540, 542, 542, 544, 544, 546, 546, 548, 548, 550, 550, 552, 552, 554, 554, 556, 556, 558, 558, 560, 560, 562, 562, 570, 571, 573, 574, 577, 577, 579, 582, 584, 584, 586, 586, 588, 588, 590, 590, 880, 880, 882, 882, 886, 886, 902, 902, 904, 906, 908, 908, 910, 911, 913, 929, 931, 939, 975, 975, 978, 980, 984, 984, 986, 986, 988, 988, 990, 990, 992, 992, 994, 994, 996, 996, 998, 998, 1000, 1000, 1002, 1002, 1004, 1004, 1006, 1006, 1012, 1012, 1015, 1015, 1017, 1018, 1021, 1071, 1120, 1120, 1122, 1122, 1124, 1124, 1126, 1126, 1128, 1128, 1130, 1130, 1132, 1132, 1134, 1134, 1136, 1136, 1138, 1138, 1140, 1140, 1142, 1142, 1144, 1144, 1146, 1146, 1148, 1148, 1150, 1150, 1152, 1152, 1162, 1162, 1164, 1164, 1166, 1166, 1168, 1168, 1170, 1170, 1172, 1172, 1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184, 1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196, 1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208, 1210, 1210, 1212, 1212, 1214, 1214, 1216, 1217, 1219, 1219, 1221, 1221, 1223, 1223, 1225, 1225, 1227, 1227, 1229, 1229, 1232, 1232, 1234, 1234, 1236, 1236, 1238, 1238, 1240, 1240, 1242, 1242, 1244, 1244, 1246, 1246, 1248, 1248, 1250, 1250, 1252, 1252, 1254, 1254, 1256, 1256, 1258, 1258, 1260, 1260, 1262, 1262, 1264, 1264, 1266, 1266, 1268, 1268, 1270, 1270, 1272, 1272, 1274, 1274, 1276, 1276, 1278, 1278, 1280, 1280, 1282, 1282, 1284, 1284, 1286, 1286, 1288, 1288, 1290, 1290, 1292, 1292, 1294, 1294, 1296, 1296, 1298, 1298, 1300, 1300, 1302, 1302, 1304, 1304, 1306, 1306, 1308, 1308, 1310, 1310, 1312, 1312, 1314, 1314, 1316, 1316, 1318, 1318, 1329, 1366, 4256, 4293, 4295, 4295, 4301, 4301, 7680, 7680, 7682, 7682, 7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694, 7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706, 7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718, 7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730, 7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742, 7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754, 7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766, 7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778, 7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790, 7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802, 7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814, 7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826, 7828, 7828, 7838, 7838, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, 7848, 7848, 7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, 7860, 7860, 7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, 7872, 7872, 7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, 7884, 7884, 7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, 7896, 7896, 7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, 7908, 7908, 7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, 7920, 7920, 7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7930, 7930, 7932, 7932, 7934, 7934, 7944, 7951, 7960, 7965, 7976, 7983, 7992, 7999, 8008, 8013, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8040, 8047, 8120, 8123, 8136, 8139, 8152, 8155, 8168, 8172, 8184, 8187, 8450, 8450, 8455, 8455, 8459, 8461, 8464, 8466, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8496, 8499, 8510, 8511, 8517, 8517, 8579, 8579, 11264, 11310, 11360, 11360, 11362, 11364, 11367, 11367, 11369, 11369, 11371, 11371, 11373, 11376, 11378, 11378, 11381, 11381, 11390, 11392, 11394, 11394, 11396, 11396, 11398, 11398, 11400, 11400, 11402, 11402, 11404, 11404, 11406, 11406, 11408, 11408, 11410, 11410, 11412, 11412, 11414, 11414, 11416, 11416, 11418, 11418, 11420, 11420, 11422, 11422, 11424, 11424, 11426, 11426, 11428, 11428, 11430, 11430, 11432, 11432, 11434, 11434, 11436, 11436, 11438, 11438, 11440, 11440, 11442, 11442, 11444, 11444, 11446, 11446, 11448, 11448, 11450, 11450, 11452, 11452, 11454, 11454, 11456, 11456, 11458, 11458, 11460, 11460, 11462, 11462, 11464, 11464, 11466, 11466, 11468, 11468, 11470, 11470, 11472, 11472, 11474, 11474, 11476, 11476, 11478, 11478, 11480, 11480, 11482, 11482, 11484, 11484, 11486, 11486, 11488, 11488, 11490, 11490, 11499, 11499, 11501, 11501, 11506, 11506, 42560, 42560, 42562, 42562, 42564, 42564, 42566, 42566, 42568, 42568, 42570, 42570, 42572, 42572, 42574, 42574, 42576, 42576, 42578, 42578, 42580, 42580, 42582, 42582, 42584, 42584, 42586, 42586, 42588, 42588, 42590, 42590, 42592, 42592, 42594, 42594, 42596, 42596, 42598, 42598, 42600, 42600, 42602, 42602, 42604, 42604, 42624, 42624, 42626, 42626, 42628, 42628, 42630, 42630, 42632, 42632, 42634, 42634, 42636, 42636, 42638, 42638, 42640, 42640, 42642, 42642, 42644, 42644, 42646, 42646, 42786, 42786, 42788, 42788, 42790, 42790, 42792, 42792, 42794, 42794, 42796, 42796, 42798, 42798, 42802, 42802, 42804, 42804, 42806, 42806, 42808, 42808, 42810, 42810, 42812, 42812, 42814, 42814, 42816, 42816, 42818, 42818, 42820, 42820, 42822, 42822, 42824, 42824, 42826, 42826, 42828, 42828, 42830, 42830, 42832, 42832, 42834, 42834, 42836, 42836, 42838, 42838, 42840, 42840, 42842, 42842, 42844, 42844, 42846, 42846, 42848, 42848, 42850, 42850, 42852, 42852, 42854, 42854, 42856, 42856, 42858, 42858, 42860, 42860, 42862, 42862, 42873, 42873, 42875, 42875, 42877, 42878, 42880, 42880, 42882, 42882, 42884, 42884, 42886, 42886, 42891, 42891, 42893, 42893, 42896, 42896, 42898, 42898, 42912, 42912, 42914, 42914, 42916, 42916, 42918, 42918, 42920, 42920, 42922, 42922, 65313, 65338, 35, 0, 48, 57, 1632, 1641, 1776, 1785, 1984, 1993, 2406, 2415, 2534, 2543, 2662, 2671, 2790, 2799, 2918, 2927, 3046, 3055, 3174, 3183, 3302, 3311, 3430, 3439, 3664, 3673, 3792, 3801, 3872, 3881, 4160, 4169, 4240, 4249, 6112, 6121, 6160, 6169, 6470, 6479, 6608, 6617, 6784, 6793, 6800, 6809, 6992, 7001, 7088, 7097, 7232, 7241, 7248, 7257, 42528, 42537, 43216, 43225, 43264, 43273, 43472, 43481, 43600, 43609, 44016, 44025, 65296, 65305, 7, 0, 5870, 5872, 8544, 8578, 8581, 8584, 12295, 12295, 12321, 12329, 12344, 12346, 42726, 42735, 3, 0, 34, 34, 36, 36, 92, 92, 2688, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 1, 325, 1, 0, 0, 0, 1, 327, 1, 0, 0, 0, 1, 329, 1, 0, 0, 0, 1, 331, 1, 0, 0, 0, 1, 333, 1, 0, 0, 0, 1, 335, 1, 0, 0, 0, 1, 337, 1, 0, 0, 0, 1, 339, 1, 0, 0, 0, 1, 341, 1, 0, 0, 0, 1, 343, 1, 0, 0, 0, 1, 345, 1, 0, 0, 0, 1, 347, 1, 0, 0, 0, 1, 349, 1, 0, 0, 0, 1, 351, 1, 0, 0, 0, 1, 353, 1, 0, 0, 0, 1, 355, 1, 0, 0, 0, 1, 357, 1, 0, 0, 0, 1, 359, 1, 0, 0, 0, 1, 361, 1, 0, 0, 0, 1, 363, 1, 0, 0, 0, 1, 365, 1, 0, 0, 0, 1, 367, 1, 0, 0, 0, 1, 369, 1, 0, 0, 0, 1, 371, 1, 0, 0, 0, 1, 373, 1, 0, 0, 0, 1, 375, 1, 0, 0, 0, 1, 377, 1, 0, 0, 0, 1, 379, 1, 0, 0, 0, 1, 381, 1, 0, 0, 0, 1, 383, 1, 0, 0, 0, 1, 385, 1, 0, 0, 0, 1, 387, 1, 0, 0, 0, 1, 389, 1, 0, 0, 0, 1, 391, 1, 0, 0, 0, 1, 393, 1, 0, 0, 0, 1, 395, 1, 0, 0, 0, 1, 397, 1, 0, 0, 0, 1, 399, 1, 0, 0, 0, 1, 401, 1, 0, 0, 0, 1, 403, 1, 0, 0, 0, 1, 405, 1, 0, 0, 0, 1, 407, 1, 0, 0, 0, 1, 409, 1, 0, 0, 0, 1, 411, 1, 0, 0, 0, 1, 413, 1, 0, 0, 0, 1, 415, 1, 0, 0, 0, 1, 417, 1, 0, 0, 0, 1, 419, 1, 0, 0, 0, 1, 421, 1, 0, 0, 0, 1, 423, 1, 0, 0, 0, 1, 425, 1, 0, 0, 0, 1, 427, 1, 0, 0, 0, 1, 429, 1, 0, 0, 0, 1, 431, 1, 0, 0, 0, 1, 433, 1, 0, 0, 0, 1, 435, 1, 0, 0, 0, 1, 437, 1, 0, 0, 0, 1, 439, 1, 0, 0, 0, 1, 441, 1, 0, 0, 0, 1, 443, 1, 0, 0, 0, 1, 445, 1, 0, 0, 0, 1, 447, 1, 0, 0, 0, 1, 449, 1, 0, 0, 0, 1, 451, 1, 0, 0, 0, 1, 453, 1, 0, 0, 0, 1, 455, 1, 0, 0, 0, 1, 457, 1, 0, 0, 0, 1, 459, 1, 0, 0, 0, 1, 461, 1, 0, 0, 0, 1, 463, 1, 0, 0, 0, 1, 465, 1, 0, 0, 0, 1, 467, 1, 0, 0, 0, 1, 469, 1, 0, 0, 0, 1, 471, 1, 0, 0, 0, 1, 473, 1, 0, 0, 0, 1, 475, 1, 0, 0, 0, 1, 477, 1, 0, 0, 0, 1, 479, 1, 0, 0, 0, 1, 481, 1, 0, 0, 0, 1, 483, 1, 0, 0, 0, 1, 485, 1, 0, 0, 0, 1, 487, 1, 0, 0, 0, 1, 489, 1, 0, 0, 0, 1, 491, 1, 0, 0, 0, 1, 493, 1, 0, 0, 0, 1, 495, 1, 0, 0, 0, 1, 497, 1, 0, 0, 0, 1, 499, 1, 0, 0, 0, 1, 501, 1, 0, 0, 0, 1, 503, 1, 0, 0, 0, 1, 505, 1, 0, 0, 0, 1, 507, 1, 0, 0, 0, 1, 509, 1, 0, 0, 0, 1, 511, 1, 0, 0, 0, 1, 513, 1, 0, 0, 0, 1, 515, 1, 0, 0, 0, 1, 517, 1, 0, 0, 0, 1, 519, 1, 0, 0, 0, 1, 521, 1, 0, 0, 0, 1, 523, 1, 0, 0, 0, 1, 525, 1, 0, 0, 0, 1, 527, 1, 0, 0, 0, 1, 529, 1, 0, 0, 0, 1, 531, 1, 0, 0, 0, 1, 533, 1, 0, 0, 0, 1, 535, 1, 0, 0, 0, 1, 537, 1, 0, 0, 0, 1, 539, 1, 0, 0, 0, 1, 541, 1, 0, 0, 0, 1, 543, 1, 0, 0, 0, 1, 545, 1, 0, 0, 0, 1, 547, 1, 0, 0, 0, 1, 549, 1, 0, 0, 0, 1, 551, 1, 0, 0, 0, 1, 553, 1, 0, 0, 0, 1, 555, 1, 0, 0, 0, 1, 557, 1, 0, 0, 0, 1, 559, 1, 0, 0, 0, 1, 561, 1, 0, 0, 0, 1, 563, 1, 0, 0, 0, 1, 565, 1, 0, 0, 0, 2, 567, 1, 0, 0, 0, 2, 569, 1, 0, 0, 0, 2, 571, 1, 0, 0, 0, 2, 573, 1, 0, 0, 0, 2, 575, 1, 0, 0, 0, 3, 577, 1, 0, 0, 0, 3, 579, 1, 0, 0, 0, 3, 581, 1, 0, 0, 0, 3, 583, 1, 0, 0, 0, 3, 585, 1, 0, 0, 0, 3, 587, 1, 0, 0, 0, 3, 589, 1, 0, 0, 0, 4, 591, 1, 0, 0, 0, 4, 593, 1, 0, 0, 0, 4, 595, 1, 0, 0, 0, 4, 597, 1, 0, 0, 0, 4, 599, 1, 0, 0, 0, 4, 601, 1, 0, 0, 0, 4, 603, 1, 0, 0, 0, 4, 605, 1, 0, 0, 0, 4, 607, 1, 0, 0, 0, 4, 609, 1, 0, 0, 0, 4, 611, 1, 0, 0, 0, 4, 613, 1, 0, 0, 0, 4, 615, 1, 0, 0, 0, 4, 617, 1, 0, 0, 0, 4, 619, 1, 0, 0, 0, 4, 621, 1, 0, 0, 0, 4, 623, 1, 0, 0, 0, 4, 625, 1, 0, 0, 0, 4, 627, 1, 0, 0, 0, 4, 629, 1, 0, 0, 0, 4, 631, 1, 0, 0, 0, 4, 633, 1, 0, 0, 0, 4, 635, 1, 0, 0, 0, 4, 637, 1, 0, 0, 0, 4, 639, 1, 0, 0, 0, 4, 641, 1, 0, 0, 0, 4, 643, 1, 0, 0, 0, 4, 645, 1, 0, 0, 0, 4, 647, 1, 0, 0, 0, 4, 649, 1, 0, 0, 0, 4, 651, 1, 0, 0, 0, 4, 653, 1, 0, 0, 0, 4, 655, 1, 0, 0, 0, 4, 657, 1, 0, 0, 0, 4, 659, 1, 0, 0, 0, 4, 661, 1, 0, 0, 0, 4, 663, 1, 0, 0, 0, 4, 665, 1, 0, 0, 0, 4, 667, 1, 0, 0, 0, 4, 669, 1, 0, 0, 0, 4, 671, 1, 0, 0, 0, 4, 673, 1, 0, 0, 0, 4, 675, 1, 0, 0, 0, 4, 677, 1, 0, 0, 0, 4, 679, 1, 0, 0, 0, 4, 681, 1, 0, 0, 0, 4, 683, 1, 0, 0, 0, 4, 685, 1, 0, 0, 0, 4, 687, 1, 0, 0, 0, 4, 689, 1, 0, 0, 0, 4, 691, 1, 0, 0, 0, 4, 693, 1, 0, 0, 0, 4, 695, 1, 0, 0, 0, 4, 697, 1, 0, 0, 0, 4, 699, 1, 0, 0, 0, 4, 701, 1, 0, 0, 0, 4, 703, 1, 0, 0, 0, 4, 705, 1, 0, 0, 0, 4, 707, 1, 0, 0, 0, 4, 709, 1, 0, 0, 0, 4, 711, 1, 0, 0, 0, 4, 713, 1, 0, 0, 0, 4, 715, 1, 0, 0, 0, 4, 717, 1, 0, 0, 0, 4, 719, 1, 0, 0, 0, 4, 721, 1, 0, 0, 0, 4, 723, 1, 0, 0, 0, 5, 725, 1, 0, 0, 0, 7, 736, 1, 0, 0, 0, 9, 751, 1, 0, 0, 0, 11, 762, 1, 0, 0, 0, 13, 769, 1, 0, 0, 0, 15, 771, 1, 0, 0, 0, 17, 775, 1, 0, 0, 0, 19, 777, 1, 0, 0, 0, 21, 779, 1, 0, 0, 0, 23, 783, 1, 0, 0, 0, 25, 785, 1, 0, 0, 0, 27, 789, 1, 0, 0, 0, 29, 791, 1, 0, 0, 0, 31, 793, 1, 0, 0, 0, 33, 795, 1, 0, 0, 0, 35, 797, 1, 0, 0, 0, 37, 799, 1, 0, 0, 0, 39, 801, 1, 0, 0, 0, 41, 803, 1, 0, 0, 0, 43, 805, 1, 0, 0, 0, 45, 808, 1, 0, 0, 0, 47, 811, 1, 0, 0, 0, 49, 814, 1, 0, 0, 0, 51, 817, 1, 0, 0, 0, 53, 819, 1, 0, 0, 0, 55, 821, 1, 0, 0, 0, 57, 823, 1, 0, 0, 0, 59, 825, 1, 0, 0, 0, 61, 828, 1, 0, 0, 0, 63, 831, 1, 0, 0, 0, 65, 834, 1, 0, 0, 0, 67, 837, 1, 0, 0, 0, 69, 840, 1, 0, 0, 0, 71, 843, 1, 0, 0, 0, 73, 846, 1, 0, 0, 0, 75, 849, 1, 0, 0, 0, 77, 852, 1, 0, 0, 0, 79, 856, 1, 0, 0, 0, 81, 859, 1, 0, 0, 0, 83, 861, 1, 0, 0, 0, 85, 863, 1, 0, 0, 0, 87, 865, 1, 0, 0, 0, 89, 868, 1, 0, 0, 0, 91, 870, 1, 0, 0, 0, 93, 872, 1, 0, 0, 0, 95, 875, 1, 0, 0, 0, 97, 878, 1, 0, 0, 0, 99, 881, 1, 0, 0, 0, 101, 885, 1, 0, 0, 0, 103, 889, 1, 0, 0, 0, 105, 892, 1, 0, 0, 0, 107, 896, 1, 0, 0, 0, 109, 898, 1, 0, 0, 0, 111, 908, 1, 0, 0, 0, 113, 920, 1, 0, 0, 0, 115, 929, 1, 0, 0, 0, 117, 935, 1, 0, 0, 0, 119, 943, 1, 0, 0, 0, 121, 950, 1, 0, 0, 0, 123, 956, 1, 0, 0, 0, 125, 966, 1, 0, 0, 0, 127, 970, 1, 0, 0, 0, 129, 977, 1, 0, 0, 0, 131, 981, 1, 0, 0, 0, 133, 985, 1, 0, 0, 0, 135, 995, 1, 0, 0, 0, 137, 1007, 1, 0, 0, 0, 139, 1010, 1, 0, 0, 0, 141, 1020, 1, 0, 0, 0, 143, 1025, 1, 0, 0, 0, 145, 1030, 1, 0, 0, 0, 147, 1036, 1, 0, 0, 0, 149, 1043, 1, 0, 0, 0, 151, 1049, 1, 0, 0, 0, 153, 1052, 1, 0, 0, 0, 155, 1057, 1, 0, 0, 0, 157, 1062, 1, 0, 0, 0, 159, 1066, 1, 0, 0, 0, 161, 1072, 1, 0, 0, 0, 163, 1080, 1, 0, 0, 0, 165, 1084, 1, 0, 0, 0, 167, 1087, 1, 0, 0, 0, 169, 1093, 1, 0, 0, 0, 171, 1099, 1, 0, 0, 0, 173, 1106, 1, 0, 0, 0, 175, 1115, 1, 0, 0, 0, 177, 1121, 1, 0, 0, 0, 179, 1124, 1, 0, 0, 0, 181, 1127, 1, 0, 0, 0, 183, 1130, 1, 0, 0, 0, 185, 1140, 1, 0, 0, 0, 187, 1150, 1, 0, 0, 0, 189, 1154, 1, 0, 0, 0, 191, 1161, 1, 0, 0, 0, 193, 1171, 1, 0, 0, 0, 195, 1176, 1, 0, 0, 0, 197, 1181, 1, 0, 0, 0, 199, 1185, 1, 0, 0, 0, 201, 1189, 1, 0, 0, 0, 203, 1199, 1, 0, 0, 0, 205, 1206, 1, 0, 0, 0, 207, 1216, 1, 0, 0, 0, 209, 1226, 1, 0, 0, 0, 211, 1234, 1, 0, 0, 0, 213, 1241, 1, 0, 0, 0, 215, 1249, 1, 0, 0, 0, 217, 1259, 1, 0, 0, 0, 219, 1268, 1, 0, 0, 0, 221, 1273, 1, 0, 0, 0, 223, 1280, 1, 0, 0, 0, 225, 1291, 1, 0, 0, 0, 227, 1296, 1, 0, 0, 0, 229, 1302, 1, 0, 0, 0, 231, 1310, 1, 0, 0, 0, 233, 1319, 1, 0, 0, 0, 235, 1326, 1, 0, 0, 0, 237, 1332, 1, 0, 0, 0, 239, 1341, 1, 0, 0, 0, 241, 1349, 1, 0, 0, 0, 243, 1358, 1, 0, 0, 0, 245, 1367, 1, 0, 0, 0, 247, 1373, 1, 0, 0, 0, 249, 1378, 1, 0, 0, 0, 251, 1384, 1, 0, 0, 0, 253, 1393, 1, 0, 0, 0, 255, 1400, 1, 0, 0, 0, 257, 1409, 1, 0, 0, 0, 259, 1421, 1, 0, 0, 0, 261, 1429, 1, 0, 0, 0, 263, 1433, 1, 0, 0, 0, 265, 1441, 1, 0, 0, 0, 267, 1445, 1, 0, 0, 0, 269, 1473, 1, 0, 0, 0, 271, 1564, 1, 0, 0, 0, 273, 1659, 1, 0, 0, 0, 275, 1661, 1, 0, 0, 0, 277, 1663, 1, 0, 0, 0, 279, 1665, 1, 0, 0, 0, 281, 1667, 1, 0, 0, 0, 283, 1677, 1, 0, 0, 0, 285, 1679, 1, 0, 0, 0, 287, 1689, 1, 0, 0, 0, 289, 1700, 1, 0, 0, 0, 291, 1702, 1, 0, 0, 0, 293, 1726, 1, 0, 0, 0, 295, 1728, 1, 0, 0, 0, 297, 1731, 1, 0, 0, 0, 299, 1734, 1, 0, 0, 0, 301, 1737, 1, 0, 0, 0, 303, 1746, 1, 0, 0, 0, 305, 1748, 1, 0, 0, 0, 307, 1755, 1, 0, 0, 0, 309, 1764, 1, 0, 0, 0, 311, 1766, 1, 0, 0, 0, 313, 1768, 1, 0, 0, 0, 315, 1770, 1, 0, 0, 0, 317, 1772, 1, 0, 0, 0, 319, 1774, 1, 0, 0, 0, 321, 1776, 1, 0, 0, 0, 323, 1778, 1, 0, 0, 0, 325, 1780, 1, 0, 0, 0, 327, 1785, 1, 0, 0, 0, 329, 1790, 1, 0, 0, 0, 331, 1795, 1, 0, 0, 0, 333, 1800, 1, 0, 0, 0, 335, 1804, 1, 0, 0, 0, 337, 1808, 1, 0, 0, 0, 339, 1812, 1, 0, 0, 0, 341, 1816, 1, 0, 0, 0, 343, 1820, 1, 0, 0, 0, 345, 1824, 1, 0, 0, 0, 347, 1828, 1, 0, 0, 0, 349, 1832, 1, 0, 0, 0, 351, 1836, 1, 0, 0, 0, 353, 1840, 1, 0, 0, 0, 355, 1844, 1, 0, 0, 0, 357, 1848, 1, 0, 0, 0, 359, 1852, 1, 0, 0, 0, 361, 1856, 1, 0, 0, 0, 363, 1860, 1, 0, 0, 0, 365, 1864, 1, 0, 0, 0, 367, 1868, 1, 0, 0, 0, 369, 1872, 1, 0, 0, 0, 371, 1876, 1, 0, 0, 0, 373, 1880, 1, 0, 0, 0, 375, 1884, 1, 0, 0, 0, 377, 1888, 1, 0, 0, 0, 379, 1892, 1, 0, 0, 0, 381, 1896, 1, 0, 0, 0, 383, 1900, 1, 0, 0, 0, 385, 1904, 1, 0, 0, 0, 387, 1908, 1, 0, 0, 0, 389, 1912, 1, 0, 0, 0, 391, 1916, 1, 0, 0, 0, 393, 1920, 1, 0, 0, 0, 395, 1924, 1, 0, 0, 0, 397, 1928, 1, 0, 0, 0, 399, 1932, 1, 0, 0, 0, 401, 1936, 1, 0, 0, 0, 403, 1940, 1, 0, 0, 0, 405, 1944, 1, 0, 0, 0, 407, 1948, 1, 0, 0, 0, 409, 1952, 1, 0, 0, 0, 411, 1956, 1, 0, 0, 0, 413, 1960, 1, 0, 0, 0, 415, 1964, 1, 0, 0, 0, 417, 1968, 1, 0, 0, 0, 419, 1972, 1, 0, 0, 0, 421, 1976, 1, 0, 0, 0, 423, 1980, 1, 0, 0, 0, 425, 1985, 1, 0, 0, 0, 427, 1990, 1, 0, 0, 0, 429, 1994, 1, 0, 0, 0, 431, 1998, 1, 0, 0, 0, 433, 2002, 1, 0, 0, 0, 435, 2006, 1, 0, 0, 0, 437, 2010, 1, 0, 0, 0, 439, 2014, 1, 0, 0, 0, 441, 2018, 1, 0, 0, 0, 443, 2022, 1, 0, 0, 0, 445, 2026, 1, 0, 0, 0, 447, 2030, 1, 0, 0, 0, 449, 2034, 1, 0, 0, 0, 451, 2038, 1, 0, 0, 0, 453, 2042, 1, 0, 0, 0, 455, 2046, 1, 0, 0, 0, 457, 2050, 1, 0, 0, 0, 459, 2054, 1, 0, 0, 0, 461, 2058, 1, 0, 0, 0, 463, 2062, 1, 0, 0, 0, 465, 2066, 1, 0, 0, 0, 467, 2070, 1, 0, 0, 0, 469, 2074, 1, 0, 0, 0, 471, 2078, 1, 0, 0, 0, 473, 2082, 1, 0, 0, 0, 475, 2086, 1, 0, 0, 0, 477, 2090, 1, 0, 0, 0, 479, 2094, 1, 0, 0, 0, 481, 2098, 1, 0, 0, 0, 483, 2102, 1, 0, 0, 0, 485, 2106, 1, 0, 0, 0, 487, 2110, 1, 0, 0, 0, 489, 2114, 1, 0, 0, 0, 491, 2118, 1, 0, 0, 0, 493, 2122, 1, 0, 0, 0, 495, 2126, 1, 0, 0, 0, 497, 2130, 1, 0, 0, 0, 499, 2134, 1, 0, 0, 0, 501, 2138, 1, 0, 0, 0, 503, 2142, 1, 0, 0, 0, 505, 2146, 1, 0, 0, 0, 507, 2150, 1, 0, 0, 0, 509, 2154, 1, 0, 0, 0, 511, 2158, 1, 0, 0, 0, 513, 2162, 1, 0, 0, 0, 515, 2166, 1, 0, 0, 0, 517, 2170, 1, 0, 0, 0, 519, 2174, 1, 0, 0, 0, 521, 2178, 1, 0, 0, 0, 523, 2182, 1, 0, 0, 0, 525, 2186, 1, 0, 0, 0, 527, 2190, 1, 0, 0, 0, 529, 2194, 1, 0, 0, 0, 531, 2198, 1, 0, 0, 0, 533, 2202, 1, 0, 0, 0, 535, 2206, 1, 0, 0, 0, 537, 2210, 1, 0, 0, 0, 539, 2214, 1, 0, 0, 0, 541, 2218, 1, 0, 0, 0, 543, 2222, 1, 0, 0, 0, 545, 2226, 1, 0, 0, 0, 547, 2230, 1, 0, 0, 0, 549, 2234, 1, 0, 0, 0, 551, 2238, 1, 0, 0, 0, 553, 2242, 1, 0, 0, 0, 555, 2246, 1, 0, 0, 0, 557, 2250, 1, 0, 0, 0, 559, 2254, 1, 0, 0, 0, 561, 2260, 1, 0, 0, 0, 563, 2264, 1, 0, 0, 0, 565, 2268, 1, 0, 0, 0, 567, 2272, 1, 0, 0, 0, 569, 2276, 1, 0, 0, 0, 571, 2284, 1, 0, 0, 0, 573, 2289, 1, 0, 0, 0, 575, 2291, 1, 0, 0, 0, 577, 2297, 1, 0, 0, 0, 579, 2306, 1, 0, 0, 0, 581, 2310, 1, 0, 0, 0, 583, 2318, 1, 0, 0, 0, 585, 2320, 1, 0, 0, 0, 587, 2323, 1, 0, 0, 0, 589, 2328, 1, 0, 0, 0, 591, 2332, 1, 0, 0, 0, 593, 2337, 1, 0, 0, 0, 595, 2342, 1, 0, 0, 0, 597, 2347, 1, 0, 0, 0, 599, 2351, 1, 0, 0, 0, 601, 2355, 1, 0, 0, 0, 603, 2360, 1, 0, 0, 0, 605, 2364, 1, 0, 0, 0, 607, 2368, 1, 0, 0, 0, 609, 2372, 1, 0, 0, 0, 611, 2376, 1, 0, 0, 0, 613, 2380, 1, 0, 0, 0, 615, 2384, 1, 0, 0, 0, 617, 2388, 1, 0, 0, 0, 619, 2392, 1, 0, 0, 0, 621, 2396, 1, 0, 0, 0, 623, 2400, 1, 0, 0, 0, 625, 2404, 1, 0, 0, 0, 627, 2408, 1, 0, 0, 0, 629, 2412, 1, 0, 0, 0, 631, 2416, 1, 0, 0, 0, 633, 2420, 1, 0, 0, 0, 635, 2424, 1, 0, 0, 0, 637, 2428, 1, 0, 0, 0, 639, 2432, 1, 0, 0, 0, 641, 2436, 1, 0, 0, 0, 643, 2440, 1, 0, 0, 0, 645, 2444, 1, 0, 0, 0, 647, 2448, 1, 0, 0, 0, 649, 2452, 1, 0, 0, 0, 651, 2456, 1, 0, 0, 0, 653, 2460, 1, 0, 0, 0, 655, 2464, 1, 0, 0, 0, 657, 2468, 1, 0, 0, 0, 659, 2472, 1, 0, 0, 0, 661, 2476, 1, 0, 0, 0, 663, 2480, 1, 0, 0, 0, 665, 2484, 1, 0, 0, 0, 667, 2488, 1, 0, 0, 0, 669, 2492, 1, 0, 0, 0, 671, 2496, 1, 0, 0, 0, 673, 2500, 1, 0, 0, 0, 675, 2504, 1, 0, 0, 0, 677, 2508, 1, 0, 0, 0, 679, 2512, 1, 0, 0, 0, 681, 2514, 1, 0, 0, 0, 683, 2518, 1, 0, 0, 0, 685, 2522, 1, 0, 0, 0, 687, 2526, 1, 0, 0, 0, 689, 2530, 1, 0, 0, 0, 691, 2534, 1, 0, 0, 0, 693, 2538, 1, 0, 0, 0, 695, 2543, 1, 0, 0, 0, 697, 2548, 1, 0, 0, 0, 699, 2552, 1, 0, 0, 0, 701, 2556, 1, 0, 0, 0, 703, 2560, 1, 0, 0, 0, 705, 2564, 1, 0, 0, 0, 707, 2568, 1, 0, 0, 0, 709, 2572, 1, 0, 0, 0, 711, 2576, 1, 0, 0, 0, 713, 2580, 1, 0, 0, 0, 715, 2584, 1, 0, 0, 0, 717, 2588, 1, 0, 0, 0, 719, 2594, 1, 0, 0, 0, 721, 2598, 1, 0, 0, 0, 723, 2602, 1, 0, 0, 0, 725, 726, 5, 35, 0, 0, 726, 727, 5, 33, 0, 0, 727, 731, 1, 0, 0, 0, 728, 730, 8, 0, 0, 0, 729, 728, 1, 0, 0, 0, 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 734, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 735, 6, 0, 0, 0, 735, 6, 1, 0, 0, 0, 736, 737, 5, 47, 0, 0, 737, 738, 5, 42, 0, 0, 738, 743, 1, 0, 0, 0, 739, 742, 3, 7, 1, 0, 740, 742, 9, 0, 0, 0, 741, 739, 1, 0, 0, 0, 741, 740, 1, 0, 0, 0, 742, 745, 1, 0, 0, 0, 743, 744, 1, 0, 0, 0, 743, 741, 1, 0, 0, 0, 744, 746, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 746, 747, 5, 42, 0, 0, 747, 748, 5, 47, 0, 0, 748, 749, 1, 0, 0, 0, 749, 750, 6, 1, 0, 0, 750, 8, 1, 0, 0, 0, 751, 752, 5, 47, 0, 0, 752, 753, 5, 47, 0, 0, 753, 757, 1, 0, 0, 0, 754, 756, 8, 0, 0, 0, 755, 754, 1, 0, 0, 0, 756, 759, 1, 0, 0, 0, 757, 755, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 760, 1, 0, 0, 0, 759, 757, 1, 0, 0, 0, 760, 761, 6, 2, 0, 0, 761, 10, 1, 0, 0, 0, 762, 763, 7, 1, 0, 0, 763, 764, 1, 0, 0, 0, 764, 765, 6, 3, 1, 0, 765, 12, 1, 0, 0, 0, 766, 770, 5, 10, 0, 0, 767, 768, 5, 13, 0, 0, 768, 770, 5, 10, 0, 0, 769, 766, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 770, 14, 1, 0, 0, 0, 771, 772, 5, 46, 0, 0, 772, 773, 5, 46, 0, 0, 773, 774, 5, 46, 0, 0, 774, 16, 1, 0, 0, 0, 775, 776, 5, 46, 0, 0, 776, 18, 1, 0, 0, 0, 777, 778, 5, 44, 0, 0, 778, 20, 1, 0, 0, 0, 779, 780, 5, 40, 0, 0, 780, 781, 1, 0, 0, 0, 781, 782, 6, 8, 2, 0, 782, 22, 1, 0, 0, 0, 783, 784, 5, 41, 0, 0, 784, 24, 1, 0, 0, 0, 785, 786, 5, 91, 0, 0, 786, 787, 1, 0, 0, 0, 787, 788, 6, 10, 2, 0, 788, 26, 1, 0, 0, 0, 789, 790, 5, 93, 0, 0, 790, 28, 1, 0, 0, 0, 791, 792, 5, 123, 0, 0, 792, 30, 1, 0, 0, 0, 793, 794, 5, 125, 0, 0, 794, 32, 1, 0, 0, 0, 795, 796, 5, 42, 0, 0, 796, 34, 1, 0, 0, 0, 797, 798, 5, 37, 0, 0, 798, 36, 1, 0, 0, 0, 799, 800, 5, 47, 0, 0, 800, 38, 1, 0, 0, 0, 801, 802, 5, 43, 0, 0, 802, 40, 1, 0, 0, 0, 803, 804, 5, 45, 0, 0, 804, 42, 1, 0, 0, 0, 805, 806, 5, 43, 0, 0, 806, 807, 5, 43, 0, 0, 807, 44, 1, 0, 0, 0, 808, 809, 5, 45, 0, 0, 809, 810, 5, 45, 0, 0, 810, 46, 1, 0, 0, 0, 811, 812, 5, 38, 0, 0, 812, 813, 5, 38, 0, 0, 813, 48, 1, 0, 0, 0, 814, 815, 5, 124, 0, 0, 815, 816, 5, 124, 0, 0, 816, 50, 1, 0, 0, 0, 817, 818, 5, 33, 0, 0, 818, 52, 1, 0, 0, 0, 819, 820, 5, 58, 0, 0, 820, 54, 1, 0, 0, 0, 821, 822, 5, 59, 0, 0, 822, 56, 1, 0, 0, 0, 823, 824, 5, 61, 0, 0, 824, 58, 1, 0, 0, 0, 825, 826, 5, 43, 0, 0, 826, 827, 5, 61, 0, 0, 827, 60, 1, 0, 0, 0, 828, 829, 5, 45, 0, 0, 829, 830, 5, 61, 0, 0, 830, 62, 1, 0, 0, 0, 831, 832, 5, 42, 0, 0, 832, 833, 5, 61, 0, 0, 833, 64, 1, 0, 0, 0, 834, 835, 5, 47, 0, 0, 835, 836, 5, 61, 0, 0, 836, 66, 1, 0, 0, 0, 837, 838, 5, 37, 0, 0, 838, 839, 5, 61, 0, 0, 839, 68, 1, 0, 0, 0, 840, 841, 5, 45, 0, 0, 841, 842, 5, 62, 0, 0, 842, 70, 1, 0, 0, 0, 843, 844, 5, 61, 0, 0, 844, 845, 5, 62, 0, 0, 845, 72, 1, 0, 0, 0, 846, 847, 5, 46, 0, 0, 847, 848, 5, 46, 0, 0, 848, 74, 1, 0, 0, 0, 849, 850, 5, 58, 0, 0, 850, 851, 5, 58, 0, 0, 851, 76, 1, 0, 0, 0, 852, 853, 5, 63, 0, 0, 853, 854, 5, 58, 0, 0, 854, 855, 5, 58, 0, 0, 855, 78, 1, 0, 0, 0, 856, 857, 5, 59, 0, 0, 857, 858, 5, 59, 0, 0, 858, 80, 1, 0, 0, 0, 859, 860, 5, 35, 0, 0, 860, 82, 1, 0, 0, 0, 861, 862, 5, 64, 0, 0, 862, 84, 1, 0, 0, 0, 863, 864, 5, 63, 0, 0, 864, 86, 1, 0, 0, 0, 865, 866, 5, 63, 0, 0, 866, 867, 5, 58, 0, 0, 867, 88, 1, 0, 0, 0, 868, 869, 5, 60, 0, 0, 869, 90, 1, 0, 0, 0, 870, 871, 5, 62, 0, 0, 871, 92, 1, 0, 0, 0, 872, 873, 5, 60, 0, 0, 873, 874, 5, 61, 0, 0, 874, 94, 1, 0, 0, 0, 875, 876, 5, 62, 0, 0, 876, 877, 5, 61, 0, 0, 877, 96, 1, 0, 0, 0, 878, 879, 5, 33, 0, 0, 879, 880, 5, 61, 0, 0, 880, 98, 1, 0, 0, 0, 881, 882, 5, 33, 0, 0, 882, 883, 5, 61, 0, 0, 883, 884, 5, 61, 0, 0, 884, 100, 1, 0, 0, 0, 885, 886, 5, 97, 0, 0, 886, 887, 5, 115, 0, 0, 887, 888, 5, 63, 0, 0, 888, 102, 1, 0, 0, 0, 889, 890, 5, 61, 0, 0, 890, 891, 5, 61, 0, 0, 891, 104, 1, 0, 0, 0, 892, 893, 5, 61, 0, 0, 893, 894, 5, 61, 0, 0, 894, 895, 5, 61, 0, 0, 895, 106, 1, 0, 0, 0, 896, 897, 5, 39, 0, 0, 897, 108, 1, 0, 0, 0, 898, 899, 5, 114, 0, 0, 899, 900, 5, 101, 0, 0, 900, 901, 5, 116, 0, 0, 901, 902, 5, 117, 0, 0, 902, 903, 5, 114, 0, 0, 903, 904, 5, 110, 0, 0, 904, 905, 5, 64, 0, 0, 905, 906, 1, 0, 0, 0, 906, 907, 3, 293, 144, 0, 907, 110, 1, 0, 0, 0, 908, 909, 5, 99, 0, 0, 909, 910, 5, 111, 0, 0, 910, 911, 5, 110, 0, 0, 911, 912, 5, 116, 0, 0, 912, 913, 5, 105, 0, 0, 913, 914, 5, 110, 0, 0, 914, 915, 5, 117, 0, 0, 915, 916, 5, 101, 0, 0, 916, 917, 5, 64, 0, 0, 917, 918, 1, 0, 0, 0, 918, 919, 3, 293, 144, 0, 919, 112, 1, 0, 0, 0, 920, 921, 5, 98, 0, 0, 921, 922, 5, 114, 0, 0, 922, 923, 5, 101, 0, 0, 923, 924, 5, 97, 0, 0, 924, 925, 5, 107, 0, 0, 925, 926, 5, 64, 0, 0, 926, 927, 1, 0, 0, 0, 927, 928, 3, 293, 144, 0, 928, 114, 1, 0, 0, 0, 929, 930, 5, 64, 0, 0, 930, 931, 5, 102, 0, 0, 931, 932, 5, 105, 0, 0, 932, 933, 5, 108, 0, 0, 933, 934, 5, 101, 0, 0, 934, 116, 1, 0, 0, 0, 935, 936, 5, 112, 0, 0, 936, 937, 5, 97, 0, 0, 937, 938, 5, 99, 0, 0, 938, 939, 5, 107, 0, 0, 939, 940, 5, 97, 0, 0, 940, 941, 5, 103, 0, 0, 941, 942, 5, 101, 0, 0, 942, 118, 1, 0, 0, 0, 943, 944, 5, 105, 0, 0, 944, 945, 5, 109, 0, 0, 945, 946, 5, 112, 0, 0, 946, 947, 5, 111, 0, 0, 947, 948, 5, 114, 0, 0, 948, 949, 5, 116, 0, 0, 949, 120, 1, 0, 0, 0, 950, 951, 5, 99, 0, 0, 951, 952, 5, 108, 0, 0, 952, 953, 5, 97, 0, 0, 953, 954, 5, 115, 0, 0, 954, 955, 5, 115, 0, 0, 955, 122, 1, 0, 0, 0, 956, 957, 5, 105, 0, 0, 957, 958, 5, 110, 0, 0, 958, 959, 5, 116, 0, 0, 959, 960, 5, 101, 0, 0, 960, 961, 5, 114, 0, 0, 961, 962, 5, 102, 0, 0, 962, 963, 5, 97, 0, 0, 963, 964, 5, 99, 0, 0, 964, 965, 5, 101, 0, 0, 965, 124, 1, 0, 0, 0, 966, 967, 5, 102, 0, 0, 967, 968, 5, 117, 0, 0, 968, 969, 5, 110, 0, 0, 969, 126, 1, 0, 0, 0, 970, 971, 5, 111, 0, 0, 971, 972, 5, 98, 0, 0, 972, 973, 5, 106, 0, 0, 973, 974, 5, 101, 0, 0, 974, 975, 5, 99, 0, 0, 975, 976, 5, 116, 0, 0, 976, 128, 1, 0, 0, 0, 977, 978, 5, 118, 0, 0, 978, 979, 5, 97, 0, 0, 979, 980, 5, 108, 0, 0, 980, 130, 1, 0, 0, 0, 981, 982, 5, 118, 0, 0, 982, 983, 5, 97, 0, 0, 983, 984, 5, 114, 0, 0, 984, 132, 1, 0, 0, 0, 985, 986, 5, 116, 0, 0, 986, 987, 5, 121, 0, 0, 987, 988, 5, 112, 0, 0, 988, 989, 5, 101, 0, 0, 989, 990, 5, 97, 0, 0, 990, 991, 5, 108, 0, 0, 991, 992, 5, 105, 0, 0, 992, 993, 5, 97, 0, 0, 993, 994, 5, 115, 0, 0, 994, 134, 1, 0, 0, 0, 995, 996, 5, 99, 0, 0, 996, 997, 5, 111, 0, 0, 997, 998, 5, 110, 0, 0, 998, 999, 5, 115, 0, 0, 999, 1000, 5, 116, 0, 0, 1000, 1001, 5, 114, 0, 0, 1001, 1002, 5, 117, 0, 0, 1002, 1003, 5, 99, 0, 0, 1003, 1004, 5, 116, 0, 0, 1004, 1005, 5, 111, 0, 0, 1005, 1006, 5, 114, 0, 0, 1006, 136, 1, 0, 0, 0, 1007, 1008, 5, 98, 0, 0, 1008, 1009, 5, 121, 0, 0, 1009, 138, 1, 0, 0, 0, 1010, 1011, 5, 99, 0, 0, 1011, 1012, 5, 111, 0, 0, 1012, 1013, 5, 109, 0, 0, 1013, 1014, 5, 112, 0, 0, 1014, 1015, 5, 97, 0, 0, 1015, 1016, 5, 110, 0, 0, 1016, 1017, 5, 105, 0, 0, 1017, 1018, 5, 111, 0, 0, 1018, 1019, 5, 110, 0, 0, 1019, 140, 1, 0, 0, 0, 1020, 1021, 5, 105, 0, 0, 1021, 1022, 5, 110, 0, 0, 1022, 1023, 5, 105, 0, 0, 1023, 1024, 5, 116, 0, 0, 1024, 142, 1, 0, 0, 0, 1025, 1026, 5, 116, 0, 0, 1026, 1027, 5, 104, 0, 0, 1027, 1028, 5, 105, 0, 0, 1028, 1029, 5, 115, 0, 0, 1029, 144, 1, 0, 0, 0, 1030, 1031, 5, 115, 0, 0, 1031, 1032, 5, 117, 0, 0, 1032, 1033, 5, 112, 0, 0, 1033, 1034, 5, 101, 0, 0, 1034, 1035, 5, 114, 0, 0, 1035, 146, 1, 0, 0, 0, 1036, 1037, 5, 116, 0, 0, 1037, 1038, 5, 121, 0, 0, 1038, 1039, 5, 112, 0, 0, 1039, 1040, 5, 101, 0, 0, 1040, 1041, 5, 111, 0, 0, 1041, 1042, 5, 102, 0, 0, 1042, 148, 1, 0, 0, 0, 1043, 1044, 5, 119, 0, 0, 1044, 1045, 5, 104, 0, 0, 1045, 1046, 5, 101, 0, 0, 1046, 1047, 5, 114, 0, 0, 1047, 1048, 5, 101, 0, 0, 1048, 150, 1, 0, 0, 0, 1049, 1050, 5, 105, 0, 0, 1050, 1051, 5, 102, 0, 0, 1051, 152, 1, 0, 0, 0, 1052, 1053, 5, 101, 0, 0, 1053, 1054, 5, 108, 0, 0, 1054, 1055, 5, 115, 0, 0, 1055, 1056, 5, 101, 0, 0, 1056, 154, 1, 0, 0, 0, 1057, 1058, 5, 119, 0, 0, 1058, 1059, 5, 104, 0, 0, 1059, 1060, 5, 101, 0, 0, 1060, 1061, 5, 110, 0, 0, 1061, 156, 1, 0, 0, 0, 1062, 1063, 5, 116, 0, 0, 1063, 1064, 5, 114, 0, 0, 1064, 1065, 5, 121, 0, 0, 1065, 158, 1, 0, 0, 0, 1066, 1067, 5, 99, 0, 0, 1067, 1068, 5, 97, 0, 0, 1068, 1069, 5, 116, 0, 0, 1069, 1070, 5, 99, 0, 0, 1070, 1071, 5, 104, 0, 0, 1071, 160, 1, 0, 0, 0, 1072, 1073, 5, 102, 0, 0, 1073, 1074, 5, 105, 0, 0, 1074, 1075, 5, 110, 0, 0, 1075, 1076, 5, 97, 0, 0, 1076, 1077, 5, 108, 0, 0, 1077, 1078, 5, 108, 0, 0, 1078, 1079, 5, 121, 0, 0, 1079, 162, 1, 0, 0, 0, 1080, 1081, 5, 102, 0, 0, 1081, 1082, 5, 111, 0, 0, 1082, 1083, 5, 114, 0, 0, 1083, 164, 1, 0, 0, 0, 1084, 1085, 5, 100, 0, 0, 1085, 1086, 5, 111, 0, 0, 1086, 166, 1, 0, 0, 0, 1087, 1088, 5, 119, 0, 0, 1088, 1089, 5, 104, 0, 0, 1089, 1090, 5, 105, 0, 0, 1090, 1091, 5, 108, 0, 0, 1091, 1092, 5, 101, 0, 0, 1092, 168, 1, 0, 0, 0, 1093, 1094, 5, 116, 0, 0, 1094, 1095, 5, 104, 0, 0, 1095, 1096, 5, 114, 0, 0, 1096, 1097, 5, 111, 0, 0, 1097, 1098, 5, 119, 0, 0, 1098, 170, 1, 0, 0, 0, 1099, 1100, 5, 114, 0, 0, 1100, 1101, 5, 101, 0, 0, 1101, 1102, 5, 116, 0, 0, 1102, 1103, 5, 117, 0, 0, 1103, 1104, 5, 114, 0, 0, 1104, 1105, 5, 110, 0, 0, 1105, 172, 1, 0, 0, 0, 1106, 1107, 5, 99, 0, 0, 1107, 1108, 5, 111, 0, 0, 1108, 1109, 5, 110, 0, 0, 1109, 1110, 5, 116, 0, 0, 1110, 1111, 5, 105, 0, 0, 1111, 1112, 5, 110, 0, 0, 1112, 1113, 5, 117, 0, 0, 1113, 1114, 5, 101, 0, 0, 1114, 174, 1, 0, 0, 0, 1115, 1116, 5, 98, 0, 0, 1116, 1117, 5, 114, 0, 0, 1117, 1118, 5, 101, 0, 0, 1118, 1119, 5, 97, 0, 0, 1119, 1120, 5, 107, 0, 0, 1120, 176, 1, 0, 0, 0, 1121, 1122, 5, 97, 0, 0, 1122, 1123, 5, 115, 0, 0, 1123, 178, 1, 0, 0, 0, 1124, 1125, 5, 105, 0, 0, 1125, 1126, 5, 115, 0, 0, 1126, 180, 1, 0, 0, 0, 1127, 1128, 5, 105, 0, 0, 1128, 1129, 5, 110, 0, 0, 1129, 182, 1, 0, 0, 0, 1130, 1131, 5, 33, 0, 0, 1131, 1132, 5, 105, 0, 0, 1132, 1133, 5, 115, 0, 0, 1133, 1136, 1, 0, 0, 0, 1134, 1137, 3, 11, 3, 0, 1135, 1137, 3, 13, 4, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 184, 1, 0, 0, 0, 1140, 1141, 5, 33, 0, 0, 1141, 1142, 5, 105, 0, 0, 1142, 1143, 5, 110, 0, 0, 1143, 1146, 1, 0, 0, 0, 1144, 1147, 3, 11, 3, 0, 1145, 1147, 3, 13, 4, 0, 1146, 1144, 1, 0, 0, 0, 1146, 1145, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1146, 1, 0, 0, 0, 1148, 1149, 1, 0, 0, 0, 1149, 186, 1, 0, 0, 0, 1150, 1151, 5, 111, 0, 0, 1151, 1152, 5, 117, 0, 0, 1152, 1153, 5, 116, 0, 0, 1153, 188, 1, 0, 0, 0, 1154, 1155, 5, 64, 0, 0, 1155, 1156, 5, 102, 0, 0, 1156, 1157, 5, 105, 0, 0, 1157, 1158, 5, 101, 0, 0, 1158, 1159, 5, 108, 0, 0, 1159, 1160, 5, 100, 0, 0, 1160, 190, 1, 0, 0, 0, 1161, 1162, 5, 64, 0, 0, 1162, 1163, 5, 112, 0, 0, 1163, 1164, 5, 114, 0, 0, 1164, 1165, 5, 111, 0, 0, 1165, 1166, 5, 112, 0, 0, 1166, 1167, 5, 101, 0, 0, 1167, 1168, 5, 114, 0, 0, 1168, 1169, 5, 116, 0, 0, 1169, 1170, 5, 121, 0, 0, 1170, 192, 1, 0, 0, 0, 1171, 1172, 5, 64, 0, 0, 1172, 1173, 5, 103, 0, 0, 1173, 1174, 5, 101, 0, 0, 1174, 1175, 5, 116, 0, 0, 1175, 194, 1, 0, 0, 0, 1176, 1177, 5, 64, 0, 0, 1177, 1178, 5, 115, 0, 0, 1178, 1179, 5, 101, 0, 0, 1179, 1180, 5, 116, 0, 0, 1180, 196, 1, 0, 0, 0, 1181, 1182, 5, 103, 0, 0, 1182, 1183, 5, 101, 0, 0, 1183, 1184, 5, 116, 0, 0, 1184, 198, 1, 0, 0, 0, 1185, 1186, 5, 115, 0, 0, 1186, 1187, 5, 101, 0, 0, 1187, 1188, 5, 116, 0, 0, 1188, 200, 1, 0, 0, 0, 1189, 1190, 5, 64, 0, 0, 1190, 1191, 5, 114, 0, 0, 1191, 1192, 5, 101, 0, 0, 1192, 1193, 5, 99, 0, 0, 1193, 1194, 5, 101, 0, 0, 1194, 1195, 5, 105, 0, 0, 1195, 1196, 5, 118, 0, 0, 1196, 1197, 5, 101, 0, 0, 1197, 1198, 5, 114, 0, 0, 1198, 202, 1, 0, 0, 0, 1199, 1200, 5, 64, 0, 0, 1200, 1201, 5, 112, 0, 0, 1201, 1202, 5, 97, 0, 0, 1202, 1203, 5, 114, 0, 0, 1203, 1204, 5, 97, 0, 0, 1204, 1205, 5, 109, 0, 0, 1205, 204, 1, 0, 0, 0, 1206, 1207, 5, 64, 0, 0, 1207, 1208, 5, 115, 0, 0, 1208, 1209, 5, 101, 0, 0, 1209, 1210, 5, 116, 0, 0, 1210, 1211, 5, 112, 0, 0, 1211, 1212, 5, 97, 0, 0, 1212, 1213, 5, 114, 0, 0, 1213, 1214, 5, 97, 0, 0, 1214, 1215, 5, 109, 0, 0, 1215, 206, 1, 0, 0, 0, 1216, 1217, 5, 64, 0, 0, 1217, 1218, 5, 100, 0, 0, 1218, 1219, 5, 101, 0, 0, 1219, 1220, 5, 108, 0, 0, 1220, 1221, 5, 101, 0, 0, 1221, 1222, 5, 103, 0, 0, 1222, 1223, 5, 97, 0, 0, 1223, 1224, 5, 116, 0, 0, 1224, 1225, 5, 101, 0, 0, 1225, 208, 1, 0, 0, 0, 1226, 1227, 5, 100, 0, 0, 1227, 1228, 5, 121, 0, 0, 1228, 1229, 5, 110, 0, 0, 1229, 1230, 5, 97, 0, 0, 1230, 1231, 5, 109, 0, 0, 1231, 1232, 5, 105, 0, 0, 1232, 1233, 5, 99, 0, 0, 1233, 210, 1, 0, 0, 0, 1234, 1235, 5, 112, 0, 0, 1235, 1236, 5, 117, 0, 0, 1236, 1237, 5, 98, 0, 0, 1237, 1238, 5, 108, 0, 0, 1238, 1239, 5, 105, 0, 0, 1239, 1240, 5, 99, 0, 0, 1240, 212, 1, 0, 0, 0, 1241, 1242, 5, 112, 0, 0, 1242, 1243, 5, 114, 0, 0, 1243, 1244, 5, 105, 0, 0, 1244, 1245, 5, 118, 0, 0, 1245, 1246, 5, 97, 0, 0, 1246, 1247, 5, 116, 0, 0, 1247, 1248, 5, 101, 0, 0, 1248, 214, 1, 0, 0, 0, 1249, 1250, 5, 112, 0, 0, 1250, 1251, 5, 114, 0, 0, 1251, 1252, 5, 111, 0, 0, 1252, 1253, 5, 116, 0, 0, 1253, 1254, 5, 101, 0, 0, 1254, 1255, 5, 99, 0, 0, 1255, 1256, 5, 116, 0, 0, 1256, 1257, 5, 101, 0, 0, 1257, 1258, 5, 100, 0, 0, 1258, 216, 1, 0, 0, 0, 1259, 1260, 5, 105, 0, 0, 1260, 1261, 5, 110, 0, 0, 1261, 1262, 5, 116, 0, 0, 1262, 1263, 5, 101, 0, 0, 1263, 1264, 5, 114, 0, 0, 1264, 1265, 5, 110, 0, 0, 1265, 1266, 5, 97, 0, 0, 1266, 1267, 5, 108, 0, 0, 1267, 218, 1, 0, 0, 0, 1268, 1269, 5, 101, 0, 0, 1269, 1270, 5, 110, 0, 0, 1270, 1271, 5, 117, 0, 0, 1271, 1272, 5, 109, 0, 0, 1272, 220, 1, 0, 0, 0, 1273, 1274, 5, 115, 0, 0, 1274, 1275, 5, 101, 0, 0, 1275, 1276, 5, 97, 0, 0, 1276, 1277, 5, 108, 0, 0, 1277, 1278, 5, 101, 0, 0, 1278, 1279, 5, 100, 0, 0, 1279, 222, 1, 0, 0, 0, 1280, 1281, 5, 97, 0, 0, 1281, 1282, 5, 110, 0, 0, 1282, 1283, 5, 110, 0, 0, 1283, 1284, 5, 111, 0, 0, 1284, 1285, 5, 116, 0, 0, 1285, 1286, 5, 97, 0, 0, 1286, 1287, 5, 116, 0, 0, 1287, 1288, 5, 105, 0, 0, 1288, 1289, 5, 111, 0, 0, 1289, 1290, 5, 110, 0, 0, 1290, 224, 1, 0, 0, 0, 1291, 1292, 5, 100, 0, 0, 1292, 1293, 5, 97, 0, 0, 1293, 1294, 5, 116, 0, 0, 1294, 1295, 5, 97, 0, 0, 1295, 226, 1, 0, 0, 0, 1296, 1297, 5, 105, 0, 0, 1297, 1298, 5, 110, 0, 0, 1298, 1299, 5, 110, 0, 0, 1299, 1300, 5, 101, 0, 0, 1300, 1301, 5, 114, 0, 0, 1301, 228, 1, 0, 0, 0, 1302, 1303, 5, 116, 0, 0, 1303, 1304, 5, 97, 0, 0, 1304, 1305, 5, 105, 0, 0, 1305, 1306, 5, 108, 0, 0, 1306, 1307, 5, 114, 0, 0, 1307, 1308, 5, 101, 0, 0, 1308, 1309, 5, 99, 0, 0, 1309, 230, 1, 0, 0, 0, 1310, 1311, 5, 111, 0, 0, 1311, 1312, 5, 112, 0, 0, 1312, 1313, 5, 101, 0, 0, 1313, 1314, 5, 114, 0, 0, 1314, 1315, 5, 97, 0, 0, 1315, 1316, 5, 116, 0, 0, 1316, 1317, 5, 111, 0, 0, 1317, 1318, 5, 114, 0, 0, 1318, 232, 1, 0, 0, 0, 1319, 1320, 5, 105, 0, 0, 1320, 1321, 5, 110, 0, 0, 1321, 1322, 5, 108, 0, 0, 1322, 1323, 5, 105, 0, 0, 1323, 1324, 5, 110, 0, 0, 1324, 1325, 5, 101, 0, 0, 1325, 234, 1, 0, 0, 0, 1326, 1327, 5, 105, 0, 0, 1327, 1328, 5, 110, 0, 0, 1328, 1329, 5, 102, 0, 0, 1329, 1330, 5, 105, 0, 0, 1330, 1331, 5, 120, 0, 0, 1331, 236, 1, 0, 0, 0, 1332, 1333, 5, 101, 0, 0, 1333, 1334, 5, 120, 0, 0, 1334, 1335, 5, 116, 0, 0, 1335, 1336, 5, 101, 0, 0, 1336, 1337, 5, 114, 0, 0, 1337, 1338, 5, 110, 0, 0, 1338, 1339, 5, 97, 0, 0, 1339, 1340, 5, 108, 0, 0, 1340, 238, 1, 0, 0, 0, 1341, 1342, 5, 115, 0, 0, 1342, 1343, 5, 117, 0, 0, 1343, 1344, 5, 115, 0, 0, 1344, 1345, 5, 112, 0, 0, 1345, 1346, 5, 101, 0, 0, 1346, 1347, 5, 110, 0, 0, 1347, 1348, 5, 100, 0, 0, 1348, 240, 1, 0, 0, 0, 1349, 1350, 5, 111, 0, 0, 1350, 1351, 5, 118, 0, 0, 1351, 1352, 5, 101, 0, 0, 1352, 1353, 5, 114, 0, 0, 1353, 1354, 5, 114, 0, 0, 1354, 1355, 5, 105, 0, 0, 1355, 1356, 5, 100, 0, 0, 1356, 1357, 5, 101, 0, 0, 1357, 242, 1, 0, 0, 0, 1358, 1359, 5, 97, 0, 0, 1359, 1360, 5, 98, 0, 0, 1360, 1361, 5, 115, 0, 0, 1361, 1362, 5, 116, 0, 0, 1362, 1363, 5, 114, 0, 0, 1363, 1364, 5, 97, 0, 0, 1364, 1365, 5, 99, 0, 0, 1365, 1366, 5, 116, 0, 0, 1366, 244, 1, 0, 0, 0, 1367, 1368, 5, 102, 0, 0, 1368, 1369, 5, 105, 0, 0, 1369, 1370, 5, 110, 0, 0, 1370, 1371, 5, 97, 0, 0, 1371, 1372, 5, 108, 0, 0, 1372, 246, 1, 0, 0, 0, 1373, 1374, 5, 111, 0, 0, 1374, 1375, 5, 112, 0, 0, 1375, 1376, 5, 101, 0, 0, 1376, 1377, 5, 110, 0, 0, 1377, 248, 1, 0, 0, 0, 1378, 1379, 5, 99, 0, 0, 1379, 1380, 5, 111, 0, 0, 1380, 1381, 5, 110, 0, 0, 1381, 1382, 5, 115, 0, 0, 1382, 1383, 5, 116, 0, 0, 1383, 250, 1, 0, 0, 0, 1384, 1385, 5, 108, 0, 0, 1385, 1386, 5, 97, 0, 0, 1386, 1387, 5, 116, 0, 0, 1387, 1388, 5, 101, 0, 0, 1388, 1389, 5, 105, 0, 0, 1389, 1390, 5, 110, 0, 0, 1390, 1391, 5, 105, 0, 0, 1391, 1392, 5, 116, 0, 0, 1392, 252, 1, 0, 0, 0, 1393, 1394, 5, 118, 0, 0, 1394, 1395, 5, 97, 0, 0, 1395, 1396, 5, 114, 0, 0, 1396, 1397, 5, 97, 0, 0, 1397, 1398, 5, 114, 0, 0, 1398, 1399, 5, 103, 0, 0, 1399, 254, 1, 0, 0, 0, 1400, 1401, 5, 110, 0, 0, 1401, 1402, 5, 111, 0, 0, 1402, 1403, 5, 105, 0, 0, 1403, 1404, 5, 110, 0, 0, 1404, 1405, 5, 108, 0, 0, 1405, 1406, 5, 105, 0, 0, 1406, 1407, 5, 110, 0, 0, 1407, 1408, 5, 101, 0, 0, 1408, 256, 1, 0, 0, 0, 1409, 1410, 5, 99, 0, 0, 1410, 1411, 5, 114, 0, 0, 1411, 1412, 5, 111, 0, 0, 1412, 1413, 5, 115, 0, 0, 1413, 1414, 5, 115, 0, 0, 1414, 1415, 5, 105, 0, 0, 1415, 1416, 5, 110, 0, 0, 1416, 1417, 5, 108, 0, 0, 1417, 1418, 5, 105, 0, 0, 1418, 1419, 5, 110, 0, 0, 1419, 1420, 5, 101, 0, 0, 1420, 258, 1, 0, 0, 0, 1421, 1422, 5, 114, 0, 0, 1422, 1423, 5, 101, 0, 0, 1423, 1424, 5, 105, 0, 0, 1424, 1425, 5, 102, 0, 0, 1425, 1426, 5, 105, 0, 0, 1426, 1427, 5, 101, 0, 0, 1427, 1428, 5, 100, 0, 0, 1428, 260, 1, 0, 0, 0, 1429, 1430, 5, 34, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1432, 6, 128, 3, 0, 1432, 262, 1, 0, 0, 0, 1433, 1434, 5, 34, 0, 0, 1434, 1435, 5, 34, 0, 0, 1435, 1436, 5, 34, 0, 0, 1436, 1437, 1, 0, 0, 0, 1437, 1438, 6, 129, 4, 0, 1438, 264, 1, 0, 0, 0, 1439, 1442, 3, 267, 131, 0, 1440, 1442, 3, 269, 132, 0, 1441, 1439, 1, 0, 0, 0, 1441, 1440, 1, 0, 0, 0, 1442, 266, 1, 0, 0, 0, 1443, 1446, 3, 269, 132, 0, 1444, 1446, 3, 273, 134, 0, 1445, 1443, 1, 0, 0, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1447, 1, 0, 0, 0, 1447, 1448, 7, 2, 0, 0, 1448, 268, 1, 0, 0, 0, 1449, 1453, 3, 277, 136, 0, 1450, 1452, 3, 275, 135, 0, 1451, 1450, 1, 0, 0, 0, 1452, 1455, 1, 0, 0, 0, 1453, 1451, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1458, 1, 0, 0, 0, 1455, 1453, 1, 0, 0, 0, 1456, 1458, 5, 48, 0, 0, 1457, 1449, 1, 0, 0, 0, 1457, 1456, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1474, 5, 46, 0, 0, 1460, 1465, 3, 277, 136, 0, 1461, 1464, 3, 275, 135, 0, 1462, 1464, 5, 95, 0, 0, 1463, 1461, 1, 0, 0, 0, 1463, 1462, 1, 0, 0, 0, 1464, 1467, 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1468, 1, 0, 0, 0, 1467, 1465, 1, 0, 0, 0, 1468, 1469, 3, 275, 135, 0, 1469, 1471, 1, 0, 0, 0, 1470, 1460, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1472, 1, 0, 0, 0, 1472, 1474, 5, 46, 0, 0, 1473, 1457, 1, 0, 0, 0, 1473, 1470, 1, 0, 0, 0, 1474, 1559, 1, 0, 0, 0, 1475, 1477, 3, 275, 135, 0, 1476, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1560, 1, 0, 0, 0, 1480, 1483, 3, 275, 135, 0, 1481, 1484, 3, 275, 135, 0, 1482, 1484, 5, 95, 0, 0, 1483, 1481, 1, 0, 0, 0, 1483, 1482, 1, 0, 0, 0, 1484, 1485, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 1488, 3, 275, 135, 0, 1488, 1560, 1, 0, 0, 0, 1489, 1491, 3, 275, 135, 0, 1490, 1489, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1490, 1, 0, 0, 0, 1492, 1493, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1496, 7, 3, 0, 0, 1495, 1497, 7, 4, 0, 0, 1496, 1495, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 1499, 1, 0, 0, 0, 1498, 1500, 3, 275, 135, 0, 1499, 1498, 1, 0, 0, 0, 1500, 1501, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1560, 1, 0, 0, 0, 1503, 1505, 3, 275, 135, 0, 1504, 1503, 1, 0, 0, 0, 1505, 1506, 1, 0, 0, 0, 1506, 1504, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 7, 3, 0, 0, 1509, 1511, 7, 4, 0, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1515, 3, 275, 135, 0, 1513, 1516, 3, 275, 135, 0, 1514, 1516, 5, 95, 0, 0, 1515, 1513, 1, 0, 0, 0, 1515, 1514, 1, 0, 0, 0, 1516, 1517, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1517, 1518, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1520, 3, 275, 135, 0, 1520, 1560, 1, 0, 0, 0, 1521, 1524, 3, 275, 135, 0, 1522, 1525, 3, 275, 135, 0, 1523, 1525, 5, 95, 0, 0, 1524, 1522, 1, 0, 0, 0, 1524, 1523, 1, 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 1528, 1, 0, 0, 0, 1528, 1529, 3, 275, 135, 0, 1529, 1531, 7, 3, 0, 0, 1530, 1532, 7, 4, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531, 1532, 1, 0, 0, 0, 1532, 1534, 1, 0, 0, 0, 1533, 1535, 3, 275, 135, 0, 1534, 1533, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1537, 1, 0, 0, 0, 1537, 1560, 1, 0, 0, 0, 1538, 1541, 3, 275, 135, 0, 1539, 1542, 3, 275, 135, 0, 1540, 1542, 5, 95, 0, 0, 1541, 1539, 1, 0, 0, 0, 1541, 1540, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1541, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1546, 3, 275, 135, 0, 1546, 1548, 7, 3, 0, 0, 1547, 1549, 7, 4, 0, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1553, 3, 275, 135, 0, 1551, 1554, 3, 275, 135, 0, 1552, 1554, 5, 95, 0, 0, 1553, 1551, 1, 0, 0, 0, 1553, 1552, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1553, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 1558, 3, 275, 135, 0, 1558, 1560, 1, 0, 0, 0, 1559, 1476, 1, 0, 0, 0, 1559, 1480, 1, 0, 0, 0, 1559, 1490, 1, 0, 0, 0, 1559, 1504, 1, 0, 0, 0, 1559, 1521, 1, 0, 0, 0, 1559, 1538, 1, 0, 0, 0, 1560, 270, 1, 0, 0, 0, 1561, 1565, 3, 273, 134, 0, 1562, 1565, 3, 281, 138, 0, 1563, 1565, 3, 285, 140, 0, 1564, 1561, 1, 0, 0, 0, 1564, 1562, 1, 0, 0, 0, 1564, 1563, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1567, 5, 76, 0, 0, 1567, 272, 1, 0, 0, 0, 1568, 1660, 5, 48, 0, 0, 1569, 1573, 3, 277, 136, 0, 1570, 1572, 3, 275, 135, 0, 1571, 1570, 1, 0, 0, 0, 1572, 1575, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1660, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1576, 1579, 3, 277, 136, 0, 1577, 1580, 3, 275, 135, 0, 1578, 1580, 5, 95, 0, 0, 1579, 1577, 1, 0, 0, 0, 1579, 1578, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1579, 1, 0, 0, 0, 1581, 1582, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1584, 3, 275, 135, 0, 1584, 1660, 1, 0, 0, 0, 1585, 1589, 3, 277, 136, 0, 1586, 1588, 3, 275, 135, 0, 1587, 1586, 1, 0, 0, 0, 1588, 1591, 1, 0, 0, 0, 1589, 1587, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 1592, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1592, 1594, 7, 3, 0, 0, 1593, 1595, 7, 4, 0, 0, 1594, 1593, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 1597, 1, 0, 0, 0, 1596, 1598, 3, 275, 135, 0, 1597, 1596, 1, 0, 0, 0, 1598, 1599, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1599, 1600, 1, 0, 0, 0, 1600, 1660, 1, 0, 0, 0, 1601, 1605, 3, 277, 136, 0, 1602, 1604, 3, 275, 135, 0, 1603, 1602, 1, 0, 0, 0, 1604, 1607, 1, 0, 0, 0, 1605, 1603, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1608, 1, 0, 0, 0, 1607, 1605, 1, 0, 0, 0, 1608, 1610, 7, 3, 0, 0, 1609, 1611, 7, 4, 0, 0, 1610, 1609, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612, 1615, 3, 275, 135, 0, 1613, 1616, 3, 275, 135, 0, 1614, 1616, 5, 95, 0, 0, 1615, 1613, 1, 0, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 1620, 3, 275, 135, 0, 1620, 1660, 1, 0, 0, 0, 1621, 1624, 3, 277, 136, 0, 1622, 1625, 3, 275, 135, 0, 1623, 1625, 5, 95, 0, 0, 1624, 1622, 1, 0, 0, 0, 1624, 1623, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1627, 1, 0, 0, 0, 1627, 1628, 1, 0, 0, 0, 1628, 1629, 3, 275, 135, 0, 1629, 1631, 7, 3, 0, 0, 1630, 1632, 7, 4, 0, 0, 1631, 1630, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, 0, 1632, 1634, 1, 0, 0, 0, 1633, 1635, 3, 275, 135, 0, 1634, 1633, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1634, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1660, 1, 0, 0, 0, 1638, 1641, 3, 277, 136, 0, 1639, 1642, 3, 275, 135, 0, 1640, 1642, 5, 95, 0, 0, 1641, 1639, 1, 0, 0, 0, 1641, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 1646, 3, 275, 135, 0, 1646, 1648, 7, 3, 0, 0, 1647, 1649, 7, 4, 0, 0, 1648, 1647, 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1653, 3, 275, 135, 0, 1651, 1654, 3, 275, 135, 0, 1652, 1654, 5, 95, 0, 0, 1653, 1651, 1, 0, 0, 0, 1653, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1653, 1, 0, 0, 0, 1655, 1656, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, 1657, 1658, 3, 275, 135, 0, 1658, 1660, 1, 0, 0, 0, 1659, 1568, 1, 0, 0, 0, 1659, 1569, 1, 0, 0, 0, 1659, 1576, 1, 0, 0, 0, 1659, 1585, 1, 0, 0, 0, 1659, 1601, 1, 0, 0, 0, 1659, 1621, 1, 0, 0, 0, 1659, 1638, 1, 0, 0, 0, 1660, 274, 1, 0, 0, 0, 1661, 1662, 3, 321, 158, 0, 1662, 276, 1, 0, 0, 0, 1663, 1664, 3, 279, 137, 0, 1664, 278, 1, 0, 0, 0, 1665, 1666, 7, 5, 0, 0, 1666, 280, 1, 0, 0, 0, 1667, 1668, 5, 48, 0, 0, 1668, 1669, 7, 6, 0, 0, 1669, 1674, 3, 283, 139, 0, 1670, 1673, 3, 283, 139, 0, 1671, 1673, 5, 95, 0, 0, 1672, 1670, 1, 0, 0, 0, 1672, 1671, 1, 0, 0, 0, 1673, 1676, 1, 0, 0, 0, 1674, 1672, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 282, 1, 0, 0, 0, 1676, 1674, 1, 0, 0, 0, 1677, 1678, 7, 7, 0, 0, 1678, 284, 1, 0, 0, 0, 1679, 1680, 5, 48, 0, 0, 1680, 1681, 7, 8, 0, 0, 1681, 1686, 3, 287, 141, 0, 1682, 1685, 3, 287, 141, 0, 1683, 1685, 5, 95, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1688, 1, 0, 0, 0, 1686, 1684, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1687, 286, 1, 0, 0, 0, 1688, 1686, 1, 0, 0, 0, 1689, 1690, 7, 9, 0, 0, 1690, 288, 1, 0, 0, 0, 1691, 1692, 5, 116, 0, 0, 1692, 1693, 5, 114, 0, 0, 1693, 1694, 5, 117, 0, 0, 1694, 1701, 5, 101, 0, 0, 1695, 1696, 5, 102, 0, 0, 1696, 1697, 5, 97, 0, 0, 1697, 1698, 5, 108, 0, 0, 1698, 1699, 5, 115, 0, 0, 1699, 1701, 5, 101, 0, 0, 1700, 1691, 1, 0, 0, 0, 1700, 1695, 1, 0, 0, 0, 1701, 290, 1, 0, 0, 0, 1702, 1703, 5, 110, 0, 0, 1703, 1704, 5, 117, 0, 0, 1704, 1705, 5, 108, 0, 0, 1705, 1706, 5, 108, 0, 0, 1706, 292, 1, 0, 0, 0, 1707, 1710, 3, 309, 152, 0, 1708, 1710, 5, 95, 0, 0, 1709, 1707, 1, 0, 0, 0, 1709, 1708, 1, 0, 0, 0, 1710, 1716, 1, 0, 0, 0, 1711, 1715, 3, 309, 152, 0, 1712, 1715, 5, 95, 0, 0, 1713, 1715, 3, 275, 135, 0, 1714, 1711, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1714, 1713, 1, 0, 0, 0, 1715, 1718, 1, 0, 0, 0, 1716, 1714, 1, 0, 0, 0, 1716, 1717, 1, 0, 0, 0, 1717, 1727, 1, 0, 0, 0, 1718, 1716, 1, 0, 0, 0, 1719, 1721, 5, 96, 0, 0, 1720, 1722, 8, 10, 0, 0, 1721, 1720, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1721, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, 1727, 5, 96, 0, 0, 1726, 1709, 1, 0, 0, 0, 1726, 1719, 1, 0, 0, 0, 1727, 294, 1, 0, 0, 0, 1728, 1729, 5, 64, 0, 0, 1729, 1730, 3, 293, 144, 0, 1730, 296, 1, 0, 0, 0, 1731, 1732, 3, 293, 144, 0, 1732, 1733, 5, 64, 0, 0, 1733, 298, 1, 0, 0, 0, 1734, 1735, 5, 36, 0, 0, 1735, 1736, 3, 293, 144, 0, 1736, 300, 1, 0, 0, 0, 1737, 1740, 5, 39, 0, 0, 1738, 1741, 3, 303, 149, 0, 1739, 1741, 9, 0, 0, 0, 1740, 1738, 1, 0, 0, 0, 1740, 1739, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1743, 5, 39, 0, 0, 1743, 302, 1, 0, 0, 0, 1744, 1747, 3, 305, 150, 0, 1745, 1747, 3, 307, 151, 0, 1746, 1744, 1, 0, 0, 0, 1746, 1745, 1, 0, 0, 0, 1747, 304, 1, 0, 0, 0, 1748, 1749, 5, 92, 0, 0, 1749, 1750, 5, 117, 0, 0, 1750, 1751, 3, 283, 139, 0, 1751, 1752, 3, 283, 139, 0, 1752, 1753, 3, 283, 139, 0, 1753, 1754, 3, 283, 139, 0, 1754, 306, 1, 0, 0, 0, 1755, 1756, 5, 92, 0, 0, 1756, 1757, 7, 11, 0, 0, 1757, 308, 1, 0, 0, 0, 1758, 1765, 3, 311, 153, 0, 1759, 1765, 3, 313, 154, 0, 1760, 1765, 3, 315, 155, 0, 1761, 1765, 3, 317, 156, 0, 1762, 1765, 3, 319, 157, 0, 1763, 1765, 3, 323, 159, 0, 1764, 1758, 1, 0, 0, 0, 1764, 1759, 1, 0, 0, 0, 1764, 1760, 1, 0, 0, 0, 1764, 1761, 1, 0, 0, 0, 1764, 1762, 1, 0, 0, 0, 1764, 1763, 1, 0, 0, 0, 1765, 310, 1, 0, 0, 0, 1766, 1767, 7, 12, 0, 0, 1767, 312, 1, 0, 0, 0, 1768, 1769, 7, 13, 0, 0, 1769, 314, 1, 0, 0, 0, 1770, 1771, 7, 14, 0, 0, 1771, 316, 1, 0, 0, 0, 1772, 1773, 7, 15, 0, 0, 1773, 318, 1, 0, 0, 0, 1774, 1775, 7, 16, 0, 0, 1775, 320, 1, 0, 0, 0, 1776, 1777, 7, 17, 0, 0, 1777, 322, 1, 0, 0, 0, 1778, 1779, 7, 18, 0, 0, 1779, 324, 1, 0, 0, 0, 1780, 1781, 5, 41, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 1783, 6, 160, 5, 0, 1783, 1784, 6, 160, 6, 0, 1784, 326, 1, 0, 0, 0, 1785, 1786, 5, 93, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1788, 6, 161, 5, 0, 1788, 1789, 6, 161, 7, 0, 1789, 328, 1, 0, 0, 0, 1790, 1791, 3, 21, 8, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1793, 6, 162, 2, 0, 1793, 1794, 6, 162, 8, 0, 1794, 330, 1, 0, 0, 0, 1795, 1796, 3, 25, 10, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1798, 6, 163, 2, 0, 1798, 1799, 6, 163, 9, 0, 1799, 332, 1, 0, 0, 0, 1800, 1801, 3, 29, 12, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1803, 6, 164, 10, 0, 1803, 334, 1, 0, 0, 0, 1804, 1805, 3, 31, 13, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1807, 6, 165, 11, 0, 1807, 336, 1, 0, 0, 0, 1808, 1809, 3, 17, 6, 0, 1809, 1810, 1, 0, 0, 0, 1810, 1811, 6, 166, 12, 0, 1811, 338, 1, 0, 0, 0, 1812, 1813, 3, 19, 7, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1815, 6, 167, 13, 0, 1815, 340, 1, 0, 0, 0, 1816, 1817, 3, 33, 14, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1819, 6, 168, 14, 0, 1819, 342, 1, 0, 0, 0, 1820, 1821, 3, 35, 15, 0, 1821, 1822, 1, 0, 0, 0, 1822, 1823, 6, 169, 15, 0, 1823, 344, 1, 0, 0, 0, 1824, 1825, 3, 37, 16, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 6, 170, 16, 0, 1827, 346, 1, 0, 0, 0, 1828, 1829, 3, 39, 17, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1831, 6, 171, 17, 0, 1831, 348, 1, 0, 0, 0, 1832, 1833, 3, 41, 18, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1835, 6, 172, 18, 0, 1835, 350, 1, 0, 0, 0, 1836, 1837, 3, 43, 19, 0, 1837, 1838, 1, 0, 0, 0, 1838, 1839, 6, 173, 19, 0, 1839, 352, 1, 0, 0, 0, 1840, 1841, 3, 45, 20, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1843, 6, 174, 20, 0, 1843, 354, 1, 0, 0, 0, 1844, 1845, 3, 47, 21, 0, 1845, 1846, 1, 0, 0, 0, 1846, 1847, 6, 175, 21, 0, 1847, 356, 1, 0, 0, 0, 1848, 1849, 3, 49, 22, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, 6, 176, 22, 0, 1851, 358, 1, 0, 0, 0, 1852, 1853, 3, 51, 23, 0, 1853, 1854, 1, 0, 0, 0, 1854, 1855, 6, 177, 23, 0, 1855, 360, 1, 0, 0, 0, 1856, 1857, 3, 53, 24, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1859, 6, 178, 24, 0, 1859, 362, 1, 0, 0, 0, 1860, 1861, 3, 55, 25, 0, 1861, 1862, 1, 0, 0, 0, 1862, 1863, 6, 179, 25, 0, 1863, 364, 1, 0, 0, 0, 1864, 1865, 3, 57, 26, 0, 1865, 1866, 1, 0, 0, 0, 1866, 1867, 6, 180, 26, 0, 1867, 366, 1, 0, 0, 0, 1868, 1869, 3, 59, 27, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1871, 6, 181, 27, 0, 1871, 368, 1, 0, 0, 0, 1872, 1873, 3, 61, 28, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1875, 6, 182, 28, 0, 1875, 370, 1, 0, 0, 0, 1876, 1877, 3, 63, 29, 0, 1877, 1878, 1, 0, 0, 0, 1878, 1879, 6, 183, 29, 0, 1879, 372, 1, 0, 0, 0, 1880, 1881, 3, 65, 30, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1883, 6, 184, 30, 0, 1883, 374, 1, 0, 0, 0, 1884, 1885, 3, 67, 31, 0, 1885, 1886, 1, 0, 0, 0, 1886, 1887, 6, 185, 31, 0, 1887, 376, 1, 0, 0, 0, 1888, 1889, 3, 69, 32, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1891, 6, 186, 32, 0, 1891, 378, 1, 0, 0, 0, 1892, 1893, 3, 71, 33, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895, 6, 187, 33, 0, 1895, 380, 1, 0, 0, 0, 1896, 1897, 3, 73, 34, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1899, 6, 188, 34, 0, 1899, 382, 1, 0, 0, 0, 1900, 1901, 3, 15, 5, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1903, 6, 189, 35, 0, 1903, 384, 1, 0, 0, 0, 1904, 1905, 3, 75, 35, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1907, 6, 190, 36, 0, 1907, 386, 1, 0, 0, 0, 1908, 1909, 3, 77, 36, 0, 1909, 1910, 1, 0, 0, 0, 1910, 1911, 6, 191, 37, 0, 1911, 388, 1, 0, 0, 0, 1912, 1913, 3, 79, 37, 0, 1913, 1914, 1, 0, 0, 0, 1914, 1915, 6, 192, 38, 0, 1915, 390, 1, 0, 0, 0, 1916, 1917, 3, 81, 38, 0, 1917, 1918, 1, 0, 0, 0, 1918, 1919, 6, 193, 39, 0, 1919, 392, 1, 0, 0, 0, 1920, 1921, 3, 83, 39, 0, 1921, 1922, 1, 0, 0, 0, 1922, 1923, 6, 194, 40, 0, 1923, 394, 1, 0, 0, 0, 1924, 1925, 3, 85, 40, 0, 1925, 1926, 1, 0, 0, 0, 1926, 1927, 6, 195, 41, 0, 1927, 396, 1, 0, 0, 0, 1928, 1929, 3, 87, 41, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1931, 6, 196, 42, 0, 1931, 398, 1, 0, 0, 0, 1932, 1933, 3, 89, 42, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1935, 6, 197, 43, 0, 1935, 400, 1, 0, 0, 0, 1936, 1937, 3, 91, 43, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 6, 198, 44, 0, 1939, 402, 1, 0, 0, 0, 1940, 1941, 3, 93, 44, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 6, 199, 45, 0, 1943, 404, 1, 0, 0, 0, 1944, 1945, 3, 95, 45, 0, 1945, 1946, 1, 0, 0, 0, 1946, 1947, 6, 200, 46, 0, 1947, 406, 1, 0, 0, 0, 1948, 1949, 3, 97, 46, 0, 1949, 1950, 1, 0, 0, 0, 1950, 1951, 6, 201, 47, 0, 1951, 408, 1, 0, 0, 0, 1952, 1953, 3, 99, 47, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1955, 6, 202, 48, 0, 1955, 410, 1, 0, 0, 0, 1956, 1957, 3, 183, 89, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1959, 6, 203, 49, 0, 1959, 412, 1, 0, 0, 0, 1960, 1961, 3, 185, 90, 0, 1961, 1962, 1, 0, 0, 0, 1962, 1963, 6, 204, 50, 0, 1963, 414, 1, 0, 0, 0, 1964, 1965, 3, 101, 48, 0, 1965, 1966, 1, 0, 0, 0, 1966, 1967, 6, 205, 51, 0, 1967, 416, 1, 0, 0, 0, 1968, 1969, 3, 103, 49, 0, 1969, 1970, 1, 0, 0, 0, 1970, 1971, 6, 206, 52, 0, 1971, 418, 1, 0, 0, 0, 1972, 1973, 3, 105, 50, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1975, 6, 207, 53, 0, 1975, 420, 1, 0, 0, 0, 1976, 1977, 3, 107, 51, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1979, 6, 208, 54, 0, 1979, 422, 1, 0, 0, 0, 1980, 1981, 3, 261, 128, 0, 1981, 1982, 1, 0, 0, 0, 1982, 1983, 6, 209, 3, 0, 1983, 1984, 6, 209, 55, 0, 1984, 424, 1, 0, 0, 0, 1985, 1986, 3, 263, 129, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1988, 6, 210, 4, 0, 1988, 1989, 6, 210, 56, 0, 1989, 426, 1, 0, 0, 0, 1990, 1991, 3, 129, 62, 0, 1991, 1992, 1, 0, 0, 0, 1992, 1993, 6, 211, 57, 0, 1993, 428, 1, 0, 0, 0, 1994, 1995, 3, 131, 63, 0, 1995, 1996, 1, 0, 0, 0, 1996, 1997, 6, 212, 58, 0, 1997, 430, 1, 0, 0, 0, 1998, 1999, 3, 127, 61, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2001, 6, 213, 59, 0, 2001, 432, 1, 0, 0, 0, 2002, 2003, 3, 145, 70, 0, 2003, 2004, 1, 0, 0, 0, 2004, 2005, 6, 214, 60, 0, 2005, 434, 1, 0, 0, 0, 2006, 2007, 3, 181, 88, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2009, 6, 215, 61, 0, 2009, 436, 1, 0, 0, 0, 2010, 2011, 3, 187, 91, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2013, 6, 216, 62, 0, 2013, 438, 1, 0, 0, 0, 2014, 2015, 3, 189, 92, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2017, 6, 217, 63, 0, 2017, 440, 1, 0, 0, 0, 2018, 2019, 3, 115, 55, 0, 2019, 2020, 1, 0, 0, 0, 2020, 2021, 6, 218, 64, 0, 2021, 442, 1, 0, 0, 0, 2022, 2023, 3, 191, 93, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2025, 6, 219, 65, 0, 2025, 444, 1, 0, 0, 0, 2026, 2027, 3, 193, 94, 0, 2027, 2028, 1, 0, 0, 0, 2028, 2029, 6, 220, 66, 0, 2029, 446, 1, 0, 0, 0, 2030, 2031, 3, 195, 95, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2033, 6, 221, 67, 0, 2033, 448, 1, 0, 0, 0, 2034, 2035, 3, 201, 98, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2037, 6, 222, 68, 0, 2037, 450, 1, 0, 0, 0, 2038, 2039, 3, 203, 99, 0, 2039, 2040, 1, 0, 0, 0, 2040, 2041, 6, 223, 69, 0, 2041, 452, 1, 0, 0, 0, 2042, 2043, 3, 205, 100, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2045, 6, 224, 70, 0, 2045, 454, 1, 0, 0, 0, 2046, 2047, 3, 207, 101, 0, 2047, 2048, 1, 0, 0, 0, 2048, 2049, 6, 225, 71, 0, 2049, 456, 1, 0, 0, 0, 2050, 2051, 3, 169, 82, 0, 2051, 2052, 1, 0, 0, 0, 2052, 2053, 6, 226, 72, 0, 2053, 458, 1, 0, 0, 0, 2054, 2055, 3, 171, 83, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2057, 6, 227, 73, 0, 2057, 460, 1, 0, 0, 0, 2058, 2059, 3, 173, 84, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2061, 6, 228, 74, 0, 2061, 462, 1, 0, 0, 0, 2062, 2063, 3, 175, 85, 0, 2063, 2064, 1, 0, 0, 0, 2064, 2065, 6, 229, 75, 0, 2065, 464, 1, 0, 0, 0, 2066, 2067, 3, 109, 52, 0, 2067, 2068, 1, 0, 0, 0, 2068, 2069, 6, 230, 76, 0, 2069, 466, 1, 0, 0, 0, 2070, 2071, 3, 111, 53, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2073, 6, 231, 77, 0, 2073, 468, 1, 0, 0, 0, 2074, 2075, 3, 113, 54, 0, 2075, 2076, 1, 0, 0, 0, 2076, 2077, 6, 232, 78, 0, 2077, 470, 1, 0, 0, 0, 2078, 2079, 3, 151, 73, 0, 2079, 2080, 1, 0, 0, 0, 2080, 2081, 6, 233, 79, 0, 2081, 472, 1, 0, 0, 0, 2082, 2083, 3, 153, 74, 0, 2083, 2084, 1, 0, 0, 0, 2084, 2085, 6, 234, 80, 0, 2085, 474, 1, 0, 0, 0, 2086, 2087, 3, 155, 75, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2089, 6, 235, 81, 0, 2089, 476, 1, 0, 0, 0, 2090, 2091, 3, 157, 76, 0, 2091, 2092, 1, 0, 0, 0, 2092, 2093, 6, 236, 82, 0, 2093, 478, 1, 0, 0, 0, 2094, 2095, 3, 159, 77, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2097, 6, 237, 83, 0, 2097, 480, 1, 0, 0, 0, 2098, 2099, 3, 161, 78, 0, 2099, 2100, 1, 0, 0, 0, 2100, 2101, 6, 238, 84, 0, 2101, 482, 1, 0, 0, 0, 2102, 2103, 3, 163, 79, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2105, 6, 239, 85, 0, 2105, 484, 1, 0, 0, 0, 2106, 2107, 3, 165, 80, 0, 2107, 2108, 1, 0, 0, 0, 2108, 2109, 6, 240, 86, 0, 2109, 486, 1, 0, 0, 0, 2110, 2111, 3, 167, 81, 0, 2111, 2112, 1, 0, 0, 0, 2112, 2113, 6, 241, 87, 0, 2113, 488, 1, 0, 0, 0, 2114, 2115, 3, 211, 103, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2117, 6, 242, 88, 0, 2117, 490, 1, 0, 0, 0, 2118, 2119, 3, 213, 104, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2121, 6, 243, 89, 0, 2121, 492, 1, 0, 0, 0, 2122, 2123, 3, 215, 105, 0, 2123, 2124, 1, 0, 0, 0, 2124, 2125, 6, 244, 90, 0, 2125, 494, 1, 0, 0, 0, 2126, 2127, 3, 217, 106, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2129, 6, 245, 91, 0, 2129, 496, 1, 0, 0, 0, 2130, 2131, 3, 219, 107, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2133, 6, 246, 92, 0, 2133, 498, 1, 0, 0, 0, 2134, 2135, 3, 221, 108, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2137, 6, 247, 93, 0, 2137, 500, 1, 0, 0, 0, 2138, 2139, 3, 223, 109, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2141, 6, 248, 94, 0, 2141, 502, 1, 0, 0, 0, 2142, 2143, 3, 225, 110, 0, 2143, 2144, 1, 0, 0, 0, 2144, 2145, 6, 249, 95, 0, 2145, 504, 1, 0, 0, 0, 2146, 2147, 3, 227, 111, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2149, 6, 250, 96, 0, 2149, 506, 1, 0, 0, 0, 2150, 2151, 3, 229, 112, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2153, 6, 251, 97, 0, 2153, 508, 1, 0, 0, 0, 2154, 2155, 3, 231, 113, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2157, 6, 252, 98, 0, 2157, 510, 1, 0, 0, 0, 2158, 2159, 3, 233, 114, 0, 2159, 2160, 1, 0, 0, 0, 2160, 2161, 6, 253, 99, 0, 2161, 512, 1, 0, 0, 0, 2162, 2163, 3, 235, 115, 0, 2163, 2164, 1, 0, 0, 0, 2164, 2165, 6, 254, 100, 0, 2165, 514, 1, 0, 0, 0, 2166, 2167, 3, 237, 116, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2169, 6, 255, 101, 0, 2169, 516, 1, 0, 0, 0, 2170, 2171, 3, 239, 117, 0, 2171, 2172, 1, 0, 0, 0, 2172, 2173, 6, 256, 102, 0, 2173, 518, 1, 0, 0, 0, 2174, 2175, 3, 241, 118, 0, 2175, 2176, 1, 0, 0, 0, 2176, 2177, 6, 257, 103, 0, 2177, 520, 1, 0, 0, 0, 2178, 2179, 3, 243, 119, 0, 2179, 2180, 1, 0, 0, 0, 2180, 2181, 6, 258, 104, 0, 2181, 522, 1, 0, 0, 0, 2182, 2183, 3, 245, 120, 0, 2183, 2184, 1, 0, 0, 0, 2184, 2185, 6, 259, 105, 0, 2185, 524, 1, 0, 0, 0, 2186, 2187, 3, 247, 121, 0, 2187, 2188, 1, 0, 0, 0, 2188, 2189, 6, 260, 106, 0, 2189, 526, 1, 0, 0, 0, 2190, 2191, 3, 249, 122, 0, 2191, 2192, 1, 0, 0, 0, 2192, 2193, 6, 261, 107, 0, 2193, 528, 1, 0, 0, 0, 2194, 2195, 3, 251, 123, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2197, 6, 262, 108, 0, 2197, 530, 1, 0, 0, 0, 2198, 2199, 3, 253, 124, 0, 2199, 2200, 1, 0, 0, 0, 2200, 2201, 6, 263, 109, 0, 2201, 532, 1, 0, 0, 0, 2202, 2203, 3, 255, 125, 0, 2203, 2204, 1, 0, 0, 0, 2204, 2205, 6, 264, 110, 0, 2205, 534, 1, 0, 0, 0, 2206, 2207, 3, 257, 126, 0, 2207, 2208, 1, 0, 0, 0, 2208, 2209, 6, 265, 111, 0, 2209, 536, 1, 0, 0, 0, 2210, 2211, 3, 259, 127, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2213, 6, 266, 112, 0, 2213, 538, 1, 0, 0, 0, 2214, 2215, 3, 289, 142, 0, 2215, 2216, 1, 0, 0, 0, 2216, 2217, 6, 267, 113, 0, 2217, 540, 1, 0, 0, 0, 2218, 2219, 3, 273, 134, 0, 2219, 2220, 1, 0, 0, 0, 2220, 2221, 6, 268, 114, 0, 2221, 542, 1, 0, 0, 0, 2222, 2223, 3, 281, 138, 0, 2223, 2224, 1, 0, 0, 0, 2224, 2225, 6, 269, 115, 0, 2225, 544, 1, 0, 0, 0, 2226, 2227, 3, 285, 140, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2229, 6, 270, 116, 0, 2229, 546, 1, 0, 0, 0, 2230, 2231, 3, 301, 148, 0, 2231, 2232, 1, 0, 0, 0, 2232, 2233, 6, 271, 117, 0, 2233, 548, 1, 0, 0, 0, 2234, 2235, 3, 265, 130, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2237, 6, 272, 118, 0, 2237, 550, 1, 0, 0, 0, 2238, 2239, 3, 291, 143, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2241, 6, 273, 119, 0, 2241, 552, 1, 0, 0, 0, 2242, 2243, 3, 271, 133, 0, 2243, 2244, 1, 0, 0, 0, 2244, 2245, 6, 274, 120, 0, 2245, 554, 1, 0, 0, 0, 2246, 2247, 3, 293, 144, 0, 2247, 2248, 1, 0, 0, 0, 2248, 2249, 6, 275, 121, 0, 2249, 556, 1, 0, 0, 0, 2250, 2251, 3, 295, 145, 0, 2251, 2252, 1, 0, 0, 0, 2252, 2253, 6, 276, 122, 0, 2253, 558, 1, 0, 0, 0, 2254, 2255, 3, 297, 146, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2257, 6, 277, 123, 0, 2257, 560, 1, 0, 0, 0, 2258, 2261, 3, 9, 2, 0, 2259, 2261, 3, 7, 1, 0, 2260, 2258, 1, 0, 0, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2263, 6, 278, 0, 0, 2263, 562, 1, 0, 0, 0, 2264, 2265, 3, 11, 3, 0, 2265, 2266, 1, 0, 0, 0, 2266, 2267, 6, 279, 1, 0, 2267, 564, 1, 0, 0, 0, 2268, 2269, 3, 13, 4, 0, 2269, 2270, 1, 0, 0, 0, 2270, 2271, 6, 280, 1, 0, 2271, 566, 1, 0, 0, 0, 2272, 2273, 5, 34, 0, 0, 2273, 2274, 1, 0, 0, 0, 2274, 2275, 6, 281, 5, 0, 2275, 568, 1, 0, 0, 0, 2276, 2277, 3, 299, 147, 0, 2277, 570, 1, 0, 0, 0, 2278, 2280, 8, 19, 0, 0, 2279, 2278, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 2279, 1, 0, 0, 0, 2281, 2282, 1, 0, 0, 0, 2282, 2285, 1, 0, 0, 0, 2283, 2285, 5, 36, 0, 0, 2284, 2279, 1, 0, 0, 0, 2284, 2283, 1, 0, 0, 0, 2285, 572, 1, 0, 0, 0, 2286, 2287, 5, 92, 0, 0, 2287, 2290, 9, 0, 0, 0, 2288, 2290, 3, 305, 150, 0, 2289, 2286, 1, 0, 0, 0, 2289, 2288, 1, 0, 0, 0, 2290, 574, 1, 0, 0, 0, 2291, 2292, 5, 36, 0, 0, 2292, 2293, 5, 123, 0, 0, 2293, 2294, 1, 0, 0, 0, 2294, 2295, 6, 285, 124, 0, 2295, 576, 1, 0, 0, 0, 2296, 2298, 3, 579, 287, 0, 2297, 2296, 1, 0, 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2299, 1, 0, 0, 0, 2299, 2300, 5, 34, 0, 0, 2300, 2301, 5, 34, 0, 0, 2301, 2302, 5, 34, 0, 0, 2302, 2303, 1, 0, 0, 0, 2303, 2304, 6, 286, 5, 0, 2304, 578, 1, 0, 0, 0, 2305, 2307, 5, 34, 0, 0, 2306, 2305, 1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2306, 1, 0, 0, 0, 2308, 2309, 1, 0, 0, 0, 2309, 580, 1, 0, 0, 0, 2310, 2311, 3, 299, 147, 0, 2311, 582, 1, 0, 0, 0, 2312, 2314, 8, 19, 0, 0, 2313, 2312, 1, 0, 0, 0, 2314, 2315, 1, 0, 0, 0, 2315, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2319, 1, 0, 0, 0, 2317, 2319, 5, 36, 0, 0, 2318, 2313, 1, 0, 0, 0, 2318, 2317, 1, 0, 0, 0, 2319, 584, 1, 0, 0, 0, 2320, 2321, 5, 92, 0, 0, 2321, 2322, 9, 0, 0, 0, 2322, 586, 1, 0, 0, 0, 2323, 2324, 5, 36, 0, 0, 2324, 2325, 5, 123, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2327, 6, 291, 124, 0, 2327, 588, 1, 0, 0, 0, 2328, 2329, 3, 13, 4, 0, 2329, 2330, 1, 0, 0, 0, 2330, 2331, 6, 292, 1, 0, 2331, 590, 1, 0, 0, 0, 2332, 2333, 3, 31, 13, 0, 2333, 2334, 1, 0, 0, 0, 2334, 2335, 6, 293, 5, 0, 2335, 2336, 6, 293, 11, 0, 2336, 592, 1, 0, 0, 0, 2337, 2338, 3, 21, 8, 0, 2338, 2339, 1, 0, 0, 0, 2339, 2340, 6, 294, 2, 0, 2340, 2341, 6, 294, 8, 0, 2341, 594, 1, 0, 0, 0, 2342, 2343, 3, 25, 10, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2345, 6, 295, 2, 0, 2345, 2346, 6, 295, 9, 0, 2346, 596, 1, 0, 0, 0, 2347, 2348, 5, 41, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 2350, 6, 296, 6, 0, 2350, 598, 1, 0, 0, 0, 2351, 2352, 5, 93, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2354, 6, 297, 7, 0, 2354, 600, 1, 0, 0, 0, 2355, 2356, 3, 29, 12, 0, 2356, 2357, 1, 0, 0, 0, 2357, 2358, 6, 298, 124, 0, 2358, 2359, 6, 298, 10, 0, 2359, 602, 1, 0, 0, 0, 2360, 2361, 3, 17, 6, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2363, 6, 299, 12, 0, 2363, 604, 1, 0, 0, 0, 2364, 2365, 3, 19, 7, 0, 2365, 2366, 1, 0, 0, 0, 2366, 2367, 6, 300, 13, 0, 2367, 606, 1, 0, 0, 0, 2368, 2369, 3, 33, 14, 0, 2369, 2370, 1, 0, 0, 0, 2370, 2371, 6, 301, 14, 0, 2371, 608, 1, 0, 0, 0, 2372, 2373, 3, 35, 15, 0, 2373, 2374, 1, 0, 0, 0, 2374, 2375, 6, 302, 15, 0, 2375, 610, 1, 0, 0, 0, 2376, 2377, 3, 37, 16, 0, 2377, 2378, 1, 0, 0, 0, 2378, 2379, 6, 303, 16, 0, 2379, 612, 1, 0, 0, 0, 2380, 2381, 3, 39, 17, 0, 2381, 2382, 1, 0, 0, 0, 2382, 2383, 6, 304, 17, 0, 2383, 614, 1, 0, 0, 0, 2384, 2385, 3, 41, 18, 0, 2385, 2386, 1, 0, 0, 0, 2386, 2387, 6, 305, 18, 0, 2387, 616, 1, 0, 0, 0, 2388, 2389, 3, 43, 19, 0, 2389, 2390, 1, 0, 0, 0, 2390, 2391, 6, 306, 19, 0, 2391, 618, 1, 0, 0, 0, 2392, 2393, 3, 45, 20, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 6, 307, 20, 0, 2395, 620, 1, 0, 0, 0, 2396, 2397, 3, 47, 21, 0, 2397, 2398, 1, 0, 0, 0, 2398, 2399, 6, 308, 21, 0, 2399, 622, 1, 0, 0, 0, 2400, 2401, 3, 49, 22, 0, 2401, 2402, 1, 0, 0, 0, 2402, 2403, 6, 309, 22, 0, 2403, 624, 1, 0, 0, 0, 2404, 2405, 3, 51, 23, 0, 2405, 2406, 1, 0, 0, 0, 2406, 2407, 6, 310, 23, 0, 2407, 626, 1, 0, 0, 0, 2408, 2409, 3, 53, 24, 0, 2409, 2410, 1, 0, 0, 0, 2410, 2411, 6, 311, 24, 0, 2411, 628, 1, 0, 0, 0, 2412, 2413, 3, 55, 25, 0, 2413, 2414, 1, 0, 0, 0, 2414, 2415, 6, 312, 25, 0, 2415, 630, 1, 0, 0, 0, 2416, 2417, 3, 57, 26, 0, 2417, 2418, 1, 0, 0, 0, 2418, 2419, 6, 313, 26, 0, 2419, 632, 1, 0, 0, 0, 2420, 2421, 3, 59, 27, 0, 2421, 2422, 1, 0, 0, 0, 2422, 2423, 6, 314, 27, 0, 2423, 634, 1, 0, 0, 0, 2424, 2425, 3, 61, 28, 0, 2425, 2426, 1, 0, 0, 0, 2426, 2427, 6, 315, 28, 0, 2427, 636, 1, 0, 0, 0, 2428, 2429, 3, 63, 29, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2431, 6, 316, 29, 0, 2431, 638, 1, 0, 0, 0, 2432, 2433, 3, 65, 30, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2435, 6, 317, 30, 0, 2435, 640, 1, 0, 0, 0, 2436, 2437, 3, 67, 31, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2439, 6, 318, 31, 0, 2439, 642, 1, 0, 0, 0, 2440, 2441, 3, 69, 32, 0, 2441, 2442, 1, 0, 0, 0, 2442, 2443, 6, 319, 32, 0, 2443, 644, 1, 0, 0, 0, 2444, 2445, 3, 71, 33, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2447, 6, 320, 33, 0, 2447, 646, 1, 0, 0, 0, 2448, 2449, 3, 73, 34, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2451, 6, 321, 34, 0, 2451, 648, 1, 0, 0, 0, 2452, 2453, 3, 75, 35, 0, 2453, 2454, 1, 0, 0, 0, 2454, 2455, 6, 322, 36, 0, 2455, 650, 1, 0, 0, 0, 2456, 2457, 3, 77, 36, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2459, 6, 323, 37, 0, 2459, 652, 1, 0, 0, 0, 2460, 2461, 3, 79, 37, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 6, 324, 38, 0, 2463, 654, 1, 0, 0, 0, 2464, 2465, 3, 81, 38, 0, 2465, 2466, 1, 0, 0, 0, 2466, 2467, 6, 325, 39, 0, 2467, 656, 1, 0, 0, 0, 2468, 2469, 3, 83, 39, 0, 2469, 2470, 1, 0, 0, 0, 2470, 2471, 6, 326, 40, 0, 2471, 658, 1, 0, 0, 0, 2472, 2473, 3, 85, 40, 0, 2473, 2474, 1, 0, 0, 0, 2474, 2475, 6, 327, 41, 0, 2475, 660, 1, 0, 0, 0, 2476, 2477, 3, 87, 41, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2479, 6, 328, 42, 0, 2479, 662, 1, 0, 0, 0, 2480, 2481, 3, 89, 42, 0, 2481, 2482, 1, 0, 0, 0, 2482, 2483, 6, 329, 43, 0, 2483, 664, 1, 0, 0, 0, 2484, 2485, 3, 91, 43, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 6, 330, 44, 0, 2487, 666, 1, 0, 0, 0, 2488, 2489, 3, 93, 44, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2491, 6, 331, 45, 0, 2491, 668, 1, 0, 0, 0, 2492, 2493, 3, 95, 45, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2495, 6, 332, 46, 0, 2495, 670, 1, 0, 0, 0, 2496, 2497, 3, 97, 46, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2499, 6, 333, 47, 0, 2499, 672, 1, 0, 0, 0, 2500, 2501, 3, 99, 47, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2503, 6, 334, 48, 0, 2503, 674, 1, 0, 0, 0, 2504, 2505, 3, 177, 86, 0, 2505, 2506, 1, 0, 0, 0, 2506, 2507, 6, 335, 125, 0, 2507, 676, 1, 0, 0, 0, 2508, 2509, 3, 179, 87, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2511, 6, 336, 61, 0, 2511, 678, 1, 0, 0, 0, 2512, 2513, 3, 181, 88, 0, 2513, 680, 1, 0, 0, 0, 2514, 2515, 3, 183, 89, 0, 2515, 2516, 1, 0, 0, 0, 2516, 2517, 6, 338, 49, 0, 2517, 682, 1, 0, 0, 0, 2518, 2519, 3, 185, 90, 0, 2519, 2520, 1, 0, 0, 0, 2520, 2521, 6, 339, 50, 0, 2521, 684, 1, 0, 0, 0, 2522, 2523, 3, 101, 48, 0, 2523, 2524, 1, 0, 0, 0, 2524, 2525, 6, 340, 51, 0, 2525, 686, 1, 0, 0, 0, 2526, 2527, 3, 103, 49, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2529, 6, 341, 52, 0, 2529, 688, 1, 0, 0, 0, 2530, 2531, 3, 105, 50, 0, 2531, 2532, 1, 0, 0, 0, 2532, 2533, 6, 342, 53, 0, 2533, 690, 1, 0, 0, 0, 2534, 2535, 3, 107, 51, 0, 2535, 2536, 1, 0, 0, 0, 2536, 2537, 6, 343, 54, 0, 2537, 692, 1, 0, 0, 0, 2538, 2539, 3, 261, 128, 0, 2539, 2540, 1, 0, 0, 0, 2540, 2541, 6, 344, 3, 0, 2541, 2542, 6, 344, 55, 0, 2542, 694, 1, 0, 0, 0, 2543, 2544, 3, 263, 129, 0, 2544, 2545, 1, 0, 0, 0, 2545, 2546, 6, 345, 4, 0, 2546, 2547, 6, 345, 56, 0, 2547, 696, 1, 0, 0, 0, 2548, 2549, 3, 289, 142, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2551, 6, 346, 113, 0, 2551, 698, 1, 0, 0, 0, 2552, 2553, 3, 273, 134, 0, 2553, 2554, 1, 0, 0, 0, 2554, 2555, 6, 347, 114, 0, 2555, 700, 1, 0, 0, 0, 2556, 2557, 3, 281, 138, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2559, 6, 348, 115, 0, 2559, 702, 1, 0, 0, 0, 2560, 2561, 3, 285, 140, 0, 2561, 2562, 1, 0, 0, 0, 2562, 2563, 6, 349, 116, 0, 2563, 704, 1, 0, 0, 0, 2564, 2565, 3, 301, 148, 0, 2565, 2566, 1, 0, 0, 0, 2566, 2567, 6, 350, 117, 0, 2567, 706, 1, 0, 0, 0, 2568, 2569, 3, 265, 130, 0, 2569, 2570, 1, 0, 0, 0, 2570, 2571, 6, 351, 118, 0, 2571, 708, 1, 0, 0, 0, 2572, 2573, 3, 291, 143, 0, 2573, 2574, 1, 0, 0, 0, 2574, 2575, 6, 352, 119, 0, 2575, 710, 1, 0, 0, 0, 2576, 2577, 3, 271, 133, 0, 2577, 2578, 1, 0, 0, 0, 2578, 2579, 6, 353, 120, 0, 2579, 712, 1, 0, 0, 0, 2580, 2581, 3, 293, 144, 0, 2581, 2582, 1, 0, 0, 0, 2582, 2583, 6, 354, 121, 0, 2583, 714, 1, 0, 0, 0, 2584, 2585, 3, 295, 145, 0, 2585, 2586, 1, 0, 0, 0, 2586, 2587, 6, 355, 122, 0, 2587, 716, 1, 0, 0, 0, 2588, 2589, 3, 297, 146, 0, 2589, 2590, 1, 0, 0, 0, 2590, 2591, 6, 356, 123, 0, 2591, 718, 1, 0, 0, 0, 2592, 2595, 3, 9, 2, 0, 2593, 2595, 3, 7, 1, 0, 2594, 2592, 1, 0, 0, 0, 2594, 2593, 1, 0, 0, 0, 2595, 2596, 1, 0, 0, 0, 2596, 2597, 6, 357, 0, 0, 2597, 720, 1, 0, 0, 0, 2598, 2599, 3, 11, 3, 0, 2599, 2600, 1, 0, 0, 0, 2600, 2601, 6, 358, 1, 0, 2601, 722, 1, 0, 0, 0, 2602, 2603, 3, 13, 4, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2605, 6, 359, 1, 0, 2605, 724, 1, 0, 0, 0, 85, 0, 1, 2, 3, 4, 731, 741, 743, 757, 769, 1136, 1138, 1146, 1148, 1441, 1445, 1453, 1457, 1463, 1465, 1470, 1473, 1478, 1483, 1485, 1492, 1496, 1501, 1506, 1510, 1515, 1517, 1524, 1526, 1531, 1536, 1541, 1543, 1548, 1553, 1555, 1559, 1564, 1573, 1579, 1581, 1589, 1594, 1599, 1605, 1610, 1615, 1617, 1624, 1626, 1631, 1636, 1641, 1643, 1648, 1653, 1655, 1659, 1672, 1674, 1684, 1686, 1700, 1709, 1714, 1716, 1723, 1726, 1740, 1746, 1764, 2260, 2281, 2284, 2289, 2297, 2308, 2315, 2318, 2594, 126, 0, 1, 0, 6, 0, 0, 5, 1, 0, 5, 2, 0, 5, 3, 0, 4, 0, 0, 7, 10, 0, 7, 12, 0, 7, 9, 0, 7, 11, 0, 7, 13, 0, 7, 14, 0, 7, 7, 0, 7, 8, 0, 7, 15, 0, 7, 16, 0, 7, 17, 0, 7, 18, 0, 7, 19, 0, 7, 20, 0, 7, 21, 0, 7, 22, 0, 7, 23, 0, 7, 24, 0, 7, 25, 0, 7, 26, 0, 7, 27, 0, 7, 28, 0, 7, 29, 0, 7, 30, 0, 7, 31, 0, 7, 32, 0, 7, 33, 0, 7, 34, 0, 7, 35, 0, 7, 6, 0, 7, 36, 0, 7, 37, 0, 7, 38, 0, 7, 39, 0, 7, 40, 0, 7, 41, 0, 7, 42, 0, 7, 43, 0, 7, 44, 0, 7, 45, 0, 7, 46, 0, 7, 47, 0, 7, 48, 0, 7, 90, 0, 7, 91, 0, 7, 49, 0, 7, 50, 0, 7, 51, 0, 7, 52, 0, 7, 129, 0, 7, 130, 0, 7, 63, 0, 7, 64, 0, 7, 62, 0, 7, 71, 0, 7, 89, 0, 7, 92, 0, 7, 93, 0, 7, 56, 0, 7, 94, 0, 7, 95, 0, 7, 96, 0, 7, 99, 0, 7, 100, 0, 7, 101, 0, 7, 102, 0, 7, 83, 0, 7, 84, 0, 7, 85, 0, 7, 86, 0, 7, 53, 0, 7, 54, 0, 7, 55, 0, 7, 74, 0, 7, 75, 0, 7, 76, 0, 7, 77, 0, 7, 78, 0, 7, 79, 0, 7, 80, 0, 7, 81, 0, 7, 82, 0, 7, 104, 0, 7, 105, 0, 7, 106, 0, 7, 107, 0, 7, 108, 0, 7, 109, 0, 7, 110, 0, 7, 111, 0, 7, 112, 0, 7, 113, 0, 7, 114, 0, 7, 115, 0, 7, 116, 0, 7, 117, 0, 7, 118, 0, 7, 119, 0, 7, 120, 0, 7, 121, 0, 7, 122, 0, 7, 123, 0, 7, 124, 0, 7, 125, 0, 7, 126, 0, 7, 127, 0, 7, 128, 0, 7, 138, 0, 7, 135, 0, 7, 136, 0, 7, 137, 0, 7, 144, 0, 7, 131, 0, 7, 139, 0, 7, 134, 0, 7, 140, 0, 7, 141, 0, 7, 142, 0, 5, 4, 0, 7, 88, 0] \ No newline at end of file diff --git a/src/main/java/KotlinLexer.java b/src/main/java/KotlinLexer.java new file mode 100644 index 0000000..a8c2641 --- /dev/null +++ b/src/main/java/KotlinLexer.java @@ -0,0 +1,2337 @@ +// Generated from KotlinLexer.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.Utils; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class KotlinLexer extends Lexer { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ShebangLine = 1, DelimitedComment = 2, LineComment = 3, WS = 4, NL = 5, RESERVED = 6, + DOT = 7, COMMA = 8, LPAREN = 9, RPAREN = 10, LSQUARE = 11, RSQUARE = 12, LCURL = 13, + RCURL = 14, MULT = 15, MOD = 16, DIV = 17, ADD = 18, SUB = 19, INCR = 20, DECR = 21, CONJ = 22, + DISJ = 23, EXCL = 24, COLON = 25, SEMICOLON = 26, ASSIGNMENT = 27, ADD_ASSIGNMENT = 28, + SUB_ASSIGNMENT = 29, MULT_ASSIGNMENT = 30, DIV_ASSIGNMENT = 31, MOD_ASSIGNMENT = 32, + ARROW = 33, DOUBLE_ARROW = 34, RANGE = 35, COLONCOLON = 36, Q_COLONCOLON = 37, DOUBLE_SEMICOLON = 38, + HASH = 39, AT = 40, QUEST = 41, ELVIS = 42, LANGLE = 43, RANGLE = 44, LE = 45, GE = 46, + EXCL_EQ = 47, EXCL_EQEQ = 48, AS_SAFE = 49, EQEQ = 50, EQEQEQ = 51, SINGLE_QUOTE = 52, + RETURN_AT = 53, CONTINUE_AT = 54, BREAK_AT = 55, FILE = 56, PACKAGE = 57, IMPORT = 58, + CLASS = 59, INTERFACE = 60, FUN = 61, OBJECT = 62, VAL = 63, VAR = 64, TYPE_ALIAS = 65, + CONSTRUCTOR = 66, BY = 67, COMPANION = 68, INIT = 69, THIS = 70, SUPER = 71, TYPEOF = 72, + WHERE = 73, IF = 74, ELSE = 75, WHEN = 76, TRY = 77, CATCH = 78, FINALLY = 79, FOR = 80, + DO = 81, WHILE = 82, THROW = 83, RETURN = 84, CONTINUE = 85, BREAK = 86, AS = 87, IS = 88, + IN = 89, NOT_IS = 90, NOT_IN = 91, OUT = 92, FIELD = 93, PROPERTY = 94, GET = 95, SET = 96, + GETTER = 97, SETTER = 98, RECEIVER = 99, PARAM = 100, SETPARAM = 101, DELEGATE = 102, + DYNAMIC = 103, PUBLIC = 104, PRIVATE = 105, PROTECTED = 106, INTERNAL = 107, ENUM = 108, + SEALED = 109, ANNOTATION = 110, DATA = 111, INNER = 112, TAILREC = 113, OPERATOR = 114, + INLINE = 115, INFIX = 116, EXTERNAL = 117, SUSPEND = 118, OVERRIDE = 119, ABSTRACT = 120, + FINAL = 121, OPEN = 122, CONST = 123, LATEINIT = 124, VARARG = 125, NOINLINE = 126, + CROSSINLINE = 127, REIFIED = 128, QUOTE_OPEN = 129, TRIPLE_QUOTE_OPEN = 130, RealLiteral = 131, + FloatLiteral = 132, DoubleLiteral = 133, LongLiteral = 134, IntegerLiteral = 135, + HexLiteral = 136, BinLiteral = 137, BooleanLiteral = 138, NullLiteral = 139, Identifier = 140, + LabelReference = 141, LabelDefinition = 142, FieldIdentifier = 143, CharacterLiteral = 144, + UNICODE_CLASS_LL = 145, UNICODE_CLASS_LM = 146, UNICODE_CLASS_LO = 147, UNICODE_CLASS_LT = 148, + UNICODE_CLASS_LU = 149, UNICODE_CLASS_ND = 150, UNICODE_CLASS_NL = 151, Inside_Comment = 152, + Inside_WS = 153, Inside_NL = 154, QUOTE_CLOSE = 155, LineStrRef = 156, LineStrText = 157, + LineStrEscapedChar = 158, LineStrExprStart = 159, TRIPLE_QUOTE_CLOSE = 160, + MultiLineStringQuote = 161, MultiLineStrRef = 162, MultiLineStrText = 163, MultiLineStrEscapedChar = 164, + MultiLineStrExprStart = 165, MultiLineNL = 166, StrExpr_IN = 167, StrExpr_Comment = 168, + StrExpr_WS = 169, StrExpr_NL = 170; + public static final int + Inside = 1, LineString = 2, MultiLineString = 3, StringExpression = 4; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE", "Inside", "LineString", "MultiLineString", "StringExpression" + }; + + private static String[] makeRuleNames() { + return new String[]{ + "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", + "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", + "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL", + "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", + "RANGE", "COLONCOLON", "Q_COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT", + "QUEST", "ELVIS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "FILE", "PACKAGE", "IMPORT", "CLASS", "INTERFACE", "FUN", + "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", + "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", + "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", "RETURN", "CONTINUE", + "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", "OUT", "FIELD", "PROPERTY", + "GET", "SET", "GETTER", "SETTER", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", + "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", "SEALED", + "ANNOTATION", "DATA", "INNER", "TAILREC", "OPERATOR", "INLINE", "INFIX", + "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", "OPEN", "CONST", + "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "LongLiteral", "IntegerLiteral", "DecDigit", "DecDigitNoZero", "UNICODE_CLASS_ND_NoZeros", + "HexLiteral", "HexDigit", "BinLiteral", "BinDigit", "BooleanLiteral", + "NullLiteral", "Identifier", "LabelReference", "LabelDefinition", "FieldIdentifier", + "CharacterLiteral", "EscapeSeq", "UniCharacterLiteral", "EscapedIdentifier", + "Letter", "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", + "Inside_RPAREN", "Inside_RSQUARE", "Inside_LPAREN", "Inside_LSQUARE", + "Inside_LCURL", "Inside_RCURL", "Inside_DOT", "Inside_COMMA", "Inside_MULT", + "Inside_MOD", "Inside_DIV", "Inside_ADD", "Inside_SUB", "Inside_INCR", + "Inside_DECR", "Inside_CONJ", "Inside_DISJ", "Inside_EXCL", "Inside_COLON", + "Inside_SEMICOLON", "Inside_ASSIGNMENT", "Inside_ADD_ASSIGNMENT", "Inside_SUB_ASSIGNMENT", + "Inside_MULT_ASSIGNMENT", "Inside_DIV_ASSIGNMENT", "Inside_MOD_ASSIGNMENT", + "Inside_ARROW", "Inside_DOUBLE_ARROW", "Inside_RANGE", "Inside_RESERVED", + "Inside_COLONCOLON", "Inside_Q_COLONCOLON", "Inside_DOUBLE_SEMICOLON", + "Inside_HASH", "Inside_AT", "Inside_QUEST", "Inside_ELVIS", "Inside_LANGLE", + "Inside_RANGLE", "Inside_LE", "Inside_GE", "Inside_EXCL_EQ", "Inside_EXCL_EQEQ", + "Inside_NOT_IS", "Inside_NOT_IN", "Inside_AS_SAFE", "Inside_EQEQ", "Inside_EQEQEQ", + "Inside_SINGLE_QUOTE", "Inside_QUOTE_OPEN", "Inside_TRIPLE_QUOTE_OPEN", + "Inside_VAL", "Inside_VAR", "Inside_OBJECT", "Inside_SUPER", "Inside_IN", + "Inside_OUT", "Inside_FIELD", "Inside_FILE", "Inside_PROPERTY", "Inside_GET", + "Inside_SET", "Inside_RECEIVER", "Inside_PARAM", "Inside_SETPARAM", "Inside_DELEGATE", + "Inside_THROW", "Inside_RETURN", "Inside_CONTINUE", "Inside_BREAK", "Inside_RETURN_AT", + "Inside_CONTINUE_AT", "Inside_BREAK_AT", "Inside_IF", "Inside_ELSE", + "Inside_WHEN", "Inside_TRY", "Inside_CATCH", "Inside_FINALLY", "Inside_FOR", + "Inside_DO", "Inside_WHILE", "Inside_PUBLIC", "Inside_PRIVATE", "Inside_PROTECTED", + "Inside_INTERNAL", "Inside_ENUM", "Inside_SEALED", "Inside_ANNOTATION", + "Inside_DATA", "Inside_INNER", "Inside_TAILREC", "Inside_OPERATOR", "Inside_INLINE", + "Inside_INFIX", "Inside_EXTERNAL", "Inside_SUSPEND", "Inside_OVERRIDE", + "Inside_ABSTRACT", "Inside_FINAL", "Inside_OPEN", "Inside_CONST", "Inside_LATEINIT", + "Inside_VARARG", "Inside_NOINLINE", "Inside_CROSSINLINE", "Inside_REIFIED", + "Inside_BooleanLiteral", "Inside_IntegerLiteral", "Inside_HexLiteral", + "Inside_BinLiteral", "Inside_CharacterLiteral", "Inside_RealLiteral", + "Inside_NullLiteral", "Inside_LongLiteral", "Inside_Identifier", "Inside_LabelReference", + "Inside_LabelDefinition", "Inside_Comment", "Inside_WS", "Inside_NL", + "QUOTE_CLOSE", "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", + "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", + "MultiLineStrEscapedChar", "MultiLineStrExprStart", "MultiLineNL", "StrExpr_RCURL", + "StrExpr_LPAREN", "StrExpr_LSQUARE", "StrExpr_RPAREN", "StrExpr_RSQUARE", + "StrExpr_LCURL", "StrExpr_DOT", "StrExpr_COMMA", "StrExpr_MULT", "StrExpr_MOD", + "StrExpr_DIV", "StrExpr_ADD", "StrExpr_SUB", "StrExpr_INCR", "StrExpr_DECR", + "StrExpr_CONJ", "StrExpr_DISJ", "StrExpr_EXCL", "StrExpr_COLON", "StrExpr_SEMICOLON", + "StrExpr_ASSIGNMENT", "StrExpr_ADD_ASSIGNMENT", "StrExpr_SUB_ASSIGNMENT", + "StrExpr_MULT_ASSIGNMENT", "StrExpr_DIV_ASSIGNMENT", "StrExpr_MOD_ASSIGNMENT", + "StrExpr_ARROW", "StrExpr_DOUBLE_ARROW", "StrExpr_RANGE", "StrExpr_COLONCOLON", + "StrExpr_Q_COLONCOLON", "StrExpr_DOUBLE_SEMICOLON", "StrExpr_HASH", "StrExpr_AT", + "StrExpr_QUEST", "StrExpr_ELVIS", "StrExpr_LANGLE", "StrExpr_RANGLE", + "StrExpr_LE", "StrExpr_GE", "StrExpr_EXCL_EQ", "StrExpr_EXCL_EQEQ", "StrExpr_AS", + "StrExpr_IS", "StrExpr_IN", "StrExpr_NOT_IS", "StrExpr_NOT_IN", "StrExpr_AS_SAFE", + "StrExpr_EQEQ", "StrExpr_EQEQEQ", "StrExpr_SINGLE_QUOTE", "StrExpr_QUOTE_OPEN", + "StrExpr_TRIPLE_QUOTE_OPEN", "StrExpr_BooleanLiteral", "StrExpr_IntegerLiteral", + "StrExpr_HexLiteral", "StrExpr_BinLiteral", "StrExpr_CharacterLiteral", + "StrExpr_RealLiteral", "StrExpr_NullLiteral", "StrExpr_LongLiteral", + "StrExpr_Identifier", "StrExpr_LabelReference", "StrExpr_LabelDefinition", + "StrExpr_Comment", "StrExpr_WS", "StrExpr_NL" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, null, null, null, null, null, "'...'", "'.'", "','", "'('", null, + "'['", null, "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", + "'--'", "'&&'", "'||'", "'!'", "':'", "';'", "'='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "'?::'", "';;'", "'#'", + "'@'", "'?'", "'?:'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", + "'as?'", "'=='", "'==='", "'''", null, null, null, "'@file'", "'package'", + "'import'", "'class'", "'interface'", "'fun'", "'object'", "'val'", "'var'", + "'typealias'", "'constructor'", "'by'", "'companion'", "'init'", "'this'", + "'super'", "'typeof'", "'where'", "'if'", "'else'", "'when'", "'try'", + "'catch'", "'finally'", "'for'", "'do'", "'while'", "'throw'", "'return'", + "'continue'", "'break'", "'as'", "'is'", "'in'", null, null, "'out'", + "'@field'", "'@property'", "'@get'", "'@set'", "'get'", "'set'", "'@receiver'", + "'@param'", "'@setparam'", "'@delegate'", "'dynamic'", "'public'", "'private'", + "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", + "'inner'", "'tailrec'", "'operator'", "'inline'", "'infix'", "'external'", + "'suspend'", "'override'", "'abstract'", "'final'", "'open'", "'const'", + "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", "'reified'", + null, "'\"\"\"'", null, null, null, null, null, null, null, null, "'null'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", + "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", + "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL", + "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", + "RANGE", "COLONCOLON", "Q_COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT", + "QUEST", "ELVIS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "FILE", "PACKAGE", "IMPORT", "CLASS", "INTERFACE", "FUN", + "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", + "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", + "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", "RETURN", "CONTINUE", + "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", "OUT", "FIELD", "PROPERTY", + "GET", "SET", "GETTER", "SETTER", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", + "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", "SEALED", + "ANNOTATION", "DATA", "INNER", "TAILREC", "OPERATOR", "INLINE", "INFIX", + "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", "OPEN", "CONST", + "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "LongLiteral", "IntegerLiteral", "HexLiteral", "BinLiteral", "BooleanLiteral", + "NullLiteral", "Identifier", "LabelReference", "LabelDefinition", "FieldIdentifier", + "CharacterLiteral", "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", + "Inside_Comment", "Inside_WS", "Inside_NL", "QUOTE_CLOSE", "LineStrRef", + "LineStrText", "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", "MultiLineStrEscapedChar", + "MultiLineStrExprStart", "MultiLineNL", "StrExpr_IN", "StrExpr_Comment", + "StrExpr_WS", "StrExpr_NL" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public KotlinLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @Override + public String getGrammarFileName() { + return "KotlinLexer.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + public ATN getATN() { + return _ATN; + } + + private static final String _serializedATNSegment0 = + "\u0004\u0000\u00aa\u0a2e\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff" + + "\uffff\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002" + + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002" + + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002" + + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002" + + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e" + + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011" + + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014" + + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017" + + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a" + + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d" + + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!" + + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002" + + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002" + + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002" + + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002" + + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002" + + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002" + + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002" + + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002" + + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002" + + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002" + + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002" + + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002" + + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002" + + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002" + + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002" + + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002" + + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002" + + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002" + + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f" + + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082" + + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085" + + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088" + + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b" + + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e" + + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091" + + "\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094" + + "\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097" + + "\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a" + + "\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d" + + "\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0" + + "\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3" + + "\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6" + + "\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9" + + "\u0002\u00aa\u0007\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac" + + "\u0002\u00ad\u0007\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af" + + "\u0002\u00b0\u0007\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2" + + "\u0002\u00b3\u0007\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5" + + "\u0002\u00b6\u0007\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8" + + "\u0002\u00b9\u0007\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb" + + "\u0002\u00bc\u0007\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be" + + "\u0002\u00bf\u0007\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1" + + "\u0002\u00c2\u0007\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4" + + "\u0002\u00c5\u0007\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7" + + "\u0002\u00c8\u0007\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca" + + "\u0002\u00cb\u0007\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd" + + "\u0002\u00ce\u0007\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0" + + "\u0002\u00d1\u0007\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3" + + "\u0002\u00d4\u0007\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6" + + "\u0002\u00d7\u0007\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9" + + "\u0002\u00da\u0007\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc" + + "\u0002\u00dd\u0007\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df" + + "\u0002\u00e0\u0007\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2" + + "\u0002\u00e3\u0007\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5" + + "\u0002\u00e6\u0007\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8" + + "\u0002\u00e9\u0007\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb" + + "\u0002\u00ec\u0007\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee" + + "\u0002\u00ef\u0007\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1" + + "\u0002\u00f2\u0007\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4" + + "\u0002\u00f5\u0007\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7" + + "\u0002\u00f8\u0007\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa" + + "\u0002\u00fb\u0007\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd" + + "\u0002\u00fe\u0007\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100" + + "\u0002\u0101\u0007\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103" + + "\u0002\u0104\u0007\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106" + + "\u0002\u0107\u0007\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109" + + "\u0002\u010a\u0007\u010a\u0002\u010b\u0007\u010b\u0002\u010c\u0007\u010c" + + "\u0002\u010d\u0007\u010d\u0002\u010e\u0007\u010e\u0002\u010f\u0007\u010f" + + "\u0002\u0110\u0007\u0110\u0002\u0111\u0007\u0111\u0002\u0112\u0007\u0112" + + "\u0002\u0113\u0007\u0113\u0002\u0114\u0007\u0114\u0002\u0115\u0007\u0115" + + "\u0002\u0116\u0007\u0116\u0002\u0117\u0007\u0117\u0002\u0118\u0007\u0118" + + "\u0002\u0119\u0007\u0119\u0002\u011a\u0007\u011a\u0002\u011b\u0007\u011b" + + "\u0002\u011c\u0007\u011c\u0002\u011d\u0007\u011d\u0002\u011e\u0007\u011e" + + "\u0002\u011f\u0007\u011f\u0002\u0120\u0007\u0120\u0002\u0121\u0007\u0121" + + "\u0002\u0122\u0007\u0122\u0002\u0123\u0007\u0123\u0002\u0124\u0007\u0124" + + "\u0002\u0125\u0007\u0125\u0002\u0126\u0007\u0126\u0002\u0127\u0007\u0127" + + "\u0002\u0128\u0007\u0128\u0002\u0129\u0007\u0129\u0002\u012a\u0007\u012a" + + "\u0002\u012b\u0007\u012b\u0002\u012c\u0007\u012c\u0002\u012d\u0007\u012d" + + "\u0002\u012e\u0007\u012e\u0002\u012f\u0007\u012f\u0002\u0130\u0007\u0130" + + "\u0002\u0131\u0007\u0131\u0002\u0132\u0007\u0132\u0002\u0133\u0007\u0133" + + "\u0002\u0134\u0007\u0134\u0002\u0135\u0007\u0135\u0002\u0136\u0007\u0136" + + "\u0002\u0137\u0007\u0137\u0002\u0138\u0007\u0138\u0002\u0139\u0007\u0139" + + "\u0002\u013a\u0007\u013a\u0002\u013b\u0007\u013b\u0002\u013c\u0007\u013c" + + "\u0002\u013d\u0007\u013d\u0002\u013e\u0007\u013e\u0002\u013f\u0007\u013f" + + "\u0002\u0140\u0007\u0140\u0002\u0141\u0007\u0141\u0002\u0142\u0007\u0142" + + "\u0002\u0143\u0007\u0143\u0002\u0144\u0007\u0144\u0002\u0145\u0007\u0145" + + "\u0002\u0146\u0007\u0146\u0002\u0147\u0007\u0147\u0002\u0148\u0007\u0148" + + "\u0002\u0149\u0007\u0149\u0002\u014a\u0007\u014a\u0002\u014b\u0007\u014b" + + "\u0002\u014c\u0007\u014c\u0002\u014d\u0007\u014d\u0002\u014e\u0007\u014e" + + "\u0002\u014f\u0007\u014f\u0002\u0150\u0007\u0150\u0002\u0151\u0007\u0151" + + "\u0002\u0152\u0007\u0152\u0002\u0153\u0007\u0153\u0002\u0154\u0007\u0154" + + "\u0002\u0155\u0007\u0155\u0002\u0156\u0007\u0156\u0002\u0157\u0007\u0157" + + "\u0002\u0158\u0007\u0158\u0002\u0159\u0007\u0159\u0002\u015a\u0007\u015a" + + "\u0002\u015b\u0007\u015b\u0002\u015c\u0007\u015c\u0002\u015d\u0007\u015d" + + "\u0002\u015e\u0007\u015e\u0002\u015f\u0007\u015f\u0002\u0160\u0007\u0160" + + "\u0002\u0161\u0007\u0161\u0002\u0162\u0007\u0162\u0002\u0163\u0007\u0163" + + "\u0002\u0164\u0007\u0164\u0002\u0165\u0007\u0165\u0002\u0166\u0007\u0166" + + "\u0002\u0167\u0007\u0167\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000" + + "\u0005\u0000\u02da\b\u0000\n\u0000\f\u0000\u02dd\t\u0000\u0001\u0000\u0001" + + "\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0005" + + "\u0001\u02e6\b\u0001\n\u0001\f\u0001\u02e9\t\u0001\u0001\u0001\u0001\u0001" + + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002" + + "\u0001\u0002\u0005\u0002\u02f4\b\u0002\n\u0002\f\u0002\u02f7\t\u0002\u0001" + + "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001" + + "\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0302\b\u0004\u0001\u0005\u0001" + + "\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0001" + + "\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\n\u0001\n" + + "\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001" + + "\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010" + + "\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013" + + "\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015" + + "\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017" + + "\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a" + + "\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c" + + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e" + + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001!\u0001" + + "!\u0001!\u0001\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001$\u0001$\u0001" + + "$\u0001$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001\'\u0001\'\u0001(\u0001" + + "(\u0001)\u0001)\u0001)\u0001*\u0001*\u0001+\u0001+\u0001,\u0001,\u0001" + + ",\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001" + + "/\u00010\u00010\u00010\u00010\u00011\u00011\u00011\u00012\u00012\u0001" + + "2\u00012\u00013\u00013\u00014\u00014\u00014\u00014\u00014\u00014\u0001" + + "4\u00014\u00014\u00014\u00015\u00015\u00015\u00015\u00015\u00015\u0001" + + "5\u00015\u00015\u00015\u00015\u00015\u00016\u00016\u00016\u00016\u0001" + + "6\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u0001" + + "7\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00019\u0001" + + "9\u00019\u00019\u00019\u00019\u00019\u0001:\u0001:\u0001:\u0001:\u0001" + + ":\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001" + + ";\u0001;\u0001<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001" + + "=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001" + + "?\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001" + + "@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001" + + "A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001" + + "C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001" + + "D\u0001E\u0001E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001" + + "F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001" + + "H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001J\u0001J\u0001" + + "J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001" + + "L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001N\u0001N\u0001" + + "N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001O\u0001O\u0001" + + "P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001" + + "R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001S\u0001" + + "S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001" + + "T\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001" + + "W\u0001W\u0001W\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001" + + "Y\u0001Y\u0004Y\u0471\bY\u000bY\fY\u0472\u0001Z\u0001Z\u0001Z\u0001Z\u0001" + + "Z\u0001Z\u0004Z\u047b\bZ\u000bZ\fZ\u047c\u0001[\u0001[\u0001[\u0001[\u0001" + + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001]\u0001]\u0001" + + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001" + + "^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001_\u0001_\u0001`\u0001`\u0001" + + "`\u0001`\u0001a\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001b\u0001" + + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001" + + "c\u0001c\u0001c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001" + + "d\u0001d\u0001d\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001" + + "e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001" + + "f\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001h\u0001h\u0001" + + "h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001" + + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001" + + "j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001k\u0001k\u0001k\u0001" + + "l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001" + + "m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001" + + "n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001p\u0001" + + "p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001" + + "q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001r\u0001r\u0001r\u0001r\u0001" + + "r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001" + + "t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001u\u0001u\u0001" + + "u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001" + + "v\u0001v\u0001v\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001" + + "w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001" + + "y\u0001y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001z\u0001" + + "z\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001" + + "|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001" + + "}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001~\u0001~\u0001~\u0001~\u0001" + + "~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f" + + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f" + + "\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081" + + "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082" + + "\u0003\u0082\u05a2\b\u0082\u0001\u0083\u0001\u0083\u0003\u0083\u05a6\b" + + "\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0005\u0084\u05ac" + + "\b\u0084\n\u0084\f\u0084\u05af\t\u0084\u0001\u0084\u0003\u0084\u05b2\b" + + "\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0005\u0084\u05b8" + + "\b\u0084\n\u0084\f\u0084\u05bb\t\u0084\u0001\u0084\u0001\u0084\u0003\u0084" + + "\u05bf\b\u0084\u0001\u0084\u0003\u0084\u05c2\b\u0084\u0001\u0084\u0004" + + "\u0084\u05c5\b\u0084\u000b\u0084\f\u0084\u05c6\u0001\u0084\u0001\u0084" + + "\u0001\u0084\u0004\u0084\u05cc\b\u0084\u000b\u0084\f\u0084\u05cd\u0001" + + "\u0084\u0001\u0084\u0001\u0084\u0004\u0084\u05d3\b\u0084\u000b\u0084\f" + + "\u0084\u05d4\u0001\u0084\u0001\u0084\u0003\u0084\u05d9\b\u0084\u0001\u0084" + + "\u0004\u0084\u05dc\b\u0084\u000b\u0084\f\u0084\u05dd\u0001\u0084\u0004" + + "\u0084\u05e1\b\u0084\u000b\u0084\f\u0084\u05e2\u0001\u0084\u0001\u0084" + + "\u0003\u0084\u05e7\b\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0004\u0084" + + "\u05ec\b\u0084\u000b\u0084\f\u0084\u05ed\u0001\u0084\u0001\u0084\u0001" + + "\u0084\u0001\u0084\u0001\u0084\u0004\u0084\u05f5\b\u0084\u000b\u0084\f" + + "\u0084\u05f6\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084\u05fc\b\u0084" + + "\u0001\u0084\u0004\u0084\u05ff\b\u0084\u000b\u0084\f\u0084\u0600\u0001" + + "\u0084\u0001\u0084\u0001\u0084\u0004\u0084\u0606\b\u0084\u000b\u0084\f" + + "\u0084\u0607\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084\u060d\b\u0084" + + "\u0001\u0084\u0001\u0084\u0001\u0084\u0004\u0084\u0612\b\u0084\u000b\u0084" + + "\f\u0084\u0613\u0001\u0084\u0001\u0084\u0003\u0084\u0618\b\u0084\u0001" + + "\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u061d\b\u0085\u0001\u0085\u0001" + + "\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0005\u0086\u0624\b\u0086\n" + + "\u0086\f\u0086\u0627\t\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0004" + + "\u0086\u062c\b\u0086\u000b\u0086\f\u0086\u062d\u0001\u0086\u0001\u0086" + + "\u0001\u0086\u0001\u0086\u0005\u0086\u0634\b\u0086\n\u0086\f\u0086\u0637" + + "\t\u0086\u0001\u0086\u0001\u0086\u0003\u0086\u063b\b\u0086\u0001\u0086" + + "\u0004\u0086\u063e\b\u0086\u000b\u0086\f\u0086\u063f\u0001\u0086\u0001" + + "\u0086\u0005\u0086\u0644\b\u0086\n\u0086\f\u0086\u0647\t\u0086\u0001\u0086" + + "\u0001\u0086\u0003\u0086\u064b\b\u0086\u0001\u0086\u0001\u0086\u0001\u0086" + + "\u0004\u0086\u0650\b\u0086\u000b\u0086\f\u0086\u0651\u0001\u0086\u0001" + + "\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0004\u0086\u0659\b\u0086\u000b" + + "\u0086\f\u0086\u065a\u0001\u0086\u0001\u0086\u0001\u0086\u0003\u0086\u0660" + + "\b\u0086\u0001\u0086\u0004\u0086\u0663\b\u0086\u000b\u0086\f\u0086\u0664" + + "\u0001\u0086\u0001\u0086\u0001\u0086\u0004\u0086\u066a\b\u0086\u000b\u0086" + + "\f\u0086\u066b\u0001\u0086\u0001\u0086\u0001\u0086\u0003\u0086\u0671\b" + + "\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0004\u0086\u0676\b\u0086\u000b" + + "\u0086\f\u0086\u0677\u0001\u0086\u0001\u0086\u0003\u0086\u067c\b\u0086" + + "\u0001\u0087\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089" + + "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0005\u008a" + + "\u0689\b\u008a\n\u008a\f\u008a\u068c\t\u008a\u0001\u008b\u0001\u008b\u0001" + + "\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0005\u008c\u0695" + + "\b\u008c\n\u008c\f\u008c\u0698\t\u008c\u0001\u008d\u0001\u008d\u0001\u008e" + + "\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e" + + "\u0001\u008e\u0001\u008e\u0003\u008e\u06a5\b\u008e\u0001\u008f\u0001\u008f" + + "\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0003\u0090" + + "\u06ae\b\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0005\u0090\u06b3\b" + + "\u0090\n\u0090\f\u0090\u06b6\t\u0090\u0001\u0090\u0001\u0090\u0004\u0090" + + "\u06ba\b\u0090\u000b\u0090\f\u0090\u06bb\u0001\u0090\u0003\u0090\u06bf" + + "\b\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001" + + "\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0094\u0001\u0094\u0001" + + "\u0094\u0003\u0094\u06cd\b\u0094\u0001\u0094\u0001\u0094\u0001\u0095\u0001" + + "\u0095\u0003\u0095\u06d3\b\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0001" + + "\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0001" + + "\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001" + + "\u0098\u0003\u0098\u06e5\b\u0098\u0001\u0099\u0001\u0099\u0001\u009a\u0001" + + "\u009a\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0001\u009d\u0001" + + "\u009d\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u00a0\u0001" + + "\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0001" + + "\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001" + + "\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001" + + "\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a5\u0001" + + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001" + + "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0001" + + "\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001" + + "\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0001" + + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001" + + "\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae\u0001" + + "\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00af\u0001\u00af\u0001\u00af\u0001" + + "\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b1\u0001" + + "\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001" + + "\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b4\u0001" + + "\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001" + + "\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001" + + "\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001" + + "\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00ba\u0001" + + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bd\u0001" + + "\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001" + + "\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0\u0001" + + "\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001" + + "\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3\u0001" + + "\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001" + + "\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6\u0001" + + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001" + + "\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c9\u0001" + + "\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001" + + "\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cc\u0001" + + "\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001" + + "\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00cf\u0001" + + "\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001" + + "\u00d0\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001" + + "\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001" + + "\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001" + + "\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d6\u0001" + + "\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001" + + "\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d9\u0001" + + "\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00da\u0001\u00da\u0001\u00da\u0001" + + "\u00da\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00dc\u0001" + + "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001" + + "\u00dd\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00df\u0001" + + "\u00df\u0001\u00df\u0001\u00df\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001" + + "\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e2\u0001" + + "\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001" + + "\u00e3\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e5\u0001" + + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001" + + "\u00e6\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e8\u0001" + + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001" + + "\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00eb\u0001" + + "\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001" + + "\u00ec\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ee\u0001" + + "\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001" + + "\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001" + + "\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001" + + "\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f4\u0001" + + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001" + + "\u00f5\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f7\u0001" + + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001" + + "\u00f8\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00fa\u0001" + + "\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001" + + "\u00fb\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fd\u0001" + + "\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001" + + "\u00fe\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u0100\u0001" + + "\u0100\u0001\u0100\u0001\u0100\u0001\u0101\u0001\u0101\u0001\u0101\u0001" + + "\u0101\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0103\u0001" + + "\u0103\u0001\u0103\u0001\u0103\u0001\u0104\u0001\u0104\u0001\u0104\u0001" + + "\u0104\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0106\u0001" + + "\u0106\u0001\u0106\u0001\u0106\u0001\u0107\u0001\u0107\u0001\u0107\u0001" + + "\u0107\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0109\u0001" + + "\u0109\u0001\u0109\u0001\u0109\u0001\u010a\u0001\u010a\u0001\u010a\u0001" + + "\u010a\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010c\u0001" + + "\u010c\u0001\u010c\u0001\u010c\u0001\u010d\u0001\u010d\u0001\u010d\u0001" + + "\u010d\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010f\u0001" + + "\u010f\u0001\u010f\u0001\u010f\u0001\u0110\u0001\u0110\u0001\u0110\u0001" + + "\u0110\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0112\u0001" + + "\u0112\u0001\u0112\u0001\u0112\u0001\u0113\u0001\u0113\u0001\u0113\u0001" + + "\u0113\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0115\u0001" + + "\u0115\u0001\u0115\u0001\u0115\u0001\u0116\u0001\u0116\u0003\u0116\u08d5" + + "\b\u0116\u0001\u0116\u0001\u0116\u0001\u0117\u0001\u0117\u0001\u0117\u0001" + + "\u0117\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0119\u0001" + + "\u0119\u0001\u0119\u0001\u0119\u0001\u011a\u0001\u011a\u0001\u011b\u0004" + + "\u011b\u08e8\b\u011b\u000b\u011b\f\u011b\u08e9\u0001\u011b\u0003\u011b" + + "\u08ed\b\u011b\u0001\u011c\u0001\u011c\u0001\u011c\u0003\u011c\u08f2\b" + + "\u011c\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001" + + "\u011e\u0003\u011e\u08fa\b\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001" + + "\u011e\u0001\u011e\u0001\u011e\u0001\u011f\u0004\u011f\u0903\b\u011f\u000b" + + "\u011f\f\u011f\u0904\u0001\u0120\u0001\u0120\u0001\u0121\u0004\u0121\u090a" + + "\b\u0121\u000b\u0121\f\u0121\u090b\u0001\u0121\u0003\u0121\u090f\b\u0121" + + "\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0123\u0001\u0123\u0001\u0123" + + "\u0001\u0123\u0001\u0123\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124" + + "\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0126" + + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0127\u0001\u0127" + + "\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0128\u0001\u0128\u0001\u0128" + + "\u0001\u0128\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u012a" + + "\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012b\u0001\u012b" + + "\u0001\u012b\u0001\u012b\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c" + + "\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012e\u0001\u012e" + + "\u0001\u012e\u0001\u012e\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u012f" + + "\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0131\u0001\u0131" + + "\u0001\u0131\u0001\u0131\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132" + + "\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0134\u0001\u0134" + + "\u0001\u0134\u0001\u0134\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135" + + "\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0137\u0001\u0137" + + "\u0001\u0137\u0001\u0137\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0138" + + "\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u013a\u0001\u013a" + + "\u0001\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b" + + "\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013d\u0001\u013d" + + "\u0001\u013d\u0001\u013d\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e" + + "\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u0140\u0001\u0140" + + "\u0001\u0140\u0001\u0140\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141" + + "\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0143\u0001\u0143" + + "\u0001\u0143\u0001\u0143\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144" + + "\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0146\u0001\u0146" + + "\u0001\u0146\u0001\u0146\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147" + + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0149\u0001\u0149" + + "\u0001\u0149\u0001\u0149\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a" + + "\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014c\u0001\u014c" + + "\u0001\u014c\u0001\u014c\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d" + + "\u0001\u014e\u0001\u014e\u0001\u014e\u0001\u014e\u0001\u014f\u0001\u014f" + + "\u0001\u014f\u0001\u014f\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150" + + "\u0001\u0151\u0001\u0151\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152" + + "\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0154\u0001\u0154" + + "\u0001\u0154\u0001\u0154\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155" + + "\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0157\u0001\u0157" + + "\u0001\u0157\u0001\u0157\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158" + + "\u0001\u0158\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159" + + "\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015b\u0001\u015b" + + "\u0001\u015b\u0001\u015b\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c" + + "\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015e\u0001\u015e" + + "\u0001\u015e\u0001\u015e\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u015f" + + "\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0161\u0001\u0161" + + "\u0001\u0161\u0001\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162" + + "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0164\u0001\u0164" + + "\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165\u0003\u0165\u0a23\b\u0165" + + "\u0001\u0165\u0001\u0165\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166" + + "\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u02e7\u0000\u0168" + + "\u0005\u0001\u0007\u0002\t\u0003\u000b\u0004\r\u0005\u000f\u0006\u0011" + + "\u0007\u0013\b\u0015\t\u0017\n\u0019\u000b\u001b\f\u001d\r\u001f\u000e" + + "!\u000f#\u0010%\u0011\'\u0012)\u0013+\u0014-\u0015/\u00161\u00173\u0018" + + "5\u00197\u001a9\u001b;\u001c=\u001d?\u001eA\u001fC E!G\"I#K$M%O&Q\'S(" + + "U)W*Y+[,]-_.a/c0e1g2i3k4m5o6q7s8u9w:y;{<}=\u007f>\u0081?\u0083@\u0085" + + "A\u0087B\u0089C\u008bD\u008dE\u008fF\u0091G\u0093H\u0095I\u0097J\u0099" + + "K\u009bL\u009dM\u009fN\u00a1O\u00a3P\u00a5Q\u00a7R\u00a9S\u00abT\u00ad" + + "U\u00afV\u00b1W\u00b3X\u00b5Y\u00b7Z\u00b9[\u00bb\\\u00bd]\u00bf^\u00c1" + + "_\u00c3`\u00c5a\u00c7b\u00c9c\u00cbd\u00cde\u00cff\u00d1g\u00d3h\u00d5" + + "i\u00d7j\u00d9k\u00dbl\u00ddm\u00dfn\u00e1o\u00e3p\u00e5q\u00e7r\u00e9" + + "s\u00ebt\u00edu\u00efv\u00f1w\u00f3x\u00f5y\u00f7z\u00f9{\u00fb|\u00fd" + + "}\u00ff~\u0101\u007f\u0103\u0080\u0105\u0081\u0107\u0082\u0109\u0083\u010b" + + "\u0084\u010d\u0085\u010f\u0086\u0111\u0087\u0113\u0000\u0115\u0000\u0117" + + "\u0000\u0119\u0088\u011b\u0000\u011d\u0089\u011f\u0000\u0121\u008a\u0123" + + "\u008b\u0125\u008c\u0127\u008d\u0129\u008e\u012b\u008f\u012d\u0090\u012f" + + "\u0000\u0131\u0000\u0133\u0000\u0135\u0000\u0137\u0091\u0139\u0092\u013b" + + "\u0093\u013d\u0094\u013f\u0095\u0141\u0096\u0143\u0097\u0145\u0000\u0147" + + "\u0000\u0149\u0000\u014b\u0000\u014d\u0000\u014f\u0000\u0151\u0000\u0153" + + "\u0000\u0155\u0000\u0157\u0000\u0159\u0000\u015b\u0000\u015d\u0000\u015f" + + "\u0000\u0161\u0000\u0163\u0000\u0165\u0000\u0167\u0000\u0169\u0000\u016b" + + "\u0000\u016d\u0000\u016f\u0000\u0171\u0000\u0173\u0000\u0175\u0000\u0177" + + "\u0000\u0179\u0000\u017b\u0000\u017d\u0000\u017f\u0000\u0181\u0000\u0183" + + "\u0000\u0185\u0000\u0187\u0000\u0189\u0000\u018b\u0000\u018d\u0000\u018f" + + "\u0000\u0191\u0000\u0193\u0000\u0195\u0000\u0197\u0000\u0199\u0000\u019b" + + "\u0000\u019d\u0000\u019f\u0000\u01a1\u0000\u01a3\u0000\u01a5\u0000\u01a7" + + "\u0000\u01a9\u0000\u01ab\u0000\u01ad\u0000\u01af\u0000\u01b1\u0000\u01b3" + + "\u0000\u01b5\u0000\u01b7\u0000\u01b9\u0000\u01bb\u0000\u01bd\u0000\u01bf" + + "\u0000\u01c1\u0000\u01c3\u0000\u01c5\u0000\u01c7\u0000\u01c9\u0000\u01cb" + + "\u0000\u01cd\u0000\u01cf\u0000\u01d1\u0000\u01d3\u0000\u01d5\u0000\u01d7" + + "\u0000\u01d9\u0000\u01db\u0000\u01dd\u0000\u01df\u0000\u01e1\u0000\u01e3" + + "\u0000\u01e5\u0000\u01e7\u0000\u01e9\u0000\u01eb\u0000\u01ed\u0000\u01ef" + + "\u0000\u01f1\u0000\u01f3\u0000\u01f5\u0000\u01f7\u0000\u01f9\u0000\u01fb" + + "\u0000\u01fd\u0000\u01ff\u0000\u0201\u0000\u0203\u0000\u0205\u0000\u0207" + + "\u0000\u0209\u0000\u020b\u0000\u020d\u0000\u020f\u0000\u0211\u0000\u0213" + + "\u0000\u0215\u0000\u0217\u0000\u0219\u0000\u021b\u0000\u021d\u0000\u021f" + + "\u0000\u0221\u0000\u0223\u0000\u0225\u0000\u0227\u0000\u0229\u0000\u022b" + + "\u0000\u022d\u0000\u022f\u0000\u0231\u0098\u0233\u0099\u0235\u009a\u0237" + + "\u009b\u0239\u009c\u023b\u009d\u023d\u009e\u023f\u009f\u0241\u00a0\u0243" + + "\u00a1\u0245\u00a2\u0247\u00a3\u0249\u00a4\u024b\u00a5\u024d\u00a6\u024f" + + "\u0000\u0251\u0000\u0253\u0000\u0255\u0000\u0257\u0000\u0259\u0000\u025b" + + "\u0000\u025d\u0000\u025f\u0000\u0261\u0000\u0263\u0000\u0265\u0000\u0267" + + "\u0000\u0269\u0000\u026b\u0000\u026d\u0000\u026f\u0000\u0271\u0000\u0273" + + "\u0000\u0275\u0000\u0277\u0000\u0279\u0000\u027b\u0000\u027d\u0000\u027f" + + "\u0000\u0281\u0000\u0283\u0000\u0285\u0000\u0287\u0000\u0289\u0000\u028b" + + "\u0000\u028d\u0000\u028f\u0000\u0291\u0000\u0293\u0000\u0295\u0000\u0297" + + "\u0000\u0299\u0000\u029b\u0000\u029d\u0000\u029f\u0000\u02a1\u0000\u02a3" + + "\u0000\u02a5\u0000\u02a7\u00a7\u02a9\u0000\u02ab\u0000\u02ad\u0000\u02af" + + "\u0000\u02b1\u0000\u02b3\u0000\u02b5\u0000\u02b7\u0000\u02b9\u0000\u02bb" + + "\u0000\u02bd\u0000\u02bf\u0000\u02c1\u0000\u02c3\u0000\u02c5\u0000\u02c7" + + "\u0000\u02c9\u0000\u02cb\u0000\u02cd\u0000\u02cf\u00a8\u02d1\u00a9\u02d3" + + "\u00aa\u0005\u0000\u0001\u0002\u0003\u0004\u0014\u0002\u0000\n\n\r\r\u0003" + + "\u0000\t\t\f\f \u0002\u0000FFff\u0002\u0000EEee\u0002\u0000++--%\u0000" + + "19\u0661\u0669\u06f1\u06f9\u07c1\u07c9\u0967\u096f\u09e7\u09ef\u0a67\u0a6f" + + "\u0ae7\u0aef\u0b67\u0b6f\u0be7\u0bef\u0c67\u0c6f\u0ce7\u0cef\u0d67\u0d6f" + + "\u0de7\u0def\u0e51\u0e59\u0ed1\u0ed9\u0f21\u0f29\u1041\u1049\u1091\u1099" + + "\u17e1\u17e9\u1811\u1819\u1947\u194f\u19d1\u19d9\u1a81\u1a89\u1a91\u1a99" + + "\u1b51\u1b59\u1bb1\u1bb9\u1c41\u1c49\u1c51\u1c59\u8000\ua621\u8000\ua629" + + "\u8000\ua8d1\u8000\ua8d9\u8000\ua901\u8000\ua909\u8000\ua9d1\u8000\ua9d9" + + "\u8000\ua9f1\u8000\ua9f9\u8000\uaa51\u8000\uaa59\u8000\uabf1\u8000\uabf9" + + "\u8000\uff11\u8000\uff19\u0002\u0000XXxx\u0003\u000009AFaf\u0002\u0000" + + "BBbb\u0001\u000001\u0001\u0000``\b\u0000\"\"$$\'\'\\\\bbnnrrtt\u0246\u0000" + + "az\u00b5\u00b5\u00df\u00f6\u00f8\u00ff\u0101\u0101\u0103\u0103\u0105\u0105" + + "\u0107\u0107\u0109\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111\u0111" + + "\u0113\u0113\u0115\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d\u011d" + + "\u011f\u011f\u0121\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129\u0129" + + "\u012b\u012b\u012d\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135\u0135" + + "\u0137\u0138\u013a\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142\u0142" + + "\u0144\u0144\u0146\u0146\u0148\u0149\u014b\u014b\u014d\u014d\u014f\u014f" + + "\u0151\u0151\u0153\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b\u015b" + + "\u015d\u015d\u015f\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167\u0167" + + "\u0169\u0169\u016b\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173\u0173" + + "\u0175\u0175\u0177\u0177\u017a\u017a\u017c\u017c\u017e\u0180\u0183\u0183" + + "\u0185\u0185\u0188\u0188\u018c\u018d\u0192\u0192\u0195\u0195\u0199\u019b" + + "\u019e\u019e\u01a1\u01a1\u01a3\u01a3\u01a5\u01a5\u01a8\u01a8\u01aa\u01ab" + + "\u01ad\u01ad\u01b0\u01b0\u01b4\u01b4\u01b6\u01b6\u01b9\u01ba\u01bd\u01bf" + + "\u01c6\u01c6\u01c9\u01c9\u01cc\u01cc\u01ce\u01ce\u01d0\u01d0\u01d2\u01d2" + + "\u01d4\u01d4\u01d6\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dd\u01df\u01df" + + "\u01e1\u01e1\u01e3\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb\u01eb" + + "\u01ed\u01ed\u01ef\u01f0\u01f3\u01f3\u01f5\u01f5\u01f9\u01f9\u01fb\u01fb" + + "\u01fd\u01fd\u01ff\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207\u0207" + + "\u0209\u0209\u020b\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213\u0213" + + "\u0215\u0215\u0217\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f\u021f" + + "\u0221\u0221\u0223\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b\u022b" + + "\u022d\u022d\u022f\u022f\u0231\u0231\u0233\u0239\u023c\u023c\u023f\u0240" + + "\u0242\u0242\u0247\u0247\u0249\u0249\u024b\u024b\u024d\u024d\u024f\u0293" + + "\u0295\u02af\u0371\u0371\u0373\u0373\u0377\u0377\u037b\u037d\u0390\u0390" + + "\u03ac\u03ce\u03d0\u03d1\u03d5\u03d7\u03d9\u03d9\u03db\u03db\u03dd\u03dd" + + "\u03df\u03df\u03e1\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9\u03e9" + + "\u03eb\u03eb\u03ed\u03ed\u03ef\u03f3\u03f5\u03f5\u03f8\u03f8\u03fb\u03fc" + + "\u0430\u045f\u0461\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469\u0469" + + "\u046b\u046b\u046d\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475\u0475" + + "\u0477\u0477\u0479\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481\u0481" + + "\u048b\u048b\u048d\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495\u0495" + + "\u0497\u0497\u0499\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1\u04a1" + + "\u04a3\u04a3\u04a5\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad\u04ad" + + "\u04af\u04af\u04b1\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9\u04b9" + + "\u04bb\u04bb\u04bd\u04bd\u04bf\u04bf\u04c2\u04c2\u04c4\u04c4\u04c6\u04c6" + + "\u04c8\u04c8\u04ca\u04ca\u04cc\u04cc\u04ce\u04cf\u04d1\u04d1\u04d3\u04d3" + + "\u04d5\u04d5\u04d7\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df\u04df" + + "\u04e1\u04e1\u04e3\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb\u04eb" + + "\u04ed\u04ed\u04ef\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7\u04f7" + + "\u04f9\u04f9\u04fb\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503\u0503" + + "\u0505\u0505\u0507\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f\u050f" + + "\u0511\u0511\u0513\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b\u051b" + + "\u051d\u051d\u051f\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527\u0527" + + "\u0561\u0587\u1d00\u1d2b\u1d6b\u1d77\u1d79\u1d9a\u1e01\u1e01\u1e03\u1e03" + + "\u1e05\u1e05\u1e07\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f\u1e0f" + + "\u1e11\u1e11\u1e13\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b\u1e1b" + + "\u1e1d\u1e1d\u1e1f\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27\u1e27" + + "\u1e29\u1e29\u1e2b\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33\u1e33" + + "\u1e35\u1e35\u1e37\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f\u1e3f" + + "\u1e41\u1e41\u1e43\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b\u1e4b" + + "\u1e4d\u1e4d\u1e4f\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57\u1e57" + + "\u1e59\u1e59\u1e5b\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63\u1e63" + + "\u1e65\u1e65\u1e67\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f\u1e6f" + + "\u1e71\u1e71\u1e73\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b\u1e7b" + + "\u1e7d\u1e7d\u1e7f\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87\u1e87" + + "\u1e89\u1e89\u1e8b\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93\u1e93" + + "\u1e95\u1e9d\u1e9f\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7\u1ea7" + + "\u1ea9\u1ea9\u1eab\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3\u1eb3" + + "\u1eb5\u1eb5\u1eb7\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf\u1ebf" + + "\u1ec1\u1ec1\u1ec3\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb\u1ecb" + + "\u1ecd\u1ecd\u1ecf\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7\u1ed7" + + "\u1ed9\u1ed9\u1edb\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3\u1ee3" + + "\u1ee5\u1ee5\u1ee7\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef\u1eef" + + "\u1ef1\u1ef1\u1ef3\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb\u1efb" + + "\u1efd\u1efd\u1eff\u1f07\u1f10\u1f15\u1f20\u1f27\u1f30\u1f37\u1f40\u1f45" + + "\u1f50\u1f57\u1f60\u1f67\u1f70\u1f7d\u1f80\u1f87\u1f90\u1f97\u1fa0\u1fa7" + + "\u1fb0\u1fb4\u1fb6\u1fb7\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fc7\u1fd0\u1fd3" + + "\u1fd6\u1fd7\u1fe0\u1fe7\u1ff2\u1ff4\u1ff6\u1ff7\u210a\u210a\u210e\u210f" + + "\u2113\u2113\u212f\u212f\u2134\u2134\u2139\u2139\u213c\u213d\u2146\u2149" + + "\u214e\u214e\u2184\u2184\u2c30\u2c5e\u2c61\u2c61\u2c65\u2c66\u2c68\u2c68" + + "\u2c6a\u2c6a\u2c6c\u2c6c\u2c71\u2c71\u2c73\u2c74\u2c76\u2c7b\u2c81\u2c81" + + "\u2c83\u2c83\u2c85\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d\u2c8d" + + "\u2c8f\u2c8f\u2c91\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99\u2c99" + + "\u2c9b\u2c9b\u2c9d\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5\u2ca5" + + "\u2ca7\u2ca7\u2ca9\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1\u2cb1" + + "\u2cb3\u2cb3\u2cb5\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd\u2cbd" + + "\u2cbf\u2cbf\u2cc1\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9\u2cc9" + + "\u2ccb\u2ccb\u2ccd\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5\u2cd5" + + "\u2cd7\u2cd7\u2cd9\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1\u2ce1" + + "\u2ce3\u2ce4\u2cec\u2cec\u2cee\u2cee\u2cf3\u2cf3\u2d00\u2d25\u2d27\u2d27" + + "\u2d2d\u2d2d\u8000\ua641\u8000\ua641\u8000\ua643\u8000\ua643\u8000\ua645" + + "\u8000\ua645\u8000\ua647\u8000\ua647\u8000\ua649\u8000\ua649\u8000\ua64b" + + "\u8000\ua64b\u8000\ua64d\u8000\ua64d\u8000\ua64f\u8000\ua64f\u8000\ua651" + + "\u8000\ua651\u8000\ua653\u8000\ua653\u8000\ua655\u8000\ua655\u8000\ua657" + + "\u8000\ua657\u8000\ua659\u8000\ua659\u8000\ua65b\u8000\ua65b\u8000\ua65d" + + "\u8000\ua65d\u8000\ua65f\u8000\ua65f\u8000\ua661\u8000\ua661\u8000\ua663" + + "\u8000\ua663\u8000\ua665\u8000\ua665\u8000\ua667\u8000\ua667\u8000\ua669" + + "\u8000\ua669\u8000\ua66b\u8000\ua66b\u8000\ua66d\u8000\ua66d\u8000\ua681" + + "\u8000\ua681\u8000\ua683\u8000\ua683\u8000\ua685\u8000\ua685\u8000\ua687" + + "\u8000\ua687\u8000\ua689\u8000\ua689\u8000\ua68b\u8000\ua68b\u8000\ua68d" + + "\u8000\ua68d\u8000\ua68f\u8000\ua68f\u8000\ua691\u8000\ua691\u8000\ua693" + + "\u8000\ua693\u8000\ua695\u8000\ua695\u8000\ua697\u8000\ua697\u8000\ua723" + + "\u8000\ua723\u8000\ua725\u8000\ua725\u8000\ua727\u8000\ua727\u8000\ua729" + + "\u8000\ua729\u8000\ua72b\u8000\ua72b\u8000\ua72d\u8000\ua72d\u8000\ua72f" + + "\u8000\ua731\u8000\ua733\u8000\ua733\u8000\ua735\u8000\ua735\u8000\ua737" + + "\u8000\ua737\u8000\ua739\u8000\ua739\u8000\ua73b\u8000\ua73b\u8000\ua73d" + + "\u8000\ua73d\u8000\ua73f\u8000\ua73f\u8000\ua741\u8000\ua741\u8000\ua743" + + "\u8000\ua743\u8000\ua745\u8000\ua745\u8000\ua747\u8000\ua747\u8000\ua749" + + "\u8000\ua749\u8000\ua74b\u8000\ua74b\u8000\ua74d\u8000\ua74d\u8000\ua74f" + + "\u8000\ua74f\u8000\ua751\u8000\ua751\u8000\ua753\u8000\ua753\u8000\ua755" + + "\u8000\ua755\u8000\ua757\u8000\ua757\u8000\ua759\u8000\ua759\u8000\ua75b" + + "\u8000\ua75b\u8000\ua75d\u8000\ua75d\u8000\ua75f\u8000\ua75f\u8000\ua761" + + "\u8000\ua761\u8000\ua763\u8000\ua763\u8000\ua765\u8000\ua765\u8000\ua767" + + "\u8000\ua767\u8000\ua769\u8000\ua769\u8000\ua76b\u8000\ua76b\u8000\ua76d" + + "\u8000\ua76d\u8000\ua76f\u8000\ua76f\u8000\ua771\u8000\ua778\u8000\ua77a" + + "\u8000\ua77a\u8000\ua77c\u8000\ua77c\u8000\ua77f\u8000\ua77f\u8000\ua781" + + "\u8000\ua781\u8000\ua783\u8000\ua783\u8000\ua785\u8000\ua785\u8000\ua787" + + "\u8000\ua787\u8000\ua78c\u8000\ua78c\u8000\ua78e\u8000\ua78e\u8000\ua791" + + "\u8000\ua791\u8000\ua793\u8000\ua793\u8000\ua7a1\u8000\ua7a1\u8000\ua7a3" + + "\u8000\ua7a3\u8000\ua7a5\u8000\ua7a5\u8000\ua7a7\u8000\ua7a7\u8000\ua7a9" + + "\u8000\ua7a9\u8000\ua7fa\u8000\ua7fa\u8000\ufb00\u8000\ufb06\u8000\ufb13" + + "\u8000\ufb17\u8000\uff41\u8000\uff5a3\u0000\u02b0\u02c1\u02c6\u02d1\u02e0" + + "\u02e4\u02ec\u02ec\u02ee\u02ee\u0374\u0374\u037a\u037a\u0559\u0559\u0640" + + "\u0640\u06e5\u06e6\u07f4\u07f5\u07fa\u07fa\u081a\u081a\u0824\u0824\u0828" + + "\u0828\u0971\u0971\u0e46\u0e46\u0ec6\u0ec6\u10fc\u10fc\u17d7\u17d7\u1843" + + "\u1843\u1aa7\u1aa7\u1c78\u1c7d\u1d2c\u1d6a\u1d78\u1d78\u1d9b\u1dbf\u2071" + + "\u2071\u207f\u207f\u2090\u209c\u2c7c\u2c7d\u2d6f\u2d6f\u2e2f\u2e2f\u3005" + + "\u3005\u3031\u3035\u303b\u303b\u309d\u309e\u30fc\u30fe\u8000\ua015\u8000" + + "\ua015\u8000\ua4f8\u8000\ua4fd\u8000\ua60c\u8000\ua60c\u8000\ua67f\u8000" + + "\ua67f\u8000\ua717\u8000\ua71f\u8000\ua770\u8000\ua770\u8000\ua788\u8000" + + "\ua788\u8000\ua7f8\u8000\ua7f9\u8000\ua9cf\u8000\ua9cf\u8000\uaa70\u8000" + + "\uaa70\u8000\uaadd\u8000\uaadd\u8000\uaaf3\u8000\uaaf4\u8000\uff70\u8000" + + "\uff70\u8000\uff9e\u8000\uff9f\u0121\u0000\u00aa\u00aa\u00ba\u00ba\u01bb" + + "\u01bb\u01c0\u01c3\u0294\u0294\u05d0\u05ea\u05f0\u05f2\u0620\u063f\u0641" + + "\u064a\u066e\u066f\u0671\u06d3\u06d5\u06d5\u06ee\u06ef\u06fa\u06fc\u06ff" + + "\u06ff\u0710\u0710\u0712\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u0800" + + "\u0815\u0840\u0858\u08a0\u08a0\u08a2\u08ac\u0904\u0939\u093d\u093d\u0950" + + "\u0950\u0958\u0961\u0972\u0977\u0979\u097f\u0985\u098c\u098f\u0990\u0993" + + "\u09a8\u09aa\u09b0\u09b2\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc" + + "\u09dd\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a" + + "\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72" + + "\u0a74\u0a85\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5" + + "\u0ab9\u0abd\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0b05\u0b0c\u0b0f\u0b10\u0b13" + + "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f" + + "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99" + + "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0" + + "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33\u0c35\u0c39\u0c3d" + + "\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa" + + "\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cde\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05" + + "\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d60\u0d61\u0d7a" + + "\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd\u0dbd\u0dc0\u0dc6\u0e01" + + "\u0e30\u0e32\u0e33\u0e40\u0e45\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a" + + "\u0e8a\u0e8d\u0e8d\u0e94\u0e97\u0e99\u0e9f\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7" + + "\u0ea7\u0eaa\u0eab\u0ead\u0eb0\u0eb2\u0eb3\u0ebd\u0ebd\u0ec0\u0ec4\u0edc" + + "\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49\u0f6c\u0f88\u0f8c\u1000\u102a\u103f" + + "\u103f\u1050\u1055\u105a\u105d\u1061\u1061\u1065\u1066\u106e\u1070\u1075" + + "\u1081\u108e\u108e\u10d0\u10fa\u10fd\u1248\u124a\u124d\u1250\u1256\u1258" + + "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8" + + "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318" + + "\u135a\u1380\u138f\u13a0\u13f4\u1401\u166c\u166f\u167f\u1681\u169a\u16a0" + + "\u16ea\u1700\u170c\u170e\u1711\u1720\u1731\u1740\u1751\u1760\u176c\u176e" + + "\u1770\u1780\u17b3\u17dc\u17dc\u1820\u1842\u1844\u1877\u1880\u18a8\u18aa" + + "\u18aa\u18b0\u18f5\u1900\u191c\u1950\u196d\u1970\u1974\u1980\u19ab\u19c1" + + "\u19c7\u1a00\u1a16\u1a20\u1a54\u1b05\u1b33\u1b45\u1b4b\u1b83\u1ba0\u1bae" + + "\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d\u1c4f\u1c5a\u1c77\u1ce9\u1cec\u1cee" + + "\u1cf1\u1cf5\u1cf6\u2135\u2138\u2d30\u2d67\u2d80\u2d96\u2da0\u2da6\u2da8" + + "\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0\u2dd6\u2dd8" + + "\u2dde\u3006\u3006\u303c\u303c\u3041\u3096\u309f\u309f\u30a1\u30fa\u30ff" + + "\u30ff\u3105\u312d\u3131\u318e\u31a0\u31ba\u31f0\u31ff\u3400\u3400\u4db5" + + "\u4db5\u4e00\u4e00\u8000\u9fcc\u8000\u9fcc\u8000\ua000\u8000\ua014\u8000" + + "\ua016\u8000\ua48c\u8000\ua4d0\u8000\ua4f7\u8000\ua500\u8000\ua60b\u8000" + + "\ua610\u8000\ua61f\u8000\ua62a\u8000\ua62b\u8000\ua66e\u8000\ua66e\u8000" + + "\ua6a0\u8000\ua6e5\u8000\ua7fb\u8000\ua801\u8000\ua803\u8000\ua805\u8000" + + "\ua807\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000" + + "\ua882\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000" + + "\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960\u8000\ua97c\u8000" + + "\ua984\u8000\ua9b2\u8000\uaa00\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000" + + "\uaa44\u8000\uaa4b\u8000\uaa60\u8000\uaa6f\u8000\uaa71\u8000\uaa76\u8000" + + "\uaa7a\u8000\uaa7a\u8000\uaa80\u8000\uaaaf\u8000\uaab1\u8000\uaab1\u8000" + + "\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0\u8000\uaac0\u8000" + + "\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadc\u8000\uaae0\u8000\uaaea\u8000" + + "\uaaf2\u8000\uaaf2\u8000\uab01\u8000\uab06\u8000\uab09\u8000\uab0e\u8000" + + "\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28\u8000\uab2e\u8000" + + "\uabc0\u8000\uabe2\u8000\uac00\u8000\uac00\u8000\ud7a3\u8000\ud7a3\u8000" + + "\ud7b0\u8000\ud7c6\u8000\ud7cb\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000" + + "\ufa70\u8000\ufad9\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f\u8000\ufb28\u8000" + + "\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e\u8000\ufb3e\u8000" + + "\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46\u8000\ufbb1\u8000" + + "\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92\u8000\ufdc7\u8000" + + "\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76\u8000\ufefc\u8000" + + "\uff66\u8000\uff6f\u8000\uff71\u8000\uff9d\u8000\uffa0\u8000\uffbe\u8000" + + "\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2\u8000\uffd7\u8000" + + "\uffda\u8000\uffdc\n\u0000\u01c5\u01c5\u01c8\u01c8\u01cb\u01cb\u01f2\u01f2" + + "\u1f88\u1f8f\u1f98\u1f9f\u1fa8\u1faf\u1fbc\u1fbc\u1fcc\u1fcc\u1ffc\u1ffc" + + "\u0240\u0000AZ\u00c0\u00d6\u00d8\u00de\u0100\u0100\u0102\u0102\u0104\u0104" + + "\u0106\u0106\u0108\u0108\u010a\u010a\u010c\u010c\u010e\u010e\u0110\u0110" + + "\u0112\u0112\u0114\u0114\u0116\u0116\u0118\u0118\u011a\u011a\u011c\u011c" + + "\u011e\u011e\u0120\u0120\u0122\u0122\u0124\u0124\u0126\u0126\u0128\u0128" + + "\u012a\u012a\u012c\u012c\u012e\u012e\u0130\u0130\u0132\u0132\u0134\u0134" + + "\u0136\u0136\u0139\u0139\u013b\u013b\u013d\u013d\u013f\u013f\u0141\u0141" + + "\u0143\u0143\u0145\u0145\u0147\u0147\u014a\u014a\u014c\u014c\u014e\u014e" + + "\u0150\u0150\u0152\u0152\u0154\u0154\u0156\u0156\u0158\u0158\u015a\u015a" + + "\u015c\u015c\u015e\u015e\u0160\u0160\u0162\u0162\u0164\u0164\u0166\u0166" + + "\u0168\u0168\u016a\u016a\u016c\u016c\u016e\u016e\u0170\u0170\u0172\u0172" + + "\u0174\u0174\u0176\u0176\u0178\u0179\u017b\u017b\u017d\u017d\u0181\u0182" + + "\u0184\u0184\u0186\u0187\u0189\u018b\u018e\u0191\u0193\u0194\u0196\u0198" + + "\u019c\u019d\u019f\u01a0\u01a2\u01a2\u01a4\u01a4\u01a6\u01a7\u01a9\u01a9" + + "\u01ac\u01ac\u01ae\u01af\u01b1\u01b3\u01b5\u01b5\u01b7\u01b8\u01bc\u01bc" + + "\u01c4\u01c4\u01c7\u01c7\u01ca\u01ca\u01cd\u01cd\u01cf\u01cf\u01d1\u01d1" + + "\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7\u01d9\u01d9\u01db\u01db\u01de\u01de" + + "\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4\u01e6\u01e6\u01e8\u01e8\u01ea\u01ea" + + "\u01ec\u01ec\u01ee\u01ee\u01f1\u01f1\u01f4\u01f4\u01f6\u01f8\u01fa\u01fa" + + "\u01fc\u01fc\u01fe\u01fe\u0200\u0200\u0202\u0202\u0204\u0204\u0206\u0206" + + "\u0208\u0208\u020a\u020a\u020c\u020c\u020e\u020e\u0210\u0210\u0212\u0212" + + "\u0214\u0214\u0216\u0216\u0218\u0218\u021a\u021a\u021c\u021c\u021e\u021e" + + "\u0220\u0220\u0222\u0222\u0224\u0224\u0226\u0226\u0228\u0228\u022a\u022a" + + "\u022c\u022c\u022e\u022e\u0230\u0230\u0232\u0232\u023a\u023b\u023d\u023e" + + "\u0241\u0241\u0243\u0246\u0248\u0248\u024a\u024a\u024c\u024c\u024e\u024e" + + "\u0370\u0370\u0372\u0372\u0376\u0376\u0386\u0386\u0388\u038a\u038c\u038c" + + "\u038e\u038f\u0391\u03a1\u03a3\u03ab\u03cf\u03cf\u03d2\u03d4\u03d8\u03d8" + + "\u03da\u03da\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03e2\u03e4\u03e4" + + "\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea\u03ec\u03ec\u03ee\u03ee\u03f4\u03f4" + + "\u03f7\u03f7\u03f9\u03fa\u03fd\u042f\u0460\u0460\u0462\u0462\u0464\u0464" + + "\u0466\u0466\u0468\u0468\u046a\u046a\u046c\u046c\u046e\u046e\u0470\u0470" + + "\u0472\u0472\u0474\u0474\u0476\u0476\u0478\u0478\u047a\u047a\u047c\u047c" + + "\u047e\u047e\u0480\u0480\u048a\u048a\u048c\u048c\u048e\u048e\u0490\u0490" + + "\u0492\u0492\u0494\u0494\u0496\u0496\u0498\u0498\u049a\u049a\u049c\u049c" + + "\u049e\u049e\u04a0\u04a0\u04a2\u04a2\u04a4\u04a4\u04a6\u04a6\u04a8\u04a8" + + "\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae\u04b0\u04b0\u04b2\u04b2\u04b4\u04b4" + + "\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba\u04bc\u04bc\u04be\u04be\u04c0\u04c1" + + "\u04c3\u04c3\u04c5\u04c5\u04c7\u04c7\u04c9\u04c9\u04cb\u04cb\u04cd\u04cd" + + "\u04d0\u04d0\u04d2\u04d2\u04d4\u04d4\u04d6\u04d6\u04d8\u04d8\u04da\u04da" + + "\u04dc\u04dc\u04de\u04de\u04e0\u04e0\u04e2\u04e2\u04e4\u04e4\u04e6\u04e6" + + "\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec\u04ee\u04ee\u04f0\u04f0\u04f2\u04f2" + + "\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8\u04fa\u04fa\u04fc\u04fc\u04fe\u04fe" + + "\u0500\u0500\u0502\u0502\u0504\u0504\u0506\u0506\u0508\u0508\u050a\u050a" + + "\u050c\u050c\u050e\u050e\u0510\u0510\u0512\u0512\u0514\u0514\u0516\u0516" + + "\u0518\u0518\u051a\u051a\u051c\u051c\u051e\u051e\u0520\u0520\u0522\u0522" + + "\u0524\u0524\u0526\u0526\u0531\u0556\u10a0\u10c5\u10c7\u10c7\u10cd\u10cd" + + "\u1e00\u1e00\u1e02\u1e02\u1e04\u1e04\u1e06\u1e06\u1e08\u1e08\u1e0a\u1e0a" + + "\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10\u1e12\u1e12\u1e14\u1e14\u1e16\u1e16" + + "\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c\u1e1e\u1e1e\u1e20\u1e20\u1e22\u1e22" + + "\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28\u1e2a\u1e2a\u1e2c\u1e2c\u1e2e\u1e2e" + + "\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34\u1e36\u1e36\u1e38\u1e38\u1e3a\u1e3a" + + "\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40\u1e42\u1e42\u1e44\u1e44\u1e46\u1e46" + + "\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c\u1e4e\u1e4e\u1e50\u1e50\u1e52\u1e52" + + "\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58\u1e5a\u1e5a\u1e5c\u1e5c\u1e5e\u1e5e" + + "\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64\u1e66\u1e66\u1e68\u1e68\u1e6a\u1e6a" + + "\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70\u1e72\u1e72\u1e74\u1e74\u1e76\u1e76" + + "\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c\u1e7e\u1e7e\u1e80\u1e80\u1e82\u1e82" + + "\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88\u1e8a\u1e8a\u1e8c\u1e8c\u1e8e\u1e8e" + + "\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94\u1e9e\u1e9e\u1ea0\u1ea0\u1ea2\u1ea2" + + "\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8\u1eaa\u1eaa\u1eac\u1eac\u1eae\u1eae" + + "\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4\u1eb6\u1eb6\u1eb8\u1eb8\u1eba\u1eba" + + "\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0\u1ec2\u1ec2\u1ec4\u1ec4\u1ec6\u1ec6" + + "\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc\u1ece\u1ece\u1ed0\u1ed0\u1ed2\u1ed2" + + "\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8\u1eda\u1eda\u1edc\u1edc\u1ede\u1ede" + + "\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4\u1ee6\u1ee6\u1ee8\u1ee8\u1eea\u1eea" + + "\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0\u1ef2\u1ef2\u1ef4\u1ef4\u1ef6\u1ef6" + + "\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc\u1efe\u1efe\u1f08\u1f0f\u1f18\u1f1d" + + "\u1f28\u1f2f\u1f38\u1f3f\u1f48\u1f4d\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d" + + "\u1f5f\u1f5f\u1f68\u1f6f\u1fb8\u1fbb\u1fc8\u1fcb\u1fd8\u1fdb\u1fe8\u1fec" + + "\u1ff8\u1ffb\u2102\u2102\u2107\u2107\u210b\u210d\u2110\u2112\u2115\u2115" + + "\u2119\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u2130\u2133" + + "\u213e\u213f\u2145\u2145\u2183\u2183\u2c00\u2c2e\u2c60\u2c60\u2c62\u2c64" + + "\u2c67\u2c67\u2c69\u2c69\u2c6b\u2c6b\u2c6d\u2c70\u2c72\u2c72\u2c75\u2c75" + + "\u2c7e\u2c80\u2c82\u2c82\u2c84\u2c84\u2c86\u2c86\u2c88\u2c88\u2c8a\u2c8a" + + "\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90\u2c92\u2c92\u2c94\u2c94\u2c96\u2c96" + + "\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c\u2c9e\u2c9e\u2ca0\u2ca0\u2ca2\u2ca2" + + "\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8\u2caa\u2caa\u2cac\u2cac\u2cae\u2cae" + + "\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4\u2cb6\u2cb6\u2cb8\u2cb8\u2cba\u2cba" + + "\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0\u2cc2\u2cc2\u2cc4\u2cc4\u2cc6\u2cc6" + + "\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc\u2cce\u2cce\u2cd0\u2cd0\u2cd2\u2cd2" + + "\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8\u2cda\u2cda\u2cdc\u2cdc\u2cde\u2cde" + + "\u2ce0\u2ce0\u2ce2\u2ce2\u2ceb\u2ceb\u2ced\u2ced\u2cf2\u2cf2\u8000\ua640" + + "\u8000\ua640\u8000\ua642\u8000\ua642\u8000\ua644\u8000\ua644\u8000\ua646" + + "\u8000\ua646\u8000\ua648\u8000\ua648\u8000\ua64a\u8000\ua64a\u8000\ua64c" + + "\u8000\ua64c\u8000\ua64e\u8000\ua64e\u8000\ua650\u8000\ua650\u8000\ua652" + + "\u8000\ua652\u8000\ua654\u8000\ua654\u8000\ua656\u8000\ua656\u8000\ua658" + + "\u8000\ua658\u8000\ua65a\u8000\ua65a\u8000\ua65c\u8000\ua65c\u8000\ua65e" + + "\u8000\ua65e\u8000\ua660\u8000\ua660\u8000\ua662\u8000\ua662\u8000\ua664" + + "\u8000\ua664\u8000\ua666\u8000\ua666\u8000\ua668\u8000\ua668\u8000\ua66a" + + "\u8000\ua66a\u8000\ua66c\u8000\ua66c\u8000\ua680\u8000\ua680\u8000\ua682" + + "\u8000\ua682\u8000\ua684\u8000\ua684\u8000\ua686\u8000\ua686\u8000\ua688" + + "\u8000\ua688\u8000\ua68a\u8000\ua68a\u8000\ua68c\u8000\ua68c\u8000\ua68e" + + "\u8000\ua68e\u8000\ua690\u8000\ua690\u8000\ua692\u8000\ua692\u8000\ua694" + + "\u8000\ua694\u8000\ua696\u8000\ua696\u8000\ua722\u8000\ua722\u8000\ua724" + + "\u8000\ua724\u8000\ua726\u8000\ua726\u8000\ua728\u8000\ua728\u8000\ua72a" + + "\u8000\ua72a\u8000\ua72c\u8000\ua72c\u8000\ua72e\u8000\ua72e\u8000\ua732" + + "\u8000\ua732\u8000\ua734\u8000\ua734\u8000\ua736\u8000\ua736\u8000\ua738" + + "\u8000\ua738\u8000\ua73a\u8000\ua73a\u8000\ua73c\u8000\ua73c\u8000\ua73e" + + "\u8000\ua73e\u8000\ua740\u8000\ua740\u8000\ua742\u8000\ua742\u8000\ua744" + + "\u8000\ua744\u8000\ua746\u8000\ua746\u8000\ua748\u8000\ua748\u8000\ua74a" + + "\u8000\ua74a\u8000\ua74c\u8000\ua74c\u8000\ua74e\u8000\ua74e\u8000\ua750" + + "\u8000\ua750\u8000\ua752\u8000\ua752\u8000\ua754\u8000\ua754\u8000\ua756" + + "\u8000\ua756\u8000\ua758\u8000\ua758\u8000\ua75a\u8000\ua75a\u8000\ua75c" + + "\u8000\ua75c\u8000\ua75e\u8000\ua75e\u8000\ua760\u8000\ua760\u8000\ua762" + + "\u8000\ua762\u8000\ua764\u8000\ua764\u8000\ua766\u8000\ua766\u8000\ua768" + + "\u8000\ua768\u8000\ua76a\u8000\ua76a\u8000\ua76c\u8000\ua76c\u8000\ua76e" + + "\u8000\ua76e\u8000\ua779\u8000\ua779\u8000\ua77b\u8000\ua77b\u8000\ua77d" + + "\u8000\ua77e\u8000\ua780\u8000\ua780\u8000\ua782\u8000\ua782\u8000\ua784" + + "\u8000\ua784\u8000\ua786\u8000\ua786\u8000\ua78b\u8000\ua78b\u8000\ua78d" + + "\u8000\ua78d\u8000\ua790\u8000\ua790\u8000\ua792\u8000\ua792\u8000\ua7a0" + + "\u8000\ua7a0\u8000\ua7a2\u8000\ua7a2\u8000\ua7a4\u8000\ua7a4\u8000\ua7a6" + + "\u8000\ua7a6\u8000\ua7a8\u8000\ua7a8\u8000\ua7aa\u8000\ua7aa\u8000\uff21" + + "\u8000\uff3a#\u000009\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f" + + "\u09e6\u09ef\u0a66\u0a6f\u0ae6\u0aef\u0b66\u0b6f\u0be6\u0bef\u0c66\u0c6f" + + "\u0ce6\u0cef\u0d66\u0d6f\u0e50\u0e59\u0ed0\u0ed9\u0f20\u0f29\u1040\u1049" + + "\u1090\u1099\u17e0\u17e9\u1810\u1819\u1946\u194f\u19d0\u19d9\u1a80\u1a89" + + "\u1a90\u1a99\u1b50\u1b59\u1bb0\u1bb9\u1c40\u1c49\u1c50\u1c59\u8000\ua620" + + "\u8000\ua629\u8000\ua8d0\u8000\ua8d9\u8000\ua900\u8000\ua909\u8000\ua9d0" + + "\u8000\ua9d9\u8000\uaa50\u8000\uaa59\u8000\uabf0\u8000\uabf9\u8000\uff10" + + "\u8000\uff19\u0007\u0000\u16ee\u16f0\u2160\u2182\u2185\u2188\u3007\u3007" + + "\u3021\u3029\u3038\u303a\u8000\ua6e6\u8000\ua6ef\u0003\u0000\"\"$$\\\\" + + "\u0a80\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000" + + "\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000" + + "\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000" + + "\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000" + + "\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000" + + "\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000" + + "\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000" + + "!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001" + + "\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001\u0000" + + "\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000" + + "\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u00003" + + "\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001\u0000" + + "\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000\u0000" + + "\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000A" + + "\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001\u0000" + + "\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000\u0000" + + "\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000O" + + "\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001\u0000" + + "\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000" + + "\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000]" + + "\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001\u0000" + + "\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000\u0000" + + "\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000k" + + "\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001\u0000" + + "\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000\u0000" + + "\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000y" + + "\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001\u0000" + + "\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001\u0000" + + "\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001\u0000" + + "\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001\u0000" + + "\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001\u0000" + + "\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001\u0000" + + "\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001\u0000" + + "\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001\u0000" + + "\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001\u0000" + + "\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001\u0000" + + "\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001\u0000" + + "\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001\u0000" + + "\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001\u0000" + + "\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001\u0000" + + "\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001\u0000" + + "\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001\u0000" + + "\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001\u0000" + + "\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001\u0000" + + "\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000\u00c5\u0001\u0000" + + "\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000\u00c9\u0001\u0000" + + "\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000\u00cd\u0001\u0000" + + "\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000\u00d1\u0001\u0000" + + "\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000\u00d5\u0001\u0000" + + "\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000\u00d9\u0001\u0000" + + "\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000\u00dd\u0001\u0000" + + "\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0000\u00e1\u0001\u0000" + + "\u0000\u0000\u0000\u00e3\u0001\u0000\u0000\u0000\u0000\u00e5\u0001\u0000" + + "\u0000\u0000\u0000\u00e7\u0001\u0000\u0000\u0000\u0000\u00e9\u0001\u0000" + + "\u0000\u0000\u0000\u00eb\u0001\u0000\u0000\u0000\u0000\u00ed\u0001\u0000" + + "\u0000\u0000\u0000\u00ef\u0001\u0000\u0000\u0000\u0000\u00f1\u0001\u0000" + + "\u0000\u0000\u0000\u00f3\u0001\u0000\u0000\u0000\u0000\u00f5\u0001\u0000" + + "\u0000\u0000\u0000\u00f7\u0001\u0000\u0000\u0000\u0000\u00f9\u0001\u0000" + + "\u0000\u0000\u0000\u00fb\u0001\u0000\u0000\u0000\u0000\u00fd\u0001\u0000" + + "\u0000\u0000\u0000\u00ff\u0001\u0000\u0000\u0000\u0000\u0101\u0001\u0000" + + "\u0000\u0000\u0000\u0103\u0001\u0000\u0000\u0000\u0000\u0105\u0001\u0000" + + "\u0000\u0000\u0000\u0107\u0001\u0000\u0000\u0000\u0000\u0109\u0001\u0000" + + "\u0000\u0000\u0000\u010b\u0001\u0000\u0000\u0000\u0000\u010d\u0001\u0000" + + "\u0000\u0000\u0000\u010f\u0001\u0000\u0000\u0000\u0000\u0111\u0001\u0000" + + "\u0000\u0000\u0000\u0119\u0001\u0000\u0000\u0000\u0000\u011d\u0001\u0000" + + "\u0000\u0000\u0000\u0121\u0001\u0000\u0000\u0000\u0000\u0123\u0001\u0000" + + "\u0000\u0000\u0000\u0125\u0001\u0000\u0000\u0000\u0000\u0127\u0001\u0000" + + "\u0000\u0000\u0000\u0129\u0001\u0000\u0000\u0000\u0000\u012b\u0001\u0000" + + "\u0000\u0000\u0000\u012d\u0001\u0000\u0000\u0000\u0000\u0137\u0001\u0000" + + "\u0000\u0000\u0000\u0139\u0001\u0000\u0000\u0000\u0000\u013b\u0001\u0000" + + "\u0000\u0000\u0000\u013d\u0001\u0000\u0000\u0000\u0000\u013f\u0001\u0000" + + "\u0000\u0000\u0000\u0141\u0001\u0000\u0000\u0000\u0000\u0143\u0001\u0000" + + "\u0000\u0000\u0001\u0145\u0001\u0000\u0000\u0000\u0001\u0147\u0001\u0000" + + "\u0000\u0000\u0001\u0149\u0001\u0000\u0000\u0000\u0001\u014b\u0001\u0000" + + "\u0000\u0000\u0001\u014d\u0001\u0000\u0000\u0000\u0001\u014f\u0001\u0000" + + "\u0000\u0000\u0001\u0151\u0001\u0000\u0000\u0000\u0001\u0153\u0001\u0000" + + "\u0000\u0000\u0001\u0155\u0001\u0000\u0000\u0000\u0001\u0157\u0001\u0000" + + "\u0000\u0000\u0001\u0159\u0001\u0000\u0000\u0000\u0001\u015b\u0001\u0000" + + "\u0000\u0000\u0001\u015d\u0001\u0000\u0000\u0000\u0001\u015f\u0001\u0000" + + "\u0000\u0000\u0001\u0161\u0001\u0000\u0000\u0000\u0001\u0163\u0001\u0000" + + "\u0000\u0000\u0001\u0165\u0001\u0000\u0000\u0000\u0001\u0167\u0001\u0000" + + "\u0000\u0000\u0001\u0169\u0001\u0000\u0000\u0000\u0001\u016b\u0001\u0000" + + "\u0000\u0000\u0001\u016d\u0001\u0000\u0000\u0000\u0001\u016f\u0001\u0000" + + "\u0000\u0000\u0001\u0171\u0001\u0000\u0000\u0000\u0001\u0173\u0001\u0000" + + "\u0000\u0000\u0001\u0175\u0001\u0000\u0000\u0000\u0001\u0177\u0001\u0000" + + "\u0000\u0000\u0001\u0179\u0001\u0000\u0000\u0000\u0001\u017b\u0001\u0000" + + "\u0000\u0000\u0001\u017d\u0001\u0000\u0000\u0000\u0001\u017f\u0001\u0000" + + "\u0000\u0000\u0001\u0181\u0001\u0000\u0000\u0000\u0001\u0183\u0001\u0000" + + "\u0000\u0000\u0001\u0185\u0001\u0000\u0000\u0000\u0001\u0187\u0001\u0000" + + "\u0000\u0000\u0001\u0189\u0001\u0000\u0000\u0000\u0001\u018b\u0001\u0000" + + "\u0000\u0000\u0001\u018d\u0001\u0000\u0000\u0000\u0001\u018f\u0001\u0000" + + "\u0000\u0000\u0001\u0191\u0001\u0000\u0000\u0000\u0001\u0193\u0001\u0000" + + "\u0000\u0000\u0001\u0195\u0001\u0000\u0000\u0000\u0001\u0197\u0001\u0000" + + "\u0000\u0000\u0001\u0199\u0001\u0000\u0000\u0000\u0001\u019b\u0001\u0000" + + "\u0000\u0000\u0001\u019d\u0001\u0000\u0000\u0000\u0001\u019f\u0001\u0000" + + "\u0000\u0000\u0001\u01a1\u0001\u0000\u0000\u0000\u0001\u01a3\u0001\u0000" + + "\u0000\u0000\u0001\u01a5\u0001\u0000\u0000\u0000\u0001\u01a7\u0001\u0000" + + "\u0000\u0000\u0001\u01a9\u0001\u0000\u0000\u0000\u0001\u01ab\u0001\u0000" + + "\u0000\u0000\u0001\u01ad\u0001\u0000\u0000\u0000\u0001\u01af\u0001\u0000" + + "\u0000\u0000\u0001\u01b1\u0001\u0000\u0000\u0000\u0001\u01b3\u0001\u0000" + + "\u0000\u0000\u0001\u01b5\u0001\u0000\u0000\u0000\u0001\u01b7\u0001\u0000" + + "\u0000\u0000\u0001\u01b9\u0001\u0000\u0000\u0000\u0001\u01bb\u0001\u0000" + + "\u0000\u0000\u0001\u01bd\u0001\u0000\u0000\u0000\u0001\u01bf\u0001\u0000" + + "\u0000\u0000\u0001\u01c1\u0001\u0000\u0000\u0000\u0001\u01c3\u0001\u0000" + + "\u0000\u0000\u0001\u01c5\u0001\u0000\u0000\u0000\u0001\u01c7\u0001\u0000" + + "\u0000\u0000\u0001\u01c9\u0001\u0000\u0000\u0000\u0001\u01cb\u0001\u0000" + + "\u0000\u0000\u0001\u01cd\u0001\u0000\u0000\u0000\u0001\u01cf\u0001\u0000" + + "\u0000\u0000\u0001\u01d1\u0001\u0000\u0000\u0000\u0001\u01d3\u0001\u0000" + + "\u0000\u0000\u0001\u01d5\u0001\u0000\u0000\u0000\u0001\u01d7\u0001\u0000" + + "\u0000\u0000\u0001\u01d9\u0001\u0000\u0000\u0000\u0001\u01db\u0001\u0000" + + "\u0000\u0000\u0001\u01dd\u0001\u0000\u0000\u0000\u0001\u01df\u0001\u0000" + + "\u0000\u0000\u0001\u01e1\u0001\u0000\u0000\u0000\u0001\u01e3\u0001\u0000" + + "\u0000\u0000\u0001\u01e5\u0001\u0000\u0000\u0000\u0001\u01e7\u0001\u0000" + + "\u0000\u0000\u0001\u01e9\u0001\u0000\u0000\u0000\u0001\u01eb\u0001\u0000" + + "\u0000\u0000\u0001\u01ed\u0001\u0000\u0000\u0000\u0001\u01ef\u0001\u0000" + + "\u0000\u0000\u0001\u01f1\u0001\u0000\u0000\u0000\u0001\u01f3\u0001\u0000" + + "\u0000\u0000\u0001\u01f5\u0001\u0000\u0000\u0000\u0001\u01f7\u0001\u0000" + + "\u0000\u0000\u0001\u01f9\u0001\u0000\u0000\u0000\u0001\u01fb\u0001\u0000" + + "\u0000\u0000\u0001\u01fd\u0001\u0000\u0000\u0000\u0001\u01ff\u0001\u0000" + + "\u0000\u0000\u0001\u0201\u0001\u0000\u0000\u0000\u0001\u0203\u0001\u0000" + + "\u0000\u0000\u0001\u0205\u0001\u0000\u0000\u0000\u0001\u0207\u0001\u0000" + + "\u0000\u0000\u0001\u0209\u0001\u0000\u0000\u0000\u0001\u020b\u0001\u0000" + + "\u0000\u0000\u0001\u020d\u0001\u0000\u0000\u0000\u0001\u020f\u0001\u0000" + + "\u0000\u0000\u0001\u0211\u0001\u0000\u0000\u0000\u0001\u0213\u0001\u0000" + + "\u0000\u0000\u0001\u0215\u0001\u0000\u0000\u0000\u0001\u0217\u0001\u0000" + + "\u0000\u0000\u0001\u0219\u0001\u0000\u0000\u0000\u0001\u021b\u0001\u0000" + + "\u0000\u0000\u0001\u021d\u0001\u0000\u0000\u0000\u0001\u021f\u0001\u0000" + + "\u0000\u0000\u0001\u0221\u0001\u0000\u0000\u0000\u0001\u0223\u0001\u0000" + + "\u0000\u0000\u0001\u0225\u0001\u0000\u0000\u0000\u0001\u0227\u0001\u0000" + + "\u0000\u0000\u0001\u0229\u0001\u0000\u0000\u0000\u0001\u022b\u0001\u0000" + + "\u0000\u0000\u0001\u022d\u0001\u0000\u0000\u0000\u0001\u022f\u0001\u0000" + + "\u0000\u0000\u0001\u0231\u0001\u0000\u0000\u0000\u0001\u0233\u0001\u0000" + + "\u0000\u0000\u0001\u0235\u0001\u0000\u0000\u0000\u0002\u0237\u0001\u0000" + + "\u0000\u0000\u0002\u0239\u0001\u0000\u0000\u0000\u0002\u023b\u0001\u0000" + + "\u0000\u0000\u0002\u023d\u0001\u0000\u0000\u0000\u0002\u023f\u0001\u0000" + + "\u0000\u0000\u0003\u0241\u0001\u0000\u0000\u0000\u0003\u0243\u0001\u0000" + + "\u0000\u0000\u0003\u0245\u0001\u0000\u0000\u0000\u0003\u0247\u0001\u0000" + + "\u0000\u0000\u0003\u0249\u0001\u0000\u0000\u0000\u0003\u024b\u0001\u0000" + + "\u0000\u0000\u0003\u024d\u0001\u0000\u0000\u0000\u0004\u024f\u0001\u0000" + + "\u0000\u0000\u0004\u0251\u0001\u0000\u0000\u0000\u0004\u0253\u0001\u0000" + + "\u0000\u0000\u0004\u0255\u0001\u0000\u0000\u0000\u0004\u0257\u0001\u0000" + + "\u0000\u0000\u0004\u0259\u0001\u0000\u0000\u0000\u0004\u025b\u0001\u0000" + + "\u0000\u0000\u0004\u025d\u0001\u0000\u0000\u0000\u0004\u025f\u0001\u0000" + + "\u0000\u0000\u0004\u0261\u0001\u0000\u0000\u0000\u0004\u0263\u0001\u0000" + + "\u0000\u0000\u0004\u0265\u0001\u0000\u0000\u0000\u0004\u0267\u0001\u0000" + + "\u0000\u0000\u0004\u0269\u0001\u0000\u0000\u0000\u0004\u026b\u0001\u0000" + + "\u0000\u0000\u0004\u026d\u0001\u0000\u0000\u0000\u0004\u026f\u0001\u0000" + + "\u0000\u0000\u0004\u0271\u0001\u0000\u0000\u0000\u0004\u0273\u0001\u0000" + + "\u0000\u0000\u0004\u0275\u0001\u0000\u0000\u0000\u0004\u0277\u0001\u0000" + + "\u0000\u0000\u0004\u0279\u0001\u0000\u0000\u0000\u0004\u027b\u0001\u0000" + + "\u0000\u0000\u0004\u027d\u0001\u0000\u0000\u0000\u0004\u027f\u0001\u0000" + + "\u0000\u0000\u0004\u0281\u0001\u0000\u0000\u0000\u0004\u0283\u0001\u0000" + + "\u0000\u0000\u0004\u0285\u0001\u0000\u0000\u0000\u0004\u0287\u0001\u0000" + + "\u0000\u0000\u0004\u0289\u0001\u0000\u0000\u0000\u0004\u028b\u0001\u0000" + + "\u0000\u0000\u0004\u028d\u0001\u0000\u0000\u0000\u0004\u028f\u0001\u0000" + + "\u0000\u0000\u0004\u0291\u0001\u0000\u0000\u0000\u0004\u0293\u0001\u0000" + + "\u0000\u0000\u0004\u0295\u0001\u0000\u0000\u0000\u0004\u0297\u0001\u0000" + + "\u0000\u0000\u0004\u0299\u0001\u0000\u0000\u0000\u0004\u029b\u0001\u0000" + + "\u0000\u0000\u0004\u029d\u0001\u0000\u0000\u0000\u0004\u029f\u0001\u0000" + + "\u0000\u0000\u0004\u02a1\u0001\u0000\u0000\u0000\u0004\u02a3\u0001\u0000" + + "\u0000\u0000\u0004\u02a5\u0001\u0000\u0000\u0000\u0004\u02a7\u0001\u0000" + + "\u0000\u0000\u0004\u02a9\u0001\u0000\u0000\u0000\u0004\u02ab\u0001\u0000" + + "\u0000\u0000\u0004\u02ad\u0001\u0000\u0000\u0000\u0004\u02af\u0001\u0000" + + "\u0000\u0000\u0004\u02b1\u0001\u0000\u0000\u0000\u0004\u02b3\u0001\u0000" + + "\u0000\u0000\u0004\u02b5\u0001\u0000\u0000\u0000\u0004\u02b7\u0001\u0000" + + "\u0000\u0000\u0004\u02b9\u0001\u0000\u0000\u0000\u0004\u02bb\u0001\u0000" + + "\u0000\u0000\u0004\u02bd\u0001\u0000\u0000\u0000\u0004\u02bf\u0001\u0000" + + "\u0000\u0000\u0004\u02c1\u0001\u0000\u0000\u0000\u0004\u02c3\u0001\u0000" + + "\u0000\u0000\u0004\u02c5\u0001\u0000\u0000\u0000\u0004\u02c7\u0001\u0000" + + "\u0000\u0000\u0004\u02c9\u0001\u0000\u0000\u0000\u0004\u02cb\u0001\u0000" + + "\u0000\u0000\u0004\u02cd\u0001\u0000\u0000\u0000\u0004\u02cf\u0001\u0000" + + "\u0000\u0000\u0004\u02d1\u0001\u0000\u0000\u0000\u0004\u02d3\u0001\u0000" + + "\u0000\u0000\u0005\u02d5\u0001\u0000\u0000\u0000\u0007\u02e0\u0001\u0000" + + "\u0000\u0000\t\u02ef\u0001\u0000\u0000\u0000\u000b\u02fa\u0001\u0000\u0000" + + "\u0000\r\u0301\u0001\u0000\u0000\u0000\u000f\u0303\u0001\u0000\u0000\u0000" + + "\u0011\u0307\u0001\u0000\u0000\u0000\u0013\u0309\u0001\u0000\u0000\u0000" + + "\u0015\u030b\u0001\u0000\u0000\u0000\u0017\u030f\u0001\u0000\u0000\u0000" + + "\u0019\u0311\u0001\u0000\u0000\u0000\u001b\u0315\u0001\u0000\u0000\u0000" + + "\u001d\u0317\u0001\u0000\u0000\u0000\u001f\u0319\u0001\u0000\u0000\u0000" + + "!\u031b\u0001\u0000\u0000\u0000#\u031d\u0001\u0000\u0000\u0000%\u031f" + + "\u0001\u0000\u0000\u0000\'\u0321\u0001\u0000\u0000\u0000)\u0323\u0001" + + "\u0000\u0000\u0000+\u0325\u0001\u0000\u0000\u0000-\u0328\u0001\u0000\u0000" + + "\u0000/\u032b\u0001\u0000\u0000\u00001\u032e\u0001\u0000\u0000\u00003" + + "\u0331\u0001\u0000\u0000\u00005\u0333\u0001\u0000\u0000\u00007\u0335\u0001" + + "\u0000\u0000\u00009\u0337\u0001\u0000\u0000\u0000;\u0339\u0001\u0000\u0000" + + "\u0000=\u033c\u0001\u0000\u0000\u0000?\u033f\u0001\u0000\u0000\u0000A" + + "\u0342\u0001\u0000\u0000\u0000C\u0345\u0001\u0000\u0000\u0000E\u0348\u0001" + + "\u0000\u0000\u0000G\u034b\u0001\u0000\u0000\u0000I\u034e\u0001\u0000\u0000" + + "\u0000K\u0351\u0001\u0000\u0000\u0000M\u0354\u0001\u0000\u0000\u0000O" + + "\u0358\u0001\u0000\u0000\u0000Q\u035b\u0001\u0000\u0000\u0000S\u035d\u0001" + + "\u0000\u0000\u0000U\u035f\u0001\u0000\u0000\u0000W\u0361\u0001\u0000\u0000" + + "\u0000Y\u0364\u0001\u0000\u0000\u0000[\u0366\u0001\u0000\u0000\u0000]" + + "\u0368\u0001\u0000\u0000\u0000_\u036b\u0001\u0000\u0000\u0000a\u036e\u0001" + + "\u0000\u0000\u0000c\u0371\u0001\u0000\u0000\u0000e\u0375\u0001\u0000\u0000" + + "\u0000g\u0379\u0001\u0000\u0000\u0000i\u037c\u0001\u0000\u0000\u0000k" + + "\u0380\u0001\u0000\u0000\u0000m\u0382\u0001\u0000\u0000\u0000o\u038c\u0001" + + "\u0000\u0000\u0000q\u0398\u0001\u0000\u0000\u0000s\u03a1\u0001\u0000\u0000" + + "\u0000u\u03a7\u0001\u0000\u0000\u0000w\u03af\u0001\u0000\u0000\u0000y" + + "\u03b6\u0001\u0000\u0000\u0000{\u03bc\u0001\u0000\u0000\u0000}\u03c6\u0001" + + "\u0000\u0000\u0000\u007f\u03ca\u0001\u0000\u0000\u0000\u0081\u03d1\u0001" + + "\u0000\u0000\u0000\u0083\u03d5\u0001\u0000\u0000\u0000\u0085\u03d9\u0001" + + "\u0000\u0000\u0000\u0087\u03e3\u0001\u0000\u0000\u0000\u0089\u03ef\u0001" + + "\u0000\u0000\u0000\u008b\u03f2\u0001\u0000\u0000\u0000\u008d\u03fc\u0001" + + "\u0000\u0000\u0000\u008f\u0401\u0001\u0000\u0000\u0000\u0091\u0406\u0001" + + "\u0000\u0000\u0000\u0093\u040c\u0001\u0000\u0000\u0000\u0095\u0413\u0001" + + "\u0000\u0000\u0000\u0097\u0419\u0001\u0000\u0000\u0000\u0099\u041c\u0001" + + "\u0000\u0000\u0000\u009b\u0421\u0001\u0000\u0000\u0000\u009d\u0426\u0001" + + "\u0000\u0000\u0000\u009f\u042a\u0001\u0000\u0000\u0000\u00a1\u0430\u0001" + + "\u0000\u0000\u0000\u00a3\u0438\u0001\u0000\u0000\u0000\u00a5\u043c\u0001" + + "\u0000\u0000\u0000\u00a7\u043f\u0001\u0000\u0000\u0000\u00a9\u0445\u0001" + + "\u0000\u0000\u0000\u00ab\u044b\u0001\u0000\u0000\u0000\u00ad\u0452\u0001" + + "\u0000\u0000\u0000\u00af\u045b\u0001\u0000\u0000\u0000\u00b1\u0461\u0001" + + "\u0000\u0000\u0000\u00b3\u0464\u0001\u0000\u0000\u0000\u00b5\u0467\u0001" + + "\u0000\u0000\u0000\u00b7\u046a\u0001\u0000\u0000\u0000\u00b9\u0474\u0001" + + "\u0000\u0000\u0000\u00bb\u047e\u0001\u0000\u0000\u0000\u00bd\u0482\u0001" + + "\u0000\u0000\u0000\u00bf\u0489\u0001\u0000\u0000\u0000\u00c1\u0493\u0001" + + "\u0000\u0000\u0000\u00c3\u0498\u0001\u0000\u0000\u0000\u00c5\u049d\u0001" + + "\u0000\u0000\u0000\u00c7\u04a1\u0001\u0000\u0000\u0000\u00c9\u04a5\u0001" + + "\u0000\u0000\u0000\u00cb\u04af\u0001\u0000\u0000\u0000\u00cd\u04b6\u0001" + + "\u0000\u0000\u0000\u00cf\u04c0\u0001\u0000\u0000\u0000\u00d1\u04ca\u0001" + + "\u0000\u0000\u0000\u00d3\u04d2\u0001\u0000\u0000\u0000\u00d5\u04d9\u0001" + + "\u0000\u0000\u0000\u00d7\u04e1\u0001\u0000\u0000\u0000\u00d9\u04eb\u0001" + + "\u0000\u0000\u0000\u00db\u04f4\u0001\u0000\u0000\u0000\u00dd\u04f9\u0001" + + "\u0000\u0000\u0000\u00df\u0500\u0001\u0000\u0000\u0000\u00e1\u050b\u0001" + + "\u0000\u0000\u0000\u00e3\u0510\u0001\u0000\u0000\u0000\u00e5\u0516\u0001" + + "\u0000\u0000\u0000\u00e7\u051e\u0001\u0000\u0000\u0000\u00e9\u0527\u0001" + + "\u0000\u0000\u0000\u00eb\u052e\u0001\u0000\u0000\u0000\u00ed\u0534\u0001" + + "\u0000\u0000\u0000\u00ef\u053d\u0001\u0000\u0000\u0000\u00f1\u0545\u0001" + + "\u0000\u0000\u0000\u00f3\u054e\u0001\u0000\u0000\u0000\u00f5\u0557\u0001" + + "\u0000\u0000\u0000\u00f7\u055d\u0001\u0000\u0000\u0000\u00f9\u0562\u0001" + + "\u0000\u0000\u0000\u00fb\u0568\u0001\u0000\u0000\u0000\u00fd\u0571\u0001" + + "\u0000\u0000\u0000\u00ff\u0578\u0001\u0000\u0000\u0000\u0101\u0581\u0001" + + "\u0000\u0000\u0000\u0103\u058d\u0001\u0000\u0000\u0000\u0105\u0595\u0001" + + "\u0000\u0000\u0000\u0107\u0599\u0001\u0000\u0000\u0000\u0109\u05a1\u0001" + + "\u0000\u0000\u0000\u010b\u05a5\u0001\u0000\u0000\u0000\u010d\u05c1\u0001" + + "\u0000\u0000\u0000\u010f\u061c\u0001\u0000\u0000\u0000\u0111\u067b\u0001" + + "\u0000\u0000\u0000\u0113\u067d\u0001\u0000\u0000\u0000\u0115\u067f\u0001" + + "\u0000\u0000\u0000\u0117\u0681\u0001\u0000\u0000\u0000\u0119\u0683\u0001" + + "\u0000\u0000\u0000\u011b\u068d\u0001\u0000\u0000\u0000\u011d\u068f\u0001" + + "\u0000\u0000\u0000\u011f\u0699\u0001\u0000\u0000\u0000\u0121\u06a4\u0001" + + "\u0000\u0000\u0000\u0123\u06a6\u0001\u0000\u0000\u0000\u0125\u06be\u0001" + + "\u0000\u0000\u0000\u0127\u06c0\u0001\u0000\u0000\u0000\u0129\u06c3\u0001" + + "\u0000\u0000\u0000\u012b\u06c6\u0001\u0000\u0000\u0000\u012d\u06c9\u0001" + + "\u0000\u0000\u0000\u012f\u06d2\u0001\u0000\u0000\u0000\u0131\u06d4\u0001" + + "\u0000\u0000\u0000\u0133\u06db\u0001\u0000\u0000\u0000\u0135\u06e4\u0001" + + "\u0000\u0000\u0000\u0137\u06e6\u0001\u0000\u0000\u0000\u0139\u06e8\u0001" + + "\u0000\u0000\u0000\u013b\u06ea\u0001\u0000\u0000\u0000\u013d\u06ec\u0001" + + "\u0000\u0000\u0000\u013f\u06ee\u0001\u0000\u0000\u0000\u0141\u06f0\u0001" + + "\u0000\u0000\u0000\u0143\u06f2\u0001\u0000\u0000\u0000\u0145\u06f4\u0001" + + "\u0000\u0000\u0000\u0147\u06f9\u0001\u0000\u0000\u0000\u0149\u06fe\u0001" + + "\u0000\u0000\u0000\u014b\u0703\u0001\u0000\u0000\u0000\u014d\u0708\u0001" + + "\u0000\u0000\u0000\u014f\u070c\u0001\u0000\u0000\u0000\u0151\u0710\u0001" + + "\u0000\u0000\u0000\u0153\u0714\u0001\u0000\u0000\u0000\u0155\u0718\u0001" + + "\u0000\u0000\u0000\u0157\u071c\u0001\u0000\u0000\u0000\u0159\u0720\u0001" + + "\u0000\u0000\u0000\u015b\u0724\u0001\u0000\u0000\u0000\u015d\u0728\u0001" + + "\u0000\u0000\u0000\u015f\u072c\u0001\u0000\u0000\u0000\u0161\u0730\u0001" + + "\u0000\u0000\u0000\u0163\u0734\u0001\u0000\u0000\u0000\u0165\u0738\u0001" + + "\u0000\u0000\u0000\u0167\u073c\u0001\u0000\u0000\u0000\u0169\u0740\u0001" + + "\u0000\u0000\u0000\u016b\u0744\u0001\u0000\u0000\u0000\u016d\u0748\u0001" + + "\u0000\u0000\u0000\u016f\u074c\u0001\u0000\u0000\u0000\u0171\u0750\u0001" + + "\u0000\u0000\u0000\u0173\u0754\u0001\u0000\u0000\u0000\u0175\u0758\u0001" + + "\u0000\u0000\u0000\u0177\u075c\u0001\u0000\u0000\u0000\u0179\u0760\u0001" + + "\u0000\u0000\u0000\u017b\u0764\u0001\u0000\u0000\u0000\u017d\u0768\u0001" + + "\u0000\u0000\u0000\u017f\u076c\u0001\u0000\u0000\u0000\u0181\u0770\u0001" + + "\u0000\u0000\u0000\u0183\u0774\u0001\u0000\u0000\u0000\u0185\u0778\u0001" + + "\u0000\u0000\u0000\u0187\u077c\u0001\u0000\u0000\u0000\u0189\u0780\u0001" + + "\u0000\u0000\u0000\u018b\u0784\u0001\u0000\u0000\u0000\u018d\u0788\u0001" + + "\u0000\u0000\u0000\u018f\u078c\u0001\u0000\u0000\u0000\u0191\u0790\u0001" + + "\u0000\u0000\u0000\u0193\u0794\u0001\u0000\u0000\u0000\u0195\u0798\u0001" + + "\u0000\u0000\u0000\u0197\u079c\u0001\u0000\u0000\u0000\u0199\u07a0\u0001" + + "\u0000\u0000\u0000\u019b\u07a4\u0001\u0000\u0000\u0000\u019d\u07a8\u0001" + + "\u0000\u0000\u0000\u019f\u07ac\u0001\u0000\u0000\u0000\u01a1\u07b0\u0001" + + "\u0000\u0000\u0000\u01a3\u07b4\u0001\u0000\u0000\u0000\u01a5\u07b8\u0001" + + "\u0000\u0000\u0000\u01a7\u07bc\u0001\u0000\u0000\u0000\u01a9\u07c1\u0001" + + "\u0000\u0000\u0000\u01ab\u07c6\u0001\u0000\u0000\u0000\u01ad\u07ca\u0001" + + "\u0000\u0000\u0000\u01af\u07ce\u0001\u0000\u0000\u0000\u01b1\u07d2\u0001" + + "\u0000\u0000\u0000\u01b3\u07d6\u0001\u0000\u0000\u0000\u01b5\u07da\u0001" + + "\u0000\u0000\u0000\u01b7\u07de\u0001\u0000\u0000\u0000\u01b9\u07e2\u0001" + + "\u0000\u0000\u0000\u01bb\u07e6\u0001\u0000\u0000\u0000\u01bd\u07ea\u0001" + + "\u0000\u0000\u0000\u01bf\u07ee\u0001\u0000\u0000\u0000\u01c1\u07f2\u0001" + + "\u0000\u0000\u0000\u01c3\u07f6\u0001\u0000\u0000\u0000\u01c5\u07fa\u0001" + + "\u0000\u0000\u0000\u01c7\u07fe\u0001\u0000\u0000\u0000\u01c9\u0802\u0001" + + "\u0000\u0000\u0000\u01cb\u0806\u0001\u0000\u0000\u0000\u01cd\u080a\u0001" + + "\u0000\u0000\u0000\u01cf\u080e\u0001\u0000\u0000\u0000\u01d1\u0812\u0001" + + "\u0000\u0000\u0000\u01d3\u0816\u0001\u0000\u0000\u0000\u01d5\u081a\u0001" + + "\u0000\u0000\u0000\u01d7\u081e\u0001\u0000\u0000\u0000\u01d9\u0822\u0001" + + "\u0000\u0000\u0000\u01db\u0826\u0001\u0000\u0000\u0000\u01dd\u082a\u0001" + + "\u0000\u0000\u0000\u01df\u082e\u0001\u0000\u0000\u0000\u01e1\u0832\u0001" + + "\u0000\u0000\u0000\u01e3\u0836\u0001\u0000\u0000\u0000\u01e5\u083a\u0001" + + "\u0000\u0000\u0000\u01e7\u083e\u0001\u0000\u0000\u0000\u01e9\u0842\u0001" + + "\u0000\u0000\u0000\u01eb\u0846\u0001\u0000\u0000\u0000\u01ed\u084a\u0001" + + "\u0000\u0000\u0000\u01ef\u084e\u0001\u0000\u0000\u0000\u01f1\u0852\u0001" + + "\u0000\u0000\u0000\u01f3\u0856\u0001\u0000\u0000\u0000\u01f5\u085a\u0001" + + "\u0000\u0000\u0000\u01f7\u085e\u0001\u0000\u0000\u0000\u01f9\u0862\u0001" + + "\u0000\u0000\u0000\u01fb\u0866\u0001\u0000\u0000\u0000\u01fd\u086a\u0001" + + "\u0000\u0000\u0000\u01ff\u086e\u0001\u0000\u0000\u0000\u0201\u0872\u0001" + + "\u0000\u0000\u0000\u0203\u0876\u0001\u0000\u0000\u0000\u0205\u087a\u0001" + + "\u0000\u0000\u0000\u0207\u087e\u0001\u0000\u0000\u0000\u0209\u0882\u0001" + + "\u0000\u0000\u0000\u020b\u0886\u0001\u0000\u0000\u0000\u020d\u088a\u0001" + + "\u0000\u0000\u0000\u020f\u088e\u0001\u0000\u0000\u0000\u0211\u0892\u0001" + + "\u0000\u0000\u0000\u0213\u0896\u0001\u0000\u0000\u0000\u0215\u089a\u0001" + + "\u0000\u0000\u0000\u0217\u089e\u0001\u0000\u0000\u0000\u0219\u08a2\u0001" + + "\u0000\u0000\u0000\u021b\u08a6\u0001\u0000\u0000\u0000\u021d\u08aa\u0001" + + "\u0000\u0000\u0000\u021f\u08ae\u0001\u0000\u0000\u0000\u0221\u08b2\u0001" + + "\u0000\u0000\u0000\u0223\u08b6\u0001\u0000\u0000\u0000\u0225\u08ba\u0001" + + "\u0000\u0000\u0000\u0227\u08be\u0001\u0000\u0000\u0000\u0229\u08c2\u0001" + + "\u0000\u0000\u0000\u022b\u08c6\u0001\u0000\u0000\u0000\u022d\u08ca\u0001" + + "\u0000\u0000\u0000\u022f\u08ce\u0001\u0000\u0000\u0000\u0231\u08d4\u0001" + + "\u0000\u0000\u0000\u0233\u08d8\u0001\u0000\u0000\u0000\u0235\u08dc\u0001" + + "\u0000\u0000\u0000\u0237\u08e0\u0001\u0000\u0000\u0000\u0239\u08e4\u0001" + + "\u0000\u0000\u0000\u023b\u08ec\u0001\u0000\u0000\u0000\u023d\u08f1\u0001" + + "\u0000\u0000\u0000\u023f\u08f3\u0001\u0000\u0000\u0000\u0241\u08f9\u0001" + + "\u0000\u0000\u0000\u0243\u0902\u0001\u0000\u0000\u0000\u0245\u0906\u0001" + + "\u0000\u0000\u0000\u0247\u090e\u0001\u0000\u0000\u0000\u0249\u0910\u0001" + + "\u0000\u0000\u0000\u024b\u0913\u0001\u0000\u0000\u0000\u024d\u0918\u0001" + + "\u0000\u0000\u0000\u024f\u091c\u0001\u0000\u0000\u0000\u0251\u0921\u0001" + + "\u0000\u0000\u0000\u0253\u0926\u0001\u0000\u0000\u0000\u0255\u092b\u0001" + + "\u0000\u0000\u0000\u0257\u092f\u0001\u0000\u0000\u0000\u0259\u0933\u0001" + + "\u0000\u0000\u0000\u025b\u0938\u0001\u0000\u0000\u0000\u025d\u093c\u0001" + + "\u0000\u0000\u0000\u025f\u0940\u0001\u0000\u0000\u0000\u0261\u0944\u0001" + + "\u0000\u0000\u0000\u0263\u0948\u0001\u0000\u0000\u0000\u0265\u094c\u0001" + + "\u0000\u0000\u0000\u0267\u0950\u0001\u0000\u0000\u0000\u0269\u0954\u0001" + + "\u0000\u0000\u0000\u026b\u0958\u0001\u0000\u0000\u0000\u026d\u095c\u0001" + + "\u0000\u0000\u0000\u026f\u0960\u0001\u0000\u0000\u0000\u0271\u0964\u0001" + + "\u0000\u0000\u0000\u0273\u0968\u0001\u0000\u0000\u0000\u0275\u096c\u0001" + + "\u0000\u0000\u0000\u0277\u0970\u0001\u0000\u0000\u0000\u0279\u0974\u0001" + + "\u0000\u0000\u0000\u027b\u0978\u0001\u0000\u0000\u0000\u027d\u097c\u0001" + + "\u0000\u0000\u0000\u027f\u0980\u0001\u0000\u0000\u0000\u0281\u0984\u0001" + + "\u0000\u0000\u0000\u0283\u0988\u0001\u0000\u0000\u0000\u0285\u098c\u0001" + + "\u0000\u0000\u0000\u0287\u0990\u0001\u0000\u0000\u0000\u0289\u0994\u0001" + + "\u0000\u0000\u0000\u028b\u0998\u0001\u0000\u0000\u0000\u028d\u099c\u0001" + + "\u0000\u0000\u0000\u028f\u09a0\u0001\u0000\u0000\u0000\u0291\u09a4\u0001" + + "\u0000\u0000\u0000\u0293\u09a8\u0001\u0000\u0000\u0000\u0295\u09ac\u0001" + + "\u0000\u0000\u0000\u0297\u09b0\u0001\u0000\u0000\u0000\u0299\u09b4\u0001" + + "\u0000\u0000\u0000\u029b\u09b8\u0001\u0000\u0000\u0000\u029d\u09bc\u0001" + + "\u0000\u0000\u0000\u029f\u09c0\u0001\u0000\u0000\u0000\u02a1\u09c4\u0001" + + "\u0000\u0000\u0000\u02a3\u09c8\u0001\u0000\u0000\u0000\u02a5\u09cc\u0001" + + "\u0000\u0000\u0000\u02a7\u09d0\u0001\u0000\u0000\u0000\u02a9\u09d2\u0001" + + "\u0000\u0000\u0000\u02ab\u09d6\u0001\u0000\u0000\u0000\u02ad\u09da\u0001" + + "\u0000\u0000\u0000\u02af\u09de\u0001\u0000\u0000\u0000\u02b1\u09e2\u0001" + + "\u0000\u0000\u0000\u02b3\u09e6\u0001\u0000\u0000\u0000\u02b5\u09ea\u0001" + + "\u0000\u0000\u0000\u02b7\u09ef\u0001\u0000\u0000\u0000\u02b9\u09f4\u0001" + + "\u0000\u0000\u0000\u02bb\u09f8\u0001\u0000\u0000\u0000\u02bd\u09fc\u0001" + + "\u0000\u0000\u0000\u02bf\u0a00\u0001\u0000\u0000\u0000\u02c1\u0a04\u0001" + + "\u0000\u0000\u0000\u02c3\u0a08\u0001\u0000\u0000\u0000\u02c5\u0a0c\u0001" + + "\u0000\u0000\u0000\u02c7\u0a10\u0001\u0000\u0000\u0000\u02c9\u0a14\u0001" + + "\u0000\u0000\u0000\u02cb\u0a18\u0001\u0000\u0000\u0000\u02cd\u0a1c\u0001" + + "\u0000\u0000\u0000\u02cf\u0a22\u0001\u0000\u0000\u0000\u02d1\u0a26\u0001" + + "\u0000\u0000\u0000\u02d3\u0a2a\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005" + + "#\u0000\u0000\u02d6\u02d7\u0005!\u0000\u0000\u02d7\u02db\u0001\u0000\u0000" + + "\u0000\u02d8\u02da\b\u0000\u0000\u0000\u02d9\u02d8\u0001\u0000\u0000\u0000" + + "\u02da\u02dd\u0001\u0000\u0000\u0000\u02db\u02d9\u0001\u0000\u0000\u0000" + + "\u02db\u02dc\u0001\u0000\u0000\u0000\u02dc\u02de\u0001\u0000\u0000\u0000" + + "\u02dd\u02db\u0001\u0000\u0000\u0000\u02de\u02df\u0006\u0000\u0000\u0000" + + "\u02df\u0006\u0001\u0000\u0000\u0000\u02e0\u02e1\u0005/\u0000\u0000\u02e1" + + "\u02e2\u0005*\u0000\u0000\u02e2\u02e7\u0001\u0000\u0000\u0000\u02e3\u02e6" + + "\u0003\u0007\u0001\u0000\u02e4\u02e6\t\u0000\u0000\u0000\u02e5\u02e3\u0001" + + "\u0000\u0000\u0000\u02e5\u02e4\u0001\u0000\u0000\u0000\u02e6\u02e9\u0001" + + "\u0000\u0000\u0000\u02e7\u02e8\u0001\u0000\u0000\u0000\u02e7\u02e5\u0001" + + "\u0000\u0000\u0000\u02e8\u02ea\u0001\u0000\u0000\u0000\u02e9\u02e7\u0001" + + "\u0000\u0000\u0000\u02ea\u02eb\u0005*\u0000\u0000\u02eb\u02ec\u0005/\u0000" + + "\u0000\u02ec\u02ed\u0001\u0000\u0000\u0000\u02ed\u02ee\u0006\u0001\u0000" + + "\u0000\u02ee\b\u0001\u0000\u0000\u0000\u02ef\u02f0\u0005/\u0000\u0000" + + "\u02f0\u02f1\u0005/\u0000\u0000\u02f1\u02f5\u0001\u0000\u0000\u0000\u02f2" + + "\u02f4\b\u0000\u0000\u0000\u02f3\u02f2\u0001\u0000\u0000\u0000\u02f4\u02f7" + + "\u0001\u0000\u0000\u0000\u02f5\u02f3\u0001\u0000\u0000\u0000\u02f5\u02f6" + + "\u0001\u0000\u0000\u0000\u02f6\u02f8\u0001\u0000\u0000\u0000\u02f7\u02f5" + + "\u0001\u0000\u0000\u0000\u02f8\u02f9\u0006\u0002\u0000\u0000\u02f9\n\u0001" + + "\u0000\u0000\u0000\u02fa\u02fb\u0007\u0001\u0000\u0000\u02fb\u02fc\u0001" + + "\u0000\u0000\u0000\u02fc\u02fd\u0006\u0003\u0001\u0000\u02fd\f\u0001\u0000" + + "\u0000\u0000\u02fe\u0302\u0005\n\u0000\u0000\u02ff\u0300\u0005\r\u0000" + + "\u0000\u0300\u0302\u0005\n\u0000\u0000\u0301\u02fe\u0001\u0000\u0000\u0000" + + "\u0301\u02ff\u0001\u0000\u0000\u0000\u0302\u000e\u0001\u0000\u0000\u0000" + + "\u0303\u0304\u0005.\u0000\u0000\u0304\u0305\u0005.\u0000\u0000\u0305\u0306" + + "\u0005.\u0000\u0000\u0306\u0010\u0001\u0000\u0000\u0000\u0307\u0308\u0005" + + ".\u0000\u0000\u0308\u0012\u0001\u0000\u0000\u0000\u0309\u030a\u0005,\u0000" + + "\u0000\u030a\u0014\u0001\u0000\u0000\u0000\u030b\u030c\u0005(\u0000\u0000" + + "\u030c\u030d\u0001\u0000\u0000\u0000\u030d\u030e\u0006\b\u0002\u0000\u030e" + + "\u0016\u0001\u0000\u0000\u0000\u030f\u0310\u0005)\u0000\u0000\u0310\u0018" + + "\u0001\u0000\u0000\u0000\u0311\u0312\u0005[\u0000\u0000\u0312\u0313\u0001" + + "\u0000\u0000\u0000\u0313\u0314\u0006\n\u0002\u0000\u0314\u001a\u0001\u0000" + + "\u0000\u0000\u0315\u0316\u0005]\u0000\u0000\u0316\u001c\u0001\u0000\u0000" + + "\u0000\u0317\u0318\u0005{\u0000\u0000\u0318\u001e\u0001\u0000\u0000\u0000" + + "\u0319\u031a\u0005}\u0000\u0000\u031a \u0001\u0000\u0000\u0000\u031b\u031c" + + "\u0005*\u0000\u0000\u031c\"\u0001\u0000\u0000\u0000\u031d\u031e\u0005" + + "%\u0000\u0000\u031e$\u0001\u0000\u0000\u0000\u031f\u0320\u0005/\u0000" + + "\u0000\u0320&\u0001\u0000\u0000\u0000\u0321\u0322\u0005+\u0000\u0000\u0322" + + "(\u0001\u0000\u0000\u0000\u0323\u0324\u0005-\u0000\u0000\u0324*\u0001" + + "\u0000\u0000\u0000\u0325\u0326\u0005+\u0000\u0000\u0326\u0327\u0005+\u0000" + + "\u0000\u0327,\u0001\u0000\u0000\u0000\u0328\u0329\u0005-\u0000\u0000\u0329" + + "\u032a\u0005-\u0000\u0000\u032a.\u0001\u0000\u0000\u0000\u032b\u032c\u0005" + + "&\u0000\u0000\u032c\u032d\u0005&\u0000\u0000\u032d0\u0001\u0000\u0000" + + "\u0000\u032e\u032f\u0005|\u0000\u0000\u032f\u0330\u0005|\u0000\u0000\u0330" + + "2\u0001\u0000\u0000\u0000\u0331\u0332\u0005!\u0000\u0000\u03324\u0001" + + "\u0000\u0000\u0000\u0333\u0334\u0005:\u0000\u0000\u03346\u0001\u0000\u0000" + + "\u0000\u0335\u0336\u0005;\u0000\u0000\u03368\u0001\u0000\u0000\u0000\u0337" + + "\u0338\u0005=\u0000\u0000\u0338:\u0001\u0000\u0000\u0000\u0339\u033a\u0005" + + "+\u0000\u0000\u033a\u033b\u0005=\u0000\u0000\u033b<\u0001\u0000\u0000" + + "\u0000\u033c\u033d\u0005-\u0000\u0000\u033d\u033e\u0005=\u0000\u0000\u033e" + + ">\u0001\u0000\u0000\u0000\u033f\u0340\u0005*\u0000\u0000\u0340\u0341\u0005" + + "=\u0000\u0000\u0341@\u0001\u0000\u0000\u0000\u0342\u0343\u0005/\u0000" + + "\u0000\u0343\u0344\u0005=\u0000\u0000\u0344B\u0001\u0000\u0000\u0000\u0345" + + "\u0346\u0005%\u0000\u0000\u0346\u0347\u0005=\u0000\u0000\u0347D\u0001" + + "\u0000\u0000\u0000\u0348\u0349\u0005-\u0000\u0000\u0349\u034a\u0005>\u0000" + + "\u0000\u034aF\u0001\u0000\u0000\u0000\u034b\u034c\u0005=\u0000\u0000\u034c" + + "\u034d\u0005>\u0000\u0000\u034dH\u0001\u0000\u0000\u0000\u034e\u034f\u0005" + + ".\u0000\u0000\u034f\u0350\u0005.\u0000\u0000\u0350J\u0001\u0000\u0000" + + "\u0000\u0351\u0352\u0005:\u0000\u0000\u0352\u0353\u0005:\u0000\u0000\u0353" + + "L\u0001\u0000\u0000\u0000\u0354\u0355\u0005?\u0000\u0000\u0355\u0356\u0005" + + ":\u0000\u0000\u0356\u0357\u0005:\u0000\u0000\u0357N\u0001\u0000\u0000" + + "\u0000\u0358\u0359\u0005;\u0000\u0000\u0359\u035a\u0005;\u0000\u0000\u035a" + + "P\u0001\u0000\u0000\u0000\u035b\u035c\u0005#\u0000\u0000\u035cR\u0001" + + "\u0000\u0000\u0000\u035d\u035e\u0005@\u0000\u0000\u035eT\u0001\u0000\u0000" + + "\u0000\u035f\u0360\u0005?\u0000\u0000\u0360V\u0001\u0000\u0000\u0000\u0361" + + "\u0362\u0005?\u0000\u0000\u0362\u0363\u0005:\u0000\u0000\u0363X\u0001" + + "\u0000\u0000\u0000\u0364\u0365\u0005<\u0000\u0000\u0365Z\u0001\u0000\u0000" + + "\u0000\u0366\u0367\u0005>\u0000\u0000\u0367\\\u0001\u0000\u0000\u0000" + + "\u0368\u0369\u0005<\u0000\u0000\u0369\u036a\u0005=\u0000\u0000\u036a^" + + "\u0001\u0000\u0000\u0000\u036b\u036c\u0005>\u0000\u0000\u036c\u036d\u0005" + + "=\u0000\u0000\u036d`\u0001\u0000\u0000\u0000\u036e\u036f\u0005!\u0000" + + "\u0000\u036f\u0370\u0005=\u0000\u0000\u0370b\u0001\u0000\u0000\u0000\u0371" + + "\u0372\u0005!\u0000\u0000\u0372\u0373\u0005=\u0000\u0000\u0373\u0374\u0005" + + "=\u0000\u0000\u0374d\u0001\u0000\u0000\u0000\u0375\u0376\u0005a\u0000" + + "\u0000\u0376\u0377\u0005s\u0000\u0000\u0377\u0378\u0005?\u0000\u0000\u0378" + + "f\u0001\u0000\u0000\u0000\u0379\u037a\u0005=\u0000\u0000\u037a\u037b\u0005" + + "=\u0000\u0000\u037bh\u0001\u0000\u0000\u0000\u037c\u037d\u0005=\u0000" + + "\u0000\u037d\u037e\u0005=\u0000\u0000\u037e\u037f\u0005=\u0000\u0000\u037f" + + "j\u0001\u0000\u0000\u0000\u0380\u0381\u0005\'\u0000\u0000\u0381l\u0001" + + "\u0000\u0000\u0000\u0382\u0383\u0005r\u0000\u0000\u0383\u0384\u0005e\u0000" + + "\u0000\u0384\u0385\u0005t\u0000\u0000\u0385\u0386\u0005u\u0000\u0000\u0386" + + "\u0387\u0005r\u0000\u0000\u0387\u0388\u0005n\u0000\u0000\u0388\u0389\u0005" + + "@\u0000\u0000\u0389\u038a\u0001\u0000\u0000\u0000\u038a\u038b\u0003\u0125" + + "\u0090\u0000\u038bn\u0001\u0000\u0000\u0000\u038c\u038d\u0005c\u0000\u0000" + + "\u038d\u038e\u0005o\u0000\u0000\u038e\u038f\u0005n\u0000\u0000\u038f\u0390" + + "\u0005t\u0000\u0000\u0390\u0391\u0005i\u0000\u0000\u0391\u0392\u0005n" + + "\u0000\u0000\u0392\u0393\u0005u\u0000\u0000\u0393\u0394\u0005e\u0000\u0000" + + "\u0394\u0395\u0005@\u0000\u0000\u0395\u0396\u0001\u0000\u0000\u0000\u0396" + + "\u0397\u0003\u0125\u0090\u0000\u0397p\u0001\u0000\u0000\u0000\u0398\u0399" + + "\u0005b\u0000\u0000\u0399\u039a\u0005r\u0000\u0000\u039a\u039b\u0005e" + + "\u0000\u0000\u039b\u039c\u0005a\u0000\u0000\u039c\u039d\u0005k\u0000\u0000" + + "\u039d\u039e\u0005@\u0000\u0000\u039e\u039f\u0001\u0000\u0000\u0000\u039f" + + "\u03a0\u0003\u0125\u0090\u0000\u03a0r\u0001\u0000\u0000\u0000\u03a1\u03a2" + + "\u0005@\u0000\u0000\u03a2\u03a3\u0005f\u0000\u0000\u03a3\u03a4\u0005i" + + "\u0000\u0000\u03a4\u03a5\u0005l\u0000\u0000\u03a5\u03a6\u0005e\u0000\u0000" + + "\u03a6t\u0001\u0000\u0000\u0000\u03a7\u03a8\u0005p\u0000\u0000\u03a8\u03a9" + + "\u0005a\u0000\u0000\u03a9\u03aa\u0005c\u0000\u0000\u03aa\u03ab\u0005k" + + "\u0000\u0000\u03ab\u03ac\u0005a\u0000\u0000\u03ac\u03ad\u0005g\u0000\u0000" + + "\u03ad\u03ae\u0005e\u0000\u0000\u03aev\u0001\u0000\u0000\u0000\u03af\u03b0" + + "\u0005i\u0000\u0000\u03b0\u03b1\u0005m\u0000\u0000\u03b1\u03b2\u0005p" + + "\u0000\u0000\u03b2\u03b3\u0005o\u0000\u0000\u03b3\u03b4\u0005r\u0000\u0000" + + "\u03b4\u03b5\u0005t\u0000\u0000\u03b5x\u0001\u0000\u0000\u0000\u03b6\u03b7" + + "\u0005c\u0000\u0000\u03b7\u03b8\u0005l\u0000\u0000\u03b8\u03b9\u0005a" + + "\u0000\u0000\u03b9\u03ba\u0005s\u0000\u0000\u03ba\u03bb\u0005s\u0000\u0000" + + "\u03bbz\u0001\u0000\u0000\u0000\u03bc\u03bd\u0005i\u0000\u0000\u03bd\u03be" + + "\u0005n\u0000\u0000\u03be\u03bf\u0005t\u0000\u0000\u03bf\u03c0\u0005e" + + "\u0000\u0000\u03c0\u03c1\u0005r\u0000\u0000\u03c1\u03c2\u0005f\u0000\u0000" + + "\u03c2\u03c3\u0005a\u0000\u0000\u03c3\u03c4\u0005c\u0000\u0000\u03c4\u03c5" + + "\u0005e\u0000\u0000\u03c5|\u0001\u0000\u0000\u0000\u03c6\u03c7\u0005f" + + "\u0000\u0000\u03c7\u03c8\u0005u\u0000\u0000\u03c8\u03c9\u0005n\u0000\u0000" + + "\u03c9~\u0001\u0000\u0000\u0000\u03ca\u03cb\u0005o\u0000\u0000\u03cb\u03cc" + + "\u0005b\u0000\u0000\u03cc\u03cd\u0005j\u0000\u0000\u03cd\u03ce\u0005e" + + "\u0000\u0000\u03ce\u03cf\u0005c\u0000\u0000\u03cf\u03d0\u0005t\u0000\u0000" + + "\u03d0\u0080\u0001\u0000\u0000\u0000\u03d1\u03d2\u0005v\u0000\u0000\u03d2" + + "\u03d3\u0005a\u0000\u0000\u03d3\u03d4\u0005l\u0000\u0000\u03d4\u0082\u0001" + + "\u0000\u0000\u0000\u03d5\u03d6\u0005v\u0000\u0000\u03d6\u03d7\u0005a\u0000" + + "\u0000\u03d7\u03d8\u0005r\u0000\u0000\u03d8\u0084\u0001\u0000\u0000\u0000" + + "\u03d9\u03da\u0005t\u0000\u0000\u03da\u03db\u0005y\u0000\u0000\u03db\u03dc" + + "\u0005p\u0000\u0000\u03dc\u03dd\u0005e\u0000\u0000\u03dd\u03de\u0005a" + + "\u0000\u0000\u03de\u03df\u0005l\u0000\u0000\u03df\u03e0\u0005i\u0000\u0000" + + "\u03e0\u03e1\u0005a\u0000\u0000\u03e1\u03e2\u0005s\u0000\u0000\u03e2\u0086" + + "\u0001\u0000\u0000\u0000\u03e3\u03e4\u0005c\u0000\u0000\u03e4\u03e5\u0005" + + "o\u0000\u0000\u03e5\u03e6\u0005n\u0000\u0000\u03e6\u03e7\u0005s\u0000" + + "\u0000\u03e7\u03e8\u0005t\u0000\u0000\u03e8\u03e9\u0005r\u0000\u0000\u03e9" + + "\u03ea\u0005u\u0000\u0000\u03ea\u03eb\u0005c\u0000\u0000\u03eb\u03ec\u0005" + + "t\u0000\u0000\u03ec\u03ed\u0005o\u0000\u0000\u03ed\u03ee\u0005r\u0000" + + "\u0000\u03ee\u0088\u0001\u0000\u0000\u0000\u03ef\u03f0\u0005b\u0000\u0000" + + "\u03f0\u03f1\u0005y\u0000\u0000\u03f1\u008a\u0001\u0000\u0000\u0000\u03f2" + + "\u03f3\u0005c\u0000\u0000\u03f3\u03f4\u0005o\u0000\u0000\u03f4\u03f5\u0005" + + "m\u0000\u0000\u03f5\u03f6\u0005p\u0000\u0000\u03f6\u03f7\u0005a\u0000" + + "\u0000\u03f7\u03f8\u0005n\u0000\u0000\u03f8\u03f9\u0005i\u0000\u0000\u03f9" + + "\u03fa\u0005o\u0000\u0000\u03fa\u03fb\u0005n\u0000\u0000\u03fb\u008c\u0001" + + "\u0000\u0000\u0000\u03fc\u03fd\u0005i\u0000\u0000\u03fd\u03fe\u0005n\u0000" + + "\u0000\u03fe\u03ff\u0005i\u0000\u0000\u03ff\u0400\u0005t\u0000\u0000\u0400" + + "\u008e\u0001\u0000\u0000\u0000\u0401\u0402\u0005t\u0000\u0000\u0402\u0403" + + "\u0005h\u0000\u0000\u0403\u0404\u0005i\u0000\u0000\u0404\u0405\u0005s" + + "\u0000\u0000\u0405\u0090\u0001\u0000\u0000\u0000\u0406\u0407\u0005s\u0000" + + "\u0000\u0407\u0408\u0005u\u0000\u0000\u0408\u0409\u0005p\u0000\u0000\u0409" + + "\u040a\u0005e\u0000\u0000\u040a\u040b\u0005r\u0000\u0000\u040b\u0092\u0001" + + "\u0000\u0000\u0000\u040c\u040d\u0005t\u0000\u0000\u040d\u040e\u0005y\u0000" + + "\u0000\u040e\u040f\u0005p\u0000\u0000\u040f\u0410\u0005e\u0000\u0000\u0410" + + "\u0411\u0005o\u0000\u0000\u0411\u0412\u0005f\u0000\u0000\u0412\u0094\u0001" + + "\u0000\u0000\u0000\u0413\u0414\u0005w\u0000\u0000\u0414\u0415\u0005h\u0000" + + "\u0000\u0415\u0416\u0005e\u0000\u0000\u0416\u0417\u0005r\u0000\u0000\u0417" + + "\u0418\u0005e\u0000\u0000\u0418\u0096\u0001\u0000\u0000\u0000\u0419\u041a" + + "\u0005i\u0000\u0000\u041a\u041b\u0005f\u0000\u0000\u041b\u0098\u0001\u0000" + + "\u0000\u0000\u041c\u041d\u0005e\u0000\u0000\u041d\u041e\u0005l\u0000\u0000" + + "\u041e\u041f\u0005s\u0000\u0000\u041f\u0420\u0005e\u0000\u0000\u0420\u009a" + + "\u0001\u0000\u0000\u0000\u0421\u0422\u0005w\u0000\u0000\u0422\u0423\u0005" + + "h\u0000\u0000\u0423\u0424\u0005e\u0000\u0000\u0424\u0425\u0005n\u0000" + + "\u0000\u0425\u009c\u0001\u0000\u0000\u0000\u0426\u0427\u0005t\u0000\u0000" + + "\u0427\u0428\u0005r\u0000\u0000\u0428\u0429\u0005y\u0000\u0000\u0429\u009e" + + "\u0001\u0000\u0000\u0000\u042a\u042b\u0005c\u0000\u0000\u042b\u042c\u0005" + + "a\u0000\u0000\u042c\u042d\u0005t\u0000\u0000\u042d\u042e\u0005c\u0000" + + "\u0000\u042e\u042f\u0005h\u0000\u0000\u042f\u00a0\u0001\u0000\u0000\u0000" + + "\u0430\u0431\u0005f\u0000\u0000\u0431\u0432\u0005i\u0000\u0000\u0432\u0433" + + "\u0005n\u0000\u0000\u0433\u0434\u0005a\u0000\u0000\u0434\u0435\u0005l" + + "\u0000\u0000\u0435\u0436\u0005l\u0000\u0000\u0436\u0437\u0005y\u0000\u0000" + + "\u0437\u00a2\u0001\u0000\u0000\u0000\u0438\u0439\u0005f\u0000\u0000\u0439" + + "\u043a\u0005o\u0000\u0000\u043a\u043b\u0005r\u0000\u0000\u043b\u00a4\u0001" + + "\u0000\u0000\u0000\u043c\u043d\u0005d\u0000\u0000\u043d\u043e\u0005o\u0000" + + "\u0000\u043e\u00a6\u0001\u0000\u0000\u0000\u043f\u0440\u0005w\u0000\u0000" + + "\u0440\u0441\u0005h\u0000\u0000\u0441\u0442\u0005i\u0000\u0000\u0442\u0443" + + "\u0005l\u0000\u0000\u0443\u0444\u0005e\u0000\u0000\u0444\u00a8\u0001\u0000" + + "\u0000\u0000\u0445\u0446\u0005t\u0000\u0000\u0446\u0447\u0005h\u0000\u0000" + + "\u0447\u0448\u0005r\u0000\u0000\u0448\u0449\u0005o\u0000\u0000\u0449\u044a" + + "\u0005w\u0000\u0000\u044a\u00aa\u0001\u0000\u0000\u0000\u044b\u044c\u0005" + + "r\u0000\u0000\u044c\u044d\u0005e\u0000\u0000\u044d\u044e\u0005t\u0000" + + "\u0000\u044e\u044f\u0005u\u0000\u0000\u044f\u0450\u0005r\u0000\u0000\u0450" + + "\u0451\u0005n\u0000\u0000\u0451\u00ac\u0001\u0000\u0000\u0000\u0452\u0453" + + "\u0005c\u0000\u0000\u0453\u0454\u0005o\u0000\u0000\u0454\u0455\u0005n" + + "\u0000\u0000\u0455\u0456\u0005t\u0000\u0000\u0456\u0457\u0005i\u0000\u0000" + + "\u0457\u0458\u0005n\u0000\u0000\u0458\u0459\u0005u\u0000\u0000\u0459\u045a" + + "\u0005e\u0000\u0000\u045a\u00ae\u0001\u0000\u0000\u0000\u045b\u045c\u0005" + + "b\u0000\u0000\u045c\u045d\u0005r\u0000\u0000\u045d\u045e\u0005e\u0000" + + "\u0000\u045e\u045f\u0005a\u0000\u0000\u045f\u0460\u0005k\u0000\u0000\u0460" + + "\u00b0\u0001\u0000\u0000\u0000\u0461\u0462\u0005a\u0000\u0000\u0462\u0463" + + "\u0005s\u0000\u0000\u0463\u00b2\u0001\u0000\u0000\u0000\u0464\u0465\u0005" + + "i\u0000\u0000\u0465\u0466\u0005s\u0000\u0000\u0466\u00b4\u0001\u0000\u0000" + + "\u0000\u0467\u0468\u0005i\u0000\u0000\u0468\u0469\u0005n\u0000\u0000\u0469" + + "\u00b6\u0001\u0000\u0000\u0000\u046a\u046b\u0005!\u0000\u0000\u046b\u046c" + + "\u0005i\u0000\u0000\u046c\u046d\u0005s\u0000\u0000\u046d\u0470\u0001\u0000" + + "\u0000\u0000\u046e\u0471\u0003\u000b\u0003\u0000\u046f\u0471\u0003\r\u0004" + + "\u0000\u0470\u046e\u0001\u0000\u0000\u0000\u0470\u046f\u0001\u0000\u0000" + + "\u0000\u0471\u0472\u0001\u0000\u0000\u0000\u0472\u0470\u0001\u0000\u0000" + + "\u0000\u0472\u0473\u0001\u0000\u0000\u0000\u0473\u00b8\u0001\u0000\u0000" + + "\u0000\u0474\u0475\u0005!\u0000\u0000\u0475\u0476\u0005i\u0000\u0000\u0476" + + "\u0477\u0005n\u0000\u0000\u0477\u047a\u0001\u0000\u0000\u0000\u0478\u047b" + + "\u0003\u000b\u0003\u0000\u0479\u047b\u0003\r\u0004\u0000\u047a\u0478\u0001" + + "\u0000\u0000\u0000\u047a\u0479\u0001\u0000\u0000\u0000\u047b\u047c\u0001" + + "\u0000\u0000\u0000\u047c\u047a\u0001\u0000\u0000\u0000\u047c\u047d\u0001" + + "\u0000\u0000\u0000\u047d\u00ba\u0001\u0000\u0000\u0000\u047e\u047f\u0005" + + "o\u0000\u0000\u047f\u0480\u0005u\u0000\u0000\u0480\u0481\u0005t\u0000" + + "\u0000\u0481\u00bc\u0001\u0000\u0000\u0000\u0482\u0483\u0005@\u0000\u0000" + + "\u0483\u0484\u0005f\u0000\u0000\u0484\u0485\u0005i\u0000\u0000\u0485\u0486" + + "\u0005e\u0000\u0000\u0486\u0487\u0005l\u0000\u0000\u0487\u0488\u0005d" + + "\u0000\u0000\u0488\u00be\u0001\u0000\u0000\u0000\u0489\u048a\u0005@\u0000" + + "\u0000\u048a\u048b\u0005p\u0000\u0000\u048b\u048c\u0005r\u0000\u0000\u048c" + + "\u048d\u0005o\u0000\u0000\u048d\u048e\u0005p\u0000\u0000\u048e\u048f\u0005" + + "e\u0000\u0000\u048f\u0490\u0005r\u0000\u0000\u0490\u0491\u0005t\u0000" + + "\u0000\u0491\u0492\u0005y\u0000\u0000\u0492\u00c0\u0001\u0000\u0000\u0000" + + "\u0493\u0494\u0005@\u0000\u0000\u0494\u0495\u0005g\u0000\u0000\u0495\u0496" + + "\u0005e\u0000\u0000\u0496\u0497\u0005t\u0000\u0000\u0497\u00c2\u0001\u0000" + + "\u0000\u0000\u0498\u0499\u0005@\u0000\u0000\u0499\u049a\u0005s\u0000\u0000" + + "\u049a\u049b\u0005e\u0000\u0000\u049b\u049c\u0005t\u0000\u0000\u049c\u00c4" + + "\u0001\u0000\u0000\u0000\u049d\u049e\u0005g\u0000\u0000\u049e\u049f\u0005" + + "e\u0000\u0000\u049f\u04a0\u0005t\u0000\u0000\u04a0\u00c6\u0001\u0000\u0000" + + "\u0000\u04a1\u04a2\u0005s\u0000\u0000\u04a2\u04a3\u0005e\u0000\u0000\u04a3" + + "\u04a4\u0005t\u0000\u0000\u04a4\u00c8\u0001\u0000\u0000\u0000\u04a5\u04a6" + + "\u0005@\u0000\u0000\u04a6\u04a7\u0005r\u0000\u0000\u04a7\u04a8\u0005e" + + "\u0000\u0000\u04a8\u04a9\u0005c\u0000\u0000\u04a9\u04aa\u0005e\u0000\u0000" + + "\u04aa\u04ab\u0005i\u0000\u0000\u04ab\u04ac\u0005v\u0000\u0000\u04ac\u04ad" + + "\u0005e\u0000\u0000\u04ad\u04ae\u0005r\u0000\u0000\u04ae\u00ca\u0001\u0000" + + "\u0000\u0000\u04af\u04b0\u0005@\u0000\u0000\u04b0\u04b1\u0005p\u0000\u0000" + + "\u04b1\u04b2\u0005a\u0000\u0000\u04b2\u04b3\u0005r\u0000\u0000\u04b3\u04b4" + + "\u0005a\u0000\u0000\u04b4\u04b5\u0005m\u0000\u0000\u04b5\u00cc\u0001\u0000" + + "\u0000\u0000\u04b6\u04b7\u0005@\u0000\u0000\u04b7\u04b8\u0005s\u0000\u0000" + + "\u04b8\u04b9\u0005e\u0000\u0000\u04b9\u04ba\u0005t\u0000\u0000\u04ba\u04bb" + + "\u0005p\u0000\u0000\u04bb\u04bc\u0005a\u0000\u0000\u04bc\u04bd\u0005r" + + "\u0000\u0000\u04bd\u04be\u0005a\u0000\u0000\u04be\u04bf\u0005m\u0000\u0000" + + "\u04bf\u00ce\u0001\u0000\u0000\u0000\u04c0\u04c1\u0005@\u0000\u0000\u04c1" + + "\u04c2\u0005d\u0000\u0000\u04c2\u04c3\u0005e\u0000\u0000\u04c3\u04c4\u0005" + + "l\u0000\u0000\u04c4\u04c5\u0005e\u0000\u0000\u04c5\u04c6\u0005g\u0000" + + "\u0000\u04c6\u04c7\u0005a\u0000\u0000\u04c7\u04c8\u0005t\u0000\u0000\u04c8" + + "\u04c9\u0005e\u0000\u0000\u04c9\u00d0\u0001\u0000\u0000\u0000\u04ca\u04cb" + + "\u0005d\u0000\u0000\u04cb\u04cc\u0005y\u0000\u0000\u04cc\u04cd\u0005n" + + "\u0000\u0000\u04cd\u04ce\u0005a\u0000\u0000\u04ce\u04cf\u0005m\u0000\u0000" + + "\u04cf\u04d0\u0005i\u0000\u0000\u04d0\u04d1\u0005c\u0000\u0000\u04d1\u00d2" + + "\u0001\u0000\u0000\u0000\u04d2\u04d3\u0005p\u0000\u0000\u04d3\u04d4\u0005" + + "u\u0000\u0000\u04d4\u04d5\u0005b\u0000\u0000\u04d5\u04d6\u0005l\u0000" + + "\u0000\u04d6\u04d7\u0005i\u0000\u0000\u04d7\u04d8\u0005c\u0000\u0000\u04d8" + + "\u00d4\u0001\u0000\u0000\u0000\u04d9\u04da\u0005p\u0000\u0000\u04da\u04db" + + "\u0005r\u0000\u0000\u04db\u04dc\u0005i\u0000\u0000\u04dc\u04dd\u0005v" + + "\u0000\u0000\u04dd\u04de\u0005a\u0000\u0000\u04de\u04df\u0005t\u0000\u0000" + + "\u04df\u04e0\u0005e\u0000\u0000\u04e0\u00d6\u0001\u0000\u0000\u0000\u04e1" + + "\u04e2\u0005p\u0000\u0000\u04e2\u04e3\u0005r\u0000\u0000\u04e3\u04e4\u0005" + + "o\u0000\u0000\u04e4\u04e5\u0005t\u0000\u0000\u04e5\u04e6\u0005e\u0000" + + "\u0000\u04e6\u04e7\u0005c\u0000\u0000\u04e7\u04e8\u0005t\u0000\u0000\u04e8" + + "\u04e9\u0005e\u0000\u0000\u04e9\u04ea\u0005d\u0000\u0000\u04ea\u00d8\u0001" + + "\u0000\u0000\u0000\u04eb\u04ec\u0005i\u0000\u0000\u04ec\u04ed\u0005n\u0000" + + "\u0000\u04ed\u04ee\u0005t\u0000\u0000\u04ee\u04ef\u0005e\u0000\u0000\u04ef" + + "\u04f0\u0005r\u0000\u0000\u04f0\u04f1\u0005n\u0000\u0000\u04f1\u04f2\u0005" + + "a\u0000\u0000\u04f2\u04f3\u0005l\u0000\u0000\u04f3\u00da\u0001\u0000\u0000" + + "\u0000\u04f4\u04f5\u0005e\u0000\u0000\u04f5\u04f6\u0005n\u0000\u0000\u04f6" + + "\u04f7\u0005u\u0000\u0000\u04f7\u04f8\u0005m\u0000\u0000\u04f8\u00dc\u0001" + + "\u0000\u0000\u0000\u04f9\u04fa\u0005s\u0000\u0000\u04fa\u04fb\u0005e\u0000" + + "\u0000\u04fb\u04fc\u0005a\u0000\u0000\u04fc\u04fd\u0005l\u0000\u0000\u04fd" + + "\u04fe\u0005e\u0000\u0000\u04fe\u04ff\u0005d\u0000\u0000\u04ff\u00de\u0001" + + "\u0000\u0000\u0000\u0500\u0501\u0005a\u0000\u0000\u0501\u0502\u0005n\u0000" + + "\u0000\u0502\u0503\u0005n\u0000\u0000\u0503\u0504\u0005o\u0000\u0000\u0504" + + "\u0505\u0005t\u0000\u0000\u0505\u0506\u0005a\u0000\u0000\u0506\u0507\u0005" + + "t\u0000\u0000\u0507\u0508\u0005i\u0000\u0000\u0508\u0509\u0005o\u0000" + + "\u0000\u0509\u050a\u0005n\u0000\u0000\u050a\u00e0\u0001\u0000\u0000\u0000" + + "\u050b\u050c\u0005d\u0000\u0000\u050c\u050d\u0005a\u0000\u0000\u050d\u050e" + + "\u0005t\u0000\u0000\u050e\u050f\u0005a\u0000\u0000\u050f\u00e2\u0001\u0000" + + "\u0000\u0000\u0510\u0511\u0005i\u0000\u0000\u0511\u0512\u0005n\u0000\u0000" + + "\u0512\u0513\u0005n\u0000\u0000\u0513\u0514\u0005e\u0000\u0000\u0514\u0515" + + "\u0005r\u0000\u0000\u0515\u00e4\u0001\u0000\u0000\u0000\u0516\u0517\u0005" + + "t\u0000\u0000\u0517\u0518\u0005a\u0000\u0000\u0518\u0519\u0005i\u0000" + + "\u0000\u0519\u051a\u0005l\u0000\u0000\u051a\u051b\u0005r\u0000\u0000\u051b" + + "\u051c\u0005e\u0000\u0000\u051c\u051d\u0005c\u0000\u0000\u051d\u00e6\u0001" + + "\u0000\u0000\u0000\u051e\u051f\u0005o\u0000\u0000\u051f\u0520\u0005p\u0000" + + "\u0000\u0520\u0521\u0005e\u0000\u0000\u0521\u0522\u0005r\u0000\u0000\u0522" + + "\u0523\u0005a\u0000\u0000\u0523\u0524\u0005t\u0000\u0000\u0524\u0525\u0005" + + "o\u0000\u0000\u0525\u0526\u0005r\u0000\u0000\u0526\u00e8\u0001\u0000\u0000" + + "\u0000\u0527\u0528\u0005i\u0000\u0000\u0528\u0529\u0005n\u0000\u0000\u0529" + + "\u052a\u0005l\u0000\u0000\u052a\u052b\u0005i\u0000\u0000\u052b\u052c\u0005" + + "n\u0000\u0000\u052c\u052d\u0005e\u0000\u0000\u052d\u00ea\u0001\u0000\u0000" + + "\u0000\u052e\u052f\u0005i\u0000\u0000\u052f\u0530\u0005n\u0000\u0000\u0530" + + "\u0531\u0005f\u0000\u0000\u0531\u0532\u0005i\u0000\u0000\u0532\u0533\u0005" + + "x\u0000\u0000\u0533\u00ec\u0001\u0000\u0000\u0000\u0534\u0535\u0005e\u0000" + + "\u0000\u0535\u0536\u0005x\u0000\u0000\u0536\u0537\u0005t\u0000\u0000\u0537" + + "\u0538\u0005e\u0000\u0000\u0538\u0539\u0005r\u0000\u0000\u0539\u053a\u0005" + + "n\u0000\u0000\u053a\u053b\u0005a\u0000\u0000\u053b\u053c\u0005l\u0000" + + "\u0000\u053c\u00ee\u0001\u0000\u0000\u0000\u053d\u053e\u0005s\u0000\u0000" + + "\u053e\u053f\u0005u\u0000\u0000\u053f\u0540\u0005s\u0000\u0000\u0540\u0541" + + "\u0005p\u0000\u0000\u0541\u0542\u0005e\u0000\u0000\u0542\u0543\u0005n" + + "\u0000\u0000\u0543\u0544\u0005d\u0000\u0000\u0544\u00f0\u0001\u0000\u0000" + + "\u0000\u0545\u0546\u0005o\u0000\u0000\u0546\u0547\u0005v\u0000\u0000\u0547" + + "\u0548\u0005e\u0000\u0000\u0548\u0549\u0005r\u0000\u0000\u0549\u054a\u0005" + + "r\u0000\u0000\u054a\u054b\u0005i\u0000\u0000\u054b\u054c\u0005d\u0000" + + "\u0000\u054c\u054d\u0005e\u0000\u0000\u054d\u00f2\u0001\u0000\u0000\u0000" + + "\u054e\u054f\u0005a\u0000\u0000\u054f\u0550\u0005b\u0000\u0000\u0550\u0551" + + "\u0005s\u0000\u0000\u0551\u0552\u0005t\u0000\u0000\u0552\u0553\u0005r" + + "\u0000\u0000\u0553\u0554\u0005a\u0000\u0000\u0554\u0555\u0005c\u0000\u0000" + + "\u0555\u0556\u0005t\u0000\u0000\u0556\u00f4\u0001\u0000\u0000\u0000\u0557" + + "\u0558\u0005f\u0000\u0000\u0558\u0559\u0005i\u0000\u0000\u0559\u055a\u0005" + + "n\u0000\u0000\u055a\u055b\u0005a\u0000\u0000\u055b\u055c\u0005l\u0000" + + "\u0000\u055c\u00f6\u0001\u0000\u0000\u0000\u055d\u055e\u0005o\u0000\u0000" + + "\u055e\u055f\u0005p\u0000\u0000\u055f\u0560\u0005e\u0000\u0000\u0560\u0561" + + "\u0005n\u0000\u0000\u0561\u00f8\u0001\u0000\u0000\u0000\u0562\u0563\u0005" + + "c\u0000\u0000\u0563\u0564\u0005o\u0000\u0000\u0564\u0565\u0005n\u0000" + + "\u0000\u0565\u0566\u0005s\u0000\u0000\u0566\u0567\u0005t\u0000\u0000\u0567" + + "\u00fa\u0001\u0000\u0000\u0000\u0568\u0569\u0005l\u0000\u0000\u0569\u056a" + + "\u0005a\u0000\u0000\u056a\u056b\u0005t\u0000\u0000\u056b\u056c\u0005e" + + "\u0000\u0000\u056c\u056d\u0005i\u0000\u0000\u056d\u056e\u0005n\u0000\u0000" + + "\u056e\u056f\u0005i\u0000\u0000\u056f\u0570\u0005t\u0000\u0000\u0570\u00fc" + + "\u0001\u0000\u0000\u0000\u0571\u0572\u0005v\u0000\u0000\u0572\u0573\u0005" + + "a\u0000\u0000\u0573\u0574\u0005r\u0000\u0000\u0574\u0575\u0005a\u0000" + + "\u0000\u0575\u0576\u0005r\u0000\u0000\u0576\u0577\u0005g\u0000\u0000\u0577" + + "\u00fe\u0001\u0000\u0000\u0000\u0578\u0579\u0005n\u0000\u0000\u0579\u057a" + + "\u0005o\u0000\u0000\u057a\u057b\u0005i\u0000\u0000\u057b\u057c\u0005n" + + "\u0000\u0000\u057c\u057d\u0005l\u0000\u0000\u057d\u057e\u0005i\u0000\u0000" + + "\u057e\u057f\u0005n\u0000\u0000\u057f\u0580\u0005e\u0000\u0000\u0580\u0100" + + "\u0001\u0000\u0000\u0000\u0581\u0582\u0005c\u0000\u0000\u0582\u0583\u0005" + + "r\u0000\u0000\u0583\u0584\u0005o\u0000\u0000\u0584\u0585\u0005s\u0000" + + "\u0000\u0585\u0586\u0005s\u0000\u0000\u0586\u0587\u0005i\u0000\u0000\u0587" + + "\u0588\u0005n\u0000\u0000\u0588\u0589\u0005l\u0000\u0000\u0589\u058a\u0005" + + "i\u0000\u0000\u058a\u058b\u0005n\u0000\u0000\u058b\u058c\u0005e\u0000" + + "\u0000\u058c\u0102\u0001\u0000\u0000\u0000\u058d\u058e\u0005r\u0000\u0000" + + "\u058e\u058f\u0005e\u0000\u0000\u058f\u0590\u0005i\u0000\u0000\u0590\u0591" + + "\u0005f\u0000\u0000\u0591\u0592\u0005i\u0000\u0000\u0592\u0593\u0005e" + + "\u0000\u0000\u0593\u0594\u0005d\u0000\u0000\u0594\u0104\u0001\u0000\u0000" + + "\u0000\u0595\u0596\u0005\"\u0000\u0000\u0596\u0597\u0001\u0000\u0000\u0000" + + "\u0597\u0598\u0006\u0080\u0003\u0000\u0598\u0106\u0001\u0000\u0000\u0000" + + "\u0599\u059a\u0005\"\u0000\u0000\u059a\u059b\u0005\"\u0000\u0000\u059b" + + "\u059c\u0005\"\u0000\u0000\u059c\u059d\u0001\u0000\u0000\u0000\u059d\u059e" + + "\u0006\u0081\u0004\u0000\u059e\u0108\u0001\u0000\u0000\u0000\u059f\u05a2" + + "\u0003\u010b\u0083\u0000\u05a0\u05a2\u0003\u010d\u0084\u0000\u05a1\u059f" + + "\u0001\u0000\u0000\u0000\u05a1\u05a0\u0001\u0000\u0000\u0000\u05a2\u010a" + + "\u0001\u0000\u0000\u0000\u05a3\u05a6\u0003\u010d\u0084\u0000\u05a4\u05a6" + + "\u0003\u0111\u0086\u0000\u05a5\u05a3\u0001\u0000\u0000\u0000\u05a5\u05a4" + + "\u0001\u0000\u0000\u0000\u05a6\u05a7\u0001\u0000\u0000\u0000\u05a7\u05a8" + + "\u0007\u0002\u0000\u0000\u05a8\u010c\u0001\u0000\u0000\u0000\u05a9\u05ad" + + "\u0003\u0115\u0088\u0000\u05aa\u05ac\u0003\u0113\u0087\u0000\u05ab\u05aa" + + "\u0001\u0000\u0000\u0000\u05ac\u05af\u0001\u0000\u0000\u0000\u05ad\u05ab" + + "\u0001\u0000\u0000\u0000\u05ad\u05ae\u0001\u0000\u0000\u0000\u05ae\u05b2" + + "\u0001\u0000\u0000\u0000\u05af\u05ad\u0001\u0000\u0000\u0000\u05b0\u05b2" + + "\u00050\u0000\u0000\u05b1\u05a9\u0001\u0000\u0000\u0000\u05b1\u05b0\u0001" + + "\u0000\u0000\u0000\u05b1\u05b2\u0001\u0000\u0000\u0000\u05b2\u05b3\u0001" + + "\u0000\u0000\u0000\u05b3\u05c2\u0005.\u0000\u0000\u05b4\u05b9\u0003\u0115" + + "\u0088\u0000\u05b5\u05b8\u0003\u0113\u0087\u0000\u05b6\u05b8\u0005_\u0000" + + "\u0000\u05b7\u05b5\u0001\u0000\u0000\u0000\u05b7\u05b6\u0001\u0000\u0000" + + "\u0000\u05b8\u05bb\u0001\u0000\u0000\u0000\u05b9\u05b7\u0001\u0000\u0000" + + "\u0000\u05b9\u05ba\u0001\u0000\u0000\u0000\u05ba\u05bc\u0001\u0000\u0000" + + "\u0000\u05bb\u05b9\u0001\u0000\u0000\u0000\u05bc\u05bd\u0003\u0113\u0087" + + "\u0000\u05bd\u05bf\u0001\u0000\u0000\u0000\u05be\u05b4\u0001\u0000\u0000" + + "\u0000\u05be\u05bf\u0001\u0000\u0000\u0000\u05bf\u05c0\u0001\u0000\u0000" + + "\u0000\u05c0\u05c2\u0005.\u0000\u0000\u05c1\u05b1\u0001\u0000\u0000\u0000" + + "\u05c1\u05be\u0001\u0000\u0000\u0000\u05c2\u0617\u0001\u0000\u0000\u0000" + + "\u05c3\u05c5\u0003\u0113\u0087\u0000\u05c4\u05c3\u0001\u0000\u0000\u0000" + + "\u05c5\u05c6\u0001\u0000\u0000\u0000\u05c6\u05c4\u0001\u0000\u0000\u0000" + + "\u05c6\u05c7\u0001\u0000\u0000\u0000\u05c7\u0618\u0001\u0000\u0000\u0000" + + "\u05c8\u05cb\u0003\u0113\u0087\u0000\u05c9\u05cc\u0003\u0113\u0087\u0000" + + "\u05ca\u05cc\u0005_\u0000\u0000\u05cb\u05c9\u0001\u0000\u0000\u0000\u05cb" + + "\u05ca\u0001\u0000\u0000\u0000\u05cc\u05cd\u0001\u0000\u0000\u0000\u05cd" + + "\u05cb\u0001\u0000\u0000\u0000\u05cd\u05ce\u0001\u0000\u0000\u0000\u05ce" + + "\u05cf\u0001\u0000\u0000\u0000\u05cf\u05d0\u0003\u0113\u0087\u0000\u05d0" + + "\u0618\u0001\u0000\u0000\u0000\u05d1\u05d3\u0003\u0113\u0087\u0000\u05d2" + + "\u05d1\u0001\u0000\u0000\u0000\u05d3\u05d4\u0001\u0000\u0000\u0000\u05d4" + + "\u05d2\u0001\u0000\u0000\u0000\u05d4\u05d5\u0001\u0000\u0000\u0000\u05d5" + + "\u05d6\u0001\u0000\u0000\u0000\u05d6\u05d8\u0007\u0003\u0000\u0000\u05d7" + + "\u05d9\u0007\u0004\u0000\u0000\u05d8\u05d7\u0001\u0000\u0000\u0000\u05d8" + + "\u05d9\u0001\u0000\u0000\u0000\u05d9\u05db\u0001\u0000\u0000\u0000\u05da" + + "\u05dc\u0003\u0113\u0087\u0000\u05db\u05da\u0001\u0000\u0000\u0000\u05dc" + + "\u05dd\u0001\u0000\u0000\u0000\u05dd\u05db\u0001\u0000\u0000\u0000\u05dd" + + "\u05de\u0001\u0000\u0000\u0000\u05de\u0618\u0001\u0000\u0000\u0000\u05df" + + "\u05e1\u0003\u0113\u0087\u0000\u05e0\u05df\u0001\u0000\u0000\u0000\u05e1" + + "\u05e2\u0001\u0000\u0000\u0000\u05e2\u05e0\u0001\u0000\u0000\u0000\u05e2" + + "\u05e3\u0001\u0000\u0000\u0000\u05e3\u05e4\u0001\u0000\u0000\u0000\u05e4" + + "\u05e6\u0007\u0003\u0000\u0000\u05e5\u05e7\u0007\u0004\u0000\u0000\u05e6" + + "\u05e5\u0001\u0000\u0000\u0000\u05e6\u05e7\u0001\u0000\u0000\u0000\u05e7" + + "\u05e8\u0001\u0000\u0000\u0000\u05e8\u05eb\u0003\u0113\u0087\u0000\u05e9" + + "\u05ec\u0003\u0113\u0087\u0000\u05ea\u05ec\u0005_\u0000\u0000\u05eb\u05e9" + + "\u0001\u0000\u0000\u0000\u05eb\u05ea\u0001\u0000\u0000\u0000\u05ec\u05ed" + + "\u0001\u0000\u0000\u0000\u05ed\u05eb\u0001\u0000\u0000\u0000\u05ed\u05ee" + + "\u0001\u0000\u0000\u0000\u05ee\u05ef\u0001\u0000\u0000\u0000\u05ef\u05f0" + + "\u0003\u0113\u0087\u0000\u05f0\u0618\u0001\u0000\u0000\u0000\u05f1\u05f4" + + "\u0003\u0113\u0087\u0000\u05f2\u05f5\u0003\u0113\u0087\u0000\u05f3\u05f5" + + "\u0005_\u0000\u0000\u05f4\u05f2\u0001\u0000\u0000\u0000\u05f4\u05f3\u0001" + + "\u0000\u0000\u0000\u05f5\u05f6\u0001\u0000\u0000\u0000\u05f6\u05f4\u0001" + + "\u0000\u0000\u0000\u05f6\u05f7\u0001\u0000\u0000\u0000\u05f7\u05f8\u0001" + + "\u0000\u0000\u0000\u05f8\u05f9\u0003\u0113\u0087\u0000\u05f9\u05fb\u0007" + + "\u0003\u0000\u0000\u05fa\u05fc\u0007\u0004\u0000\u0000\u05fb\u05fa\u0001" + + "\u0000\u0000\u0000\u05fb\u05fc\u0001\u0000\u0000\u0000\u05fc\u05fe\u0001" + + "\u0000\u0000\u0000\u05fd\u05ff\u0003\u0113\u0087\u0000\u05fe\u05fd\u0001" + + "\u0000\u0000\u0000\u05ff\u0600\u0001\u0000\u0000\u0000\u0600\u05fe\u0001" + + "\u0000\u0000\u0000\u0600\u0601\u0001\u0000\u0000\u0000\u0601\u0618\u0001" + + "\u0000\u0000\u0000\u0602\u0605\u0003\u0113\u0087\u0000\u0603\u0606\u0003" + + "\u0113\u0087\u0000\u0604\u0606\u0005_\u0000\u0000\u0605\u0603\u0001\u0000" + + "\u0000\u0000\u0605\u0604\u0001\u0000\u0000\u0000\u0606\u0607\u0001\u0000" + + "\u0000\u0000\u0607\u0605\u0001\u0000\u0000\u0000\u0607\u0608\u0001\u0000" + + "\u0000\u0000\u0608\u0609\u0001\u0000\u0000\u0000\u0609\u060a\u0003\u0113" + + "\u0087\u0000\u060a\u060c\u0007\u0003\u0000\u0000\u060b\u060d\u0007\u0004" + + "\u0000\u0000\u060c\u060b\u0001\u0000\u0000\u0000\u060c\u060d\u0001\u0000" + + "\u0000\u0000\u060d\u060e\u0001\u0000\u0000\u0000\u060e\u0611\u0003\u0113" + + "\u0087\u0000\u060f\u0612\u0003\u0113\u0087\u0000\u0610\u0612\u0005_\u0000" + + "\u0000\u0611\u060f\u0001\u0000\u0000\u0000\u0611\u0610\u0001\u0000\u0000" + + "\u0000\u0612\u0613\u0001\u0000\u0000\u0000\u0613\u0611\u0001\u0000\u0000" + + "\u0000\u0613\u0614\u0001\u0000\u0000\u0000\u0614\u0615\u0001\u0000\u0000" + + "\u0000\u0615\u0616\u0003\u0113\u0087\u0000\u0616\u0618\u0001\u0000\u0000" + + "\u0000\u0617\u05c4\u0001\u0000\u0000\u0000\u0617\u05c8\u0001\u0000\u0000" + + "\u0000\u0617\u05d2\u0001\u0000\u0000\u0000\u0617\u05e0\u0001\u0000\u0000" + + "\u0000\u0617\u05f1\u0001\u0000\u0000\u0000\u0617\u0602\u0001\u0000\u0000" + + "\u0000\u0618\u010e\u0001\u0000\u0000\u0000\u0619\u061d\u0003\u0111\u0086" + + "\u0000\u061a\u061d\u0003\u0119\u008a\u0000\u061b\u061d\u0003\u011d\u008c" + + "\u0000\u061c\u0619\u0001\u0000\u0000\u0000\u061c\u061a\u0001\u0000\u0000" + + "\u0000\u061c\u061b\u0001\u0000\u0000\u0000\u061d\u061e\u0001\u0000\u0000" + + "\u0000\u061e\u061f\u0005L\u0000\u0000\u061f\u0110\u0001\u0000\u0000\u0000" + + "\u0620\u067c\u00050\u0000\u0000\u0621\u0625\u0003\u0115\u0088\u0000\u0622" + + "\u0624\u0003\u0113\u0087\u0000\u0623\u0622\u0001\u0000\u0000\u0000\u0624" + + "\u0627\u0001\u0000\u0000\u0000\u0625\u0623\u0001\u0000\u0000\u0000\u0625" + + "\u0626\u0001\u0000\u0000\u0000\u0626\u067c\u0001\u0000\u0000\u0000\u0627" + + "\u0625\u0001\u0000\u0000\u0000\u0628\u062b\u0003\u0115\u0088\u0000\u0629" + + "\u062c\u0003\u0113\u0087\u0000\u062a\u062c\u0005_\u0000\u0000\u062b\u0629" + + "\u0001\u0000\u0000\u0000\u062b\u062a\u0001\u0000\u0000\u0000\u062c\u062d" + + "\u0001\u0000\u0000\u0000\u062d\u062b\u0001\u0000\u0000\u0000\u062d\u062e" + + "\u0001\u0000\u0000\u0000\u062e\u062f\u0001\u0000\u0000\u0000\u062f\u0630" + + "\u0003\u0113\u0087\u0000\u0630\u067c\u0001\u0000\u0000\u0000\u0631\u0635" + + "\u0003\u0115\u0088\u0000\u0632\u0634\u0003\u0113\u0087\u0000\u0633\u0632" + + "\u0001\u0000\u0000\u0000\u0634\u0637\u0001\u0000\u0000\u0000\u0635\u0633" + + "\u0001\u0000\u0000\u0000\u0635\u0636\u0001\u0000\u0000\u0000\u0636\u0638" + + "\u0001\u0000\u0000\u0000\u0637\u0635\u0001\u0000\u0000\u0000\u0638\u063a" + + "\u0007\u0003\u0000\u0000\u0639\u063b\u0007\u0004\u0000\u0000\u063a\u0639" + + "\u0001\u0000\u0000\u0000\u063a\u063b\u0001\u0000\u0000\u0000\u063b\u063d" + + "\u0001\u0000\u0000\u0000\u063c\u063e\u0003\u0113\u0087\u0000\u063d\u063c" + + "\u0001\u0000\u0000\u0000\u063e\u063f\u0001\u0000\u0000\u0000\u063f\u063d" + + "\u0001\u0000\u0000\u0000\u063f\u0640\u0001\u0000\u0000\u0000\u0640\u067c" + + "\u0001\u0000\u0000\u0000\u0641\u0645\u0003\u0115\u0088\u0000\u0642\u0644" + + "\u0003\u0113\u0087\u0000\u0643\u0642\u0001\u0000\u0000\u0000\u0644\u0647" + + "\u0001\u0000\u0000\u0000\u0645\u0643\u0001\u0000\u0000\u0000\u0645\u0646" + + "\u0001\u0000\u0000\u0000\u0646\u0648\u0001\u0000\u0000\u0000\u0647\u0645" + + "\u0001\u0000\u0000\u0000\u0648\u064a\u0007\u0003\u0000\u0000\u0649\u064b" + + "\u0007\u0004\u0000\u0000\u064a\u0649\u0001\u0000\u0000\u0000\u064a\u064b" + + "\u0001\u0000\u0000\u0000\u064b\u064c\u0001\u0000\u0000\u0000\u064c\u064f" + + "\u0003\u0113\u0087\u0000\u064d\u0650\u0003\u0113\u0087\u0000\u064e\u0650" + + "\u0005_\u0000\u0000\u064f\u064d\u0001\u0000\u0000\u0000\u064f\u064e\u0001" + + "\u0000\u0000\u0000\u0650\u0651\u0001\u0000\u0000\u0000\u0651\u064f\u0001" + + "\u0000\u0000\u0000\u0651\u0652\u0001\u0000\u0000\u0000\u0652\u0653\u0001" + + "\u0000\u0000\u0000\u0653\u0654\u0003\u0113\u0087\u0000\u0654\u067c\u0001" + + "\u0000\u0000\u0000\u0655\u0658\u0003\u0115\u0088\u0000\u0656\u0659\u0003" + + "\u0113\u0087\u0000\u0657\u0659\u0005_\u0000\u0000\u0658\u0656\u0001\u0000" + + "\u0000\u0000\u0658\u0657\u0001\u0000\u0000\u0000\u0659\u065a\u0001\u0000" + + "\u0000\u0000\u065a\u0658\u0001\u0000\u0000\u0000\u065a\u065b\u0001\u0000" + + "\u0000\u0000\u065b\u065c\u0001\u0000\u0000\u0000\u065c\u065d\u0003\u0113" + + "\u0087\u0000\u065d\u065f\u0007\u0003\u0000\u0000\u065e\u0660\u0007\u0004" + + "\u0000\u0000\u065f\u065e\u0001\u0000\u0000\u0000\u065f\u0660\u0001\u0000" + + "\u0000\u0000\u0660\u0662\u0001\u0000\u0000\u0000\u0661\u0663\u0003\u0113" + + "\u0087\u0000\u0662\u0661\u0001\u0000\u0000\u0000\u0663\u0664\u0001\u0000" + + "\u0000\u0000\u0664\u0662\u0001\u0000\u0000\u0000\u0664\u0665\u0001\u0000" + + "\u0000\u0000\u0665\u067c\u0001\u0000\u0000\u0000\u0666\u0669\u0003\u0115" + + "\u0088\u0000\u0667\u066a\u0003\u0113\u0087\u0000\u0668\u066a\u0005_\u0000" + + "\u0000\u0669\u0667\u0001\u0000\u0000\u0000\u0669\u0668\u0001\u0000\u0000" + + "\u0000\u066a\u066b\u0001\u0000\u0000\u0000\u066b\u0669\u0001\u0000\u0000" + + "\u0000\u066b\u066c\u0001\u0000\u0000\u0000\u066c\u066d\u0001\u0000\u0000" + + "\u0000\u066d\u066e\u0003\u0113\u0087\u0000\u066e\u0670\u0007\u0003\u0000" + + "\u0000\u066f\u0671\u0007\u0004\u0000\u0000\u0670\u066f\u0001\u0000\u0000" + + "\u0000\u0670\u0671\u0001\u0000\u0000\u0000\u0671\u0672\u0001\u0000\u0000" + + "\u0000\u0672\u0675\u0003\u0113\u0087\u0000\u0673\u0676\u0003\u0113\u0087" + + "\u0000\u0674\u0676\u0005_\u0000\u0000\u0675\u0673\u0001\u0000\u0000\u0000" + + "\u0675\u0674\u0001\u0000\u0000\u0000\u0676\u0677\u0001\u0000\u0000\u0000" + + "\u0677\u0675\u0001\u0000\u0000\u0000\u0677\u0678\u0001\u0000\u0000\u0000" + + "\u0678\u0679\u0001\u0000\u0000\u0000\u0679\u067a\u0003\u0113\u0087\u0000" + + "\u067a\u067c\u0001\u0000\u0000\u0000\u067b\u0620\u0001\u0000\u0000\u0000" + + "\u067b\u0621\u0001\u0000\u0000\u0000\u067b\u0628\u0001\u0000\u0000\u0000" + + "\u067b\u0631\u0001\u0000\u0000\u0000\u067b\u0641\u0001\u0000\u0000\u0000" + + "\u067b\u0655\u0001\u0000\u0000\u0000\u067b\u0666\u0001\u0000\u0000\u0000" + + "\u067c\u0112\u0001\u0000\u0000\u0000\u067d\u067e\u0003\u0141\u009e\u0000" + + "\u067e\u0114\u0001\u0000\u0000\u0000\u067f\u0680\u0003\u0117\u0089\u0000" + + "\u0680\u0116\u0001\u0000\u0000\u0000\u0681\u0682\u0007\u0005\u0000\u0000" + + "\u0682\u0118\u0001\u0000\u0000\u0000\u0683\u0684\u00050\u0000\u0000\u0684" + + "\u0685\u0007\u0006\u0000\u0000\u0685\u068a\u0003\u011b\u008b\u0000\u0686" + + "\u0689\u0003\u011b\u008b\u0000\u0687\u0689\u0005_\u0000\u0000\u0688\u0686" + + "\u0001\u0000\u0000\u0000\u0688\u0687\u0001\u0000\u0000\u0000\u0689\u068c" + + "\u0001\u0000\u0000\u0000\u068a\u0688\u0001\u0000\u0000\u0000\u068a\u068b" + + "\u0001\u0000\u0000\u0000\u068b\u011a\u0001\u0000\u0000\u0000\u068c\u068a" + + "\u0001\u0000\u0000\u0000\u068d\u068e\u0007\u0007\u0000\u0000\u068e\u011c" + + "\u0001\u0000\u0000\u0000\u068f\u0690\u00050\u0000\u0000\u0690\u0691\u0007" + + "\b\u0000\u0000\u0691\u0696\u0003\u011f\u008d\u0000\u0692\u0695\u0003\u011f" + + "\u008d\u0000\u0693\u0695\u0005_\u0000\u0000\u0694\u0692\u0001\u0000\u0000" + + "\u0000\u0694\u0693\u0001\u0000\u0000\u0000\u0695\u0698\u0001\u0000\u0000" + + "\u0000\u0696\u0694\u0001\u0000\u0000\u0000\u0696\u0697\u0001\u0000\u0000" + + "\u0000\u0697\u011e\u0001\u0000\u0000\u0000\u0698\u0696\u0001\u0000\u0000" + + "\u0000\u0699\u069a\u0007\t\u0000\u0000\u069a\u0120\u0001\u0000\u0000\u0000" + + "\u069b\u069c\u0005t\u0000\u0000\u069c\u069d\u0005r\u0000\u0000\u069d\u069e" + + "\u0005u\u0000\u0000\u069e\u06a5\u0005e\u0000\u0000\u069f\u06a0\u0005f" + + "\u0000\u0000\u06a0\u06a1\u0005a\u0000\u0000\u06a1\u06a2\u0005l\u0000\u0000" + + "\u06a2\u06a3\u0005s\u0000\u0000\u06a3\u06a5\u0005e\u0000\u0000\u06a4\u069b" + + "\u0001\u0000\u0000\u0000\u06a4\u069f\u0001\u0000\u0000\u0000\u06a5\u0122" + + "\u0001\u0000\u0000\u0000\u06a6\u06a7\u0005n\u0000\u0000\u06a7\u06a8\u0005" + + "u\u0000\u0000\u06a8\u06a9\u0005l\u0000\u0000\u06a9\u06aa\u0005l\u0000" + + "\u0000\u06aa\u0124\u0001\u0000\u0000\u0000\u06ab\u06ae\u0003\u0135\u0098" + + "\u0000\u06ac\u06ae\u0005_\u0000\u0000\u06ad\u06ab\u0001\u0000\u0000\u0000" + + "\u06ad\u06ac\u0001\u0000\u0000\u0000\u06ae\u06b4\u0001\u0000\u0000\u0000" + + "\u06af\u06b3\u0003\u0135\u0098\u0000\u06b0\u06b3\u0005_\u0000\u0000\u06b1" + + "\u06b3\u0003\u0113\u0087\u0000\u06b2\u06af\u0001\u0000\u0000\u0000\u06b2" + + "\u06b0\u0001\u0000\u0000\u0000\u06b2\u06b1\u0001\u0000\u0000\u0000\u06b3" + + "\u06b6\u0001\u0000\u0000\u0000\u06b4\u06b2\u0001\u0000\u0000\u0000\u06b4" + + "\u06b5\u0001\u0000\u0000\u0000\u06b5\u06bf\u0001\u0000\u0000\u0000\u06b6" + + "\u06b4\u0001\u0000\u0000\u0000\u06b7\u06b9\u0005`\u0000\u0000\u06b8\u06ba" + + "\b\n\u0000\u0000\u06b9\u06b8\u0001\u0000\u0000\u0000\u06ba\u06bb\u0001" + + "\u0000\u0000\u0000\u06bb\u06b9\u0001\u0000\u0000\u0000\u06bb\u06bc\u0001" + + "\u0000\u0000\u0000\u06bc\u06bd\u0001\u0000\u0000\u0000\u06bd\u06bf\u0005" + + "`\u0000\u0000\u06be\u06ad\u0001\u0000\u0000\u0000\u06be\u06b7\u0001\u0000" + + "\u0000\u0000\u06bf\u0126\u0001\u0000\u0000\u0000\u06c0\u06c1\u0005@\u0000" + + "\u0000\u06c1\u06c2\u0003\u0125\u0090\u0000\u06c2\u0128\u0001\u0000\u0000" + + "\u0000\u06c3\u06c4\u0003\u0125\u0090\u0000\u06c4\u06c5\u0005@\u0000\u0000" + + "\u06c5\u012a\u0001\u0000\u0000\u0000\u06c6\u06c7\u0005$\u0000\u0000\u06c7" + + "\u06c8\u0003\u0125\u0090\u0000\u06c8\u012c\u0001\u0000\u0000\u0000\u06c9" + + "\u06cc\u0005\'\u0000\u0000\u06ca\u06cd\u0003\u012f\u0095\u0000\u06cb\u06cd" + + "\t\u0000\u0000\u0000\u06cc\u06ca\u0001\u0000\u0000\u0000\u06cc\u06cb\u0001" + + "\u0000\u0000\u0000\u06cd\u06ce\u0001\u0000\u0000\u0000\u06ce\u06cf\u0005" + + "\'\u0000\u0000\u06cf\u012e\u0001\u0000\u0000\u0000\u06d0\u06d3\u0003\u0131" + + "\u0096\u0000\u06d1\u06d3\u0003\u0133\u0097\u0000\u06d2\u06d0\u0001\u0000" + + "\u0000\u0000\u06d2\u06d1\u0001\u0000\u0000\u0000\u06d3\u0130\u0001\u0000" + + "\u0000\u0000\u06d4\u06d5\u0005\\\u0000\u0000\u06d5\u06d6\u0005u\u0000" + + "\u0000\u06d6\u06d7\u0003\u011b\u008b\u0000\u06d7\u06d8\u0003\u011b\u008b" + + "\u0000\u06d8\u06d9\u0003\u011b\u008b\u0000\u06d9\u06da\u0003\u011b\u008b" + + "\u0000\u06da\u0132\u0001\u0000\u0000\u0000\u06db\u06dc\u0005\\\u0000\u0000" + + "\u06dc\u06dd\u0007\u000b\u0000\u0000\u06dd\u0134\u0001\u0000\u0000\u0000" + + "\u06de\u06e5\u0003\u0137\u0099\u0000\u06df\u06e5\u0003\u0139\u009a\u0000" + + "\u06e0\u06e5\u0003\u013b\u009b\u0000\u06e1\u06e5\u0003\u013d\u009c\u0000" + + "\u06e2\u06e5\u0003\u013f\u009d\u0000\u06e3\u06e5\u0003\u0143\u009f\u0000" + + "\u06e4\u06de\u0001\u0000\u0000\u0000\u06e4\u06df\u0001\u0000\u0000\u0000" + + "\u06e4\u06e0\u0001\u0000\u0000\u0000\u06e4\u06e1\u0001\u0000\u0000\u0000" + + "\u06e4\u06e2\u0001\u0000\u0000\u0000\u06e4\u06e3\u0001\u0000\u0000\u0000" + + "\u06e5\u0136\u0001\u0000\u0000\u0000\u06e6\u06e7\u0007\f\u0000\u0000\u06e7" + + "\u0138\u0001\u0000\u0000\u0000\u06e8\u06e9\u0007\r\u0000\u0000\u06e9\u013a" + + "\u0001\u0000\u0000\u0000\u06ea\u06eb\u0007\u000e\u0000\u0000\u06eb\u013c" + + "\u0001\u0000\u0000\u0000\u06ec\u06ed\u0007\u000f\u0000\u0000\u06ed\u013e" + + "\u0001\u0000\u0000\u0000\u06ee\u06ef\u0007\u0010\u0000\u0000\u06ef\u0140" + + "\u0001\u0000\u0000\u0000\u06f0\u06f1\u0007\u0011\u0000\u0000\u06f1\u0142" + + "\u0001\u0000\u0000\u0000\u06f2\u06f3\u0007\u0012\u0000\u0000\u06f3\u0144" + + "\u0001\u0000\u0000\u0000\u06f4\u06f5\u0005)\u0000\u0000\u06f5\u06f6\u0001" + + "\u0000\u0000\u0000\u06f6\u06f7\u0006\u00a0\u0005\u0000\u06f7\u06f8\u0006" + + "\u00a0\u0006\u0000\u06f8\u0146\u0001\u0000\u0000\u0000\u06f9\u06fa\u0005" + + "]\u0000\u0000\u06fa\u06fb\u0001\u0000\u0000\u0000\u06fb\u06fc\u0006\u00a1" + + "\u0005\u0000\u06fc\u06fd\u0006\u00a1\u0007\u0000\u06fd\u0148\u0001\u0000" + + "\u0000\u0000\u06fe\u06ff\u0003\u0015\b\u0000\u06ff\u0700\u0001\u0000\u0000" + + "\u0000\u0700\u0701\u0006\u00a2\u0002\u0000\u0701\u0702\u0006\u00a2\b\u0000" + + "\u0702\u014a\u0001\u0000\u0000\u0000\u0703\u0704\u0003\u0019\n\u0000\u0704" + + "\u0705\u0001\u0000\u0000\u0000\u0705\u0706\u0006\u00a3\u0002\u0000\u0706" + + "\u0707\u0006\u00a3\t\u0000\u0707\u014c\u0001\u0000\u0000\u0000\u0708\u0709" + + "\u0003\u001d\f\u0000\u0709\u070a\u0001\u0000\u0000\u0000\u070a\u070b\u0006" + + "\u00a4\n\u0000\u070b\u014e\u0001\u0000\u0000\u0000\u070c\u070d\u0003\u001f" + + "\r\u0000\u070d\u070e\u0001\u0000\u0000\u0000\u070e\u070f\u0006\u00a5\u000b" + + "\u0000\u070f\u0150\u0001\u0000\u0000\u0000\u0710\u0711\u0003\u0011\u0006" + + "\u0000\u0711\u0712\u0001\u0000\u0000\u0000\u0712\u0713\u0006\u00a6\f\u0000" + + "\u0713\u0152\u0001\u0000\u0000\u0000\u0714\u0715\u0003\u0013\u0007\u0000" + + "\u0715\u0716\u0001\u0000\u0000\u0000\u0716\u0717\u0006\u00a7\r\u0000\u0717" + + "\u0154\u0001\u0000\u0000\u0000\u0718\u0719\u0003!\u000e\u0000\u0719\u071a" + + "\u0001\u0000\u0000\u0000\u071a\u071b\u0006\u00a8\u000e\u0000\u071b\u0156" + + "\u0001\u0000\u0000\u0000\u071c\u071d\u0003#\u000f\u0000\u071d\u071e\u0001" + + "\u0000\u0000\u0000\u071e\u071f\u0006\u00a9\u000f\u0000\u071f\u0158\u0001" + + "\u0000\u0000\u0000\u0720\u0721\u0003%\u0010\u0000\u0721\u0722\u0001\u0000" + + "\u0000\u0000\u0722\u0723\u0006\u00aa\u0010\u0000\u0723\u015a\u0001\u0000" + + "\u0000\u0000\u0724\u0725\u0003\'\u0011\u0000\u0725\u0726\u0001\u0000\u0000" + + "\u0000\u0726\u0727\u0006\u00ab\u0011\u0000\u0727\u015c\u0001\u0000\u0000" + + "\u0000\u0728\u0729\u0003)\u0012\u0000\u0729\u072a\u0001\u0000\u0000\u0000" + + "\u072a\u072b\u0006\u00ac\u0012\u0000\u072b\u015e\u0001\u0000\u0000\u0000" + + "\u072c\u072d\u0003+\u0013\u0000\u072d\u072e\u0001\u0000\u0000\u0000\u072e" + + "\u072f\u0006\u00ad\u0013\u0000\u072f\u0160\u0001\u0000\u0000\u0000\u0730" + + "\u0731\u0003-\u0014\u0000\u0731\u0732\u0001\u0000\u0000\u0000\u0732\u0733" + + "\u0006\u00ae\u0014\u0000\u0733\u0162\u0001\u0000\u0000\u0000\u0734\u0735" + + "\u0003/\u0015\u0000\u0735\u0736\u0001\u0000\u0000\u0000\u0736\u0737\u0006" + + "\u00af\u0015\u0000\u0737\u0164\u0001\u0000\u0000\u0000\u0738\u0739\u0003" + + "1\u0016\u0000\u0739\u073a\u0001\u0000\u0000\u0000\u073a\u073b\u0006\u00b0" + + "\u0016\u0000\u073b\u0166\u0001\u0000\u0000\u0000\u073c\u073d\u00033\u0017" + + "\u0000\u073d\u073e\u0001\u0000\u0000\u0000\u073e\u073f\u0006\u00b1\u0017" + + "\u0000\u073f\u0168\u0001\u0000\u0000\u0000\u0740\u0741\u00035\u0018\u0000" + + "\u0741\u0742\u0001\u0000\u0000\u0000\u0742\u0743\u0006\u00b2\u0018\u0000" + + "\u0743\u016a\u0001\u0000\u0000\u0000\u0744\u0745\u00037\u0019\u0000\u0745" + + "\u0746\u0001\u0000\u0000\u0000\u0746\u0747\u0006\u00b3\u0019\u0000\u0747" + + "\u016c\u0001\u0000\u0000\u0000\u0748\u0749\u00039\u001a\u0000\u0749\u074a" + + "\u0001\u0000\u0000\u0000\u074a\u074b\u0006\u00b4\u001a\u0000\u074b\u016e" + + "\u0001\u0000\u0000\u0000\u074c\u074d\u0003;\u001b\u0000\u074d\u074e\u0001" + + "\u0000\u0000\u0000\u074e\u074f\u0006\u00b5\u001b\u0000\u074f\u0170\u0001" + + "\u0000\u0000\u0000\u0750\u0751\u0003=\u001c\u0000\u0751\u0752\u0001\u0000" + + "\u0000\u0000\u0752\u0753\u0006\u00b6\u001c\u0000\u0753\u0172\u0001\u0000" + + "\u0000\u0000\u0754\u0755\u0003?\u001d\u0000\u0755\u0756\u0001\u0000\u0000" + + "\u0000\u0756\u0757\u0006\u00b7\u001d\u0000\u0757\u0174\u0001\u0000\u0000" + + "\u0000\u0758\u0759\u0003A\u001e\u0000\u0759\u075a\u0001\u0000\u0000\u0000" + + "\u075a\u075b\u0006\u00b8\u001e\u0000\u075b\u0176\u0001\u0000\u0000\u0000" + + "\u075c\u075d\u0003C\u001f\u0000\u075d\u075e\u0001\u0000\u0000\u0000\u075e" + + "\u075f\u0006\u00b9\u001f\u0000\u075f\u0178\u0001\u0000\u0000\u0000\u0760" + + "\u0761\u0003E \u0000\u0761\u0762\u0001\u0000\u0000\u0000\u0762\u0763\u0006" + + "\u00ba \u0000\u0763\u017a\u0001\u0000\u0000\u0000\u0764\u0765\u0003G!" + + "\u0000\u0765\u0766\u0001\u0000\u0000\u0000\u0766\u0767\u0006\u00bb!\u0000" + + "\u0767\u017c\u0001\u0000\u0000\u0000\u0768\u0769\u0003I\"\u0000\u0769" + + "\u076a\u0001\u0000\u0000\u0000\u076a\u076b\u0006\u00bc\"\u0000\u076b\u017e" + + "\u0001\u0000\u0000\u0000\u076c\u076d\u0003\u000f\u0005\u0000\u076d\u076e" + + "\u0001\u0000\u0000\u0000\u076e\u076f\u0006\u00bd#\u0000\u076f\u0180\u0001" + + "\u0000\u0000\u0000\u0770\u0771\u0003K#\u0000\u0771\u0772\u0001\u0000\u0000" + + "\u0000\u0772\u0773\u0006\u00be$\u0000\u0773\u0182\u0001\u0000\u0000\u0000" + + "\u0774\u0775\u0003M$\u0000\u0775\u0776\u0001\u0000\u0000\u0000\u0776\u0777" + + "\u0006\u00bf%\u0000\u0777\u0184\u0001\u0000\u0000\u0000\u0778\u0779\u0003" + + "O%\u0000\u0779\u077a\u0001\u0000\u0000\u0000\u077a\u077b\u0006\u00c0&" + + "\u0000\u077b\u0186\u0001\u0000\u0000\u0000\u077c\u077d\u0003Q&\u0000\u077d" + + "\u077e\u0001\u0000\u0000\u0000\u077e\u077f\u0006\u00c1\'"; + private static final String _serializedATNSegment1 = + "\u0000\u077f\u0188\u0001\u0000\u0000\u0000\u0780\u0781\u0003S\'\u0000" + + "\u0781\u0782\u0001\u0000\u0000\u0000\u0782\u0783\u0006\u00c2(\u0000\u0783" + + "\u018a\u0001\u0000\u0000\u0000\u0784\u0785\u0003U(\u0000\u0785\u0786\u0001" + + "\u0000\u0000\u0000\u0786\u0787\u0006\u00c3)\u0000\u0787\u018c\u0001\u0000" + + "\u0000\u0000\u0788\u0789\u0003W)\u0000\u0789\u078a\u0001\u0000\u0000\u0000" + + "\u078a\u078b\u0006\u00c4*\u0000\u078b\u018e\u0001\u0000\u0000\u0000\u078c" + + "\u078d\u0003Y*\u0000\u078d\u078e\u0001\u0000\u0000\u0000\u078e\u078f\u0006" + + "\u00c5+\u0000\u078f\u0190\u0001\u0000\u0000\u0000\u0790\u0791\u0003[+" + + "\u0000\u0791\u0792\u0001\u0000\u0000\u0000\u0792\u0793\u0006\u00c6,\u0000" + + "\u0793\u0192\u0001\u0000\u0000\u0000\u0794\u0795\u0003],\u0000\u0795\u0796" + + "\u0001\u0000\u0000\u0000\u0796\u0797\u0006\u00c7-\u0000\u0797\u0194\u0001" + + "\u0000\u0000\u0000\u0798\u0799\u0003_-\u0000\u0799\u079a\u0001\u0000\u0000" + + "\u0000\u079a\u079b\u0006\u00c8.\u0000\u079b\u0196\u0001\u0000\u0000\u0000" + + "\u079c\u079d\u0003a.\u0000\u079d\u079e\u0001\u0000\u0000\u0000\u079e\u079f" + + "\u0006\u00c9/\u0000\u079f\u0198\u0001\u0000\u0000\u0000\u07a0\u07a1\u0003" + + "c/\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000\u07a2\u07a3\u0006\u00ca0" + + "\u0000\u07a3\u019a\u0001\u0000\u0000\u0000\u07a4\u07a5\u0003\u00b7Y\u0000" + + "\u07a5\u07a6\u0001\u0000\u0000\u0000\u07a6\u07a7\u0006\u00cb1\u0000\u07a7" + + "\u019c\u0001\u0000\u0000\u0000\u07a8\u07a9\u0003\u00b9Z\u0000\u07a9\u07aa" + + "\u0001\u0000\u0000\u0000\u07aa\u07ab\u0006\u00cc2\u0000\u07ab\u019e\u0001" + + "\u0000\u0000\u0000\u07ac\u07ad\u0003e0\u0000\u07ad\u07ae\u0001\u0000\u0000" + + "\u0000\u07ae\u07af\u0006\u00cd3\u0000\u07af\u01a0\u0001\u0000\u0000\u0000" + + "\u07b0\u07b1\u0003g1\u0000\u07b1\u07b2\u0001\u0000\u0000\u0000\u07b2\u07b3" + + "\u0006\u00ce4\u0000\u07b3\u01a2\u0001\u0000\u0000\u0000\u07b4\u07b5\u0003" + + "i2\u0000\u07b5\u07b6\u0001\u0000\u0000\u0000\u07b6\u07b7\u0006\u00cf5" + + "\u0000\u07b7\u01a4\u0001\u0000\u0000\u0000\u07b8\u07b9\u0003k3\u0000\u07b9" + + "\u07ba\u0001\u0000\u0000\u0000\u07ba\u07bb\u0006\u00d06\u0000\u07bb\u01a6" + + "\u0001\u0000\u0000\u0000\u07bc\u07bd\u0003\u0105\u0080\u0000\u07bd\u07be" + + "\u0001\u0000\u0000\u0000\u07be\u07bf\u0006\u00d1\u0003\u0000\u07bf\u07c0" + + "\u0006\u00d17\u0000\u07c0\u01a8\u0001\u0000\u0000\u0000\u07c1\u07c2\u0003" + + "\u0107\u0081\u0000\u07c2\u07c3\u0001\u0000\u0000\u0000\u07c3\u07c4\u0006" + + "\u00d2\u0004\u0000\u07c4\u07c5\u0006\u00d28\u0000\u07c5\u01aa\u0001\u0000" + + "\u0000\u0000\u07c6\u07c7\u0003\u0081>\u0000\u07c7\u07c8\u0001\u0000\u0000" + + "\u0000\u07c8\u07c9\u0006\u00d39\u0000\u07c9\u01ac\u0001\u0000\u0000\u0000" + + "\u07ca\u07cb\u0003\u0083?\u0000\u07cb\u07cc\u0001\u0000\u0000\u0000\u07cc" + + "\u07cd\u0006\u00d4:\u0000\u07cd\u01ae\u0001\u0000\u0000\u0000\u07ce\u07cf" + + "\u0003\u007f=\u0000\u07cf\u07d0\u0001\u0000\u0000\u0000\u07d0\u07d1\u0006" + + "\u00d5;\u0000\u07d1\u01b0\u0001\u0000\u0000\u0000\u07d2\u07d3\u0003\u0091" + + "F\u0000\u07d3\u07d4\u0001\u0000\u0000\u0000\u07d4\u07d5\u0006\u00d6<\u0000" + + "\u07d5\u01b2\u0001\u0000\u0000\u0000\u07d6\u07d7\u0003\u00b5X\u0000\u07d7" + + "\u07d8\u0001\u0000\u0000\u0000\u07d8\u07d9\u0006\u00d7=\u0000\u07d9\u01b4" + + "\u0001\u0000\u0000\u0000\u07da\u07db\u0003\u00bb[\u0000\u07db\u07dc\u0001" + + "\u0000\u0000\u0000\u07dc\u07dd\u0006\u00d8>\u0000\u07dd\u01b6\u0001\u0000" + + "\u0000\u0000\u07de\u07df\u0003\u00bd\\\u0000\u07df\u07e0\u0001\u0000\u0000" + + "\u0000\u07e0\u07e1\u0006\u00d9?\u0000\u07e1\u01b8\u0001\u0000\u0000\u0000" + + "\u07e2\u07e3\u0003s7\u0000\u07e3\u07e4\u0001\u0000\u0000\u0000\u07e4\u07e5" + + "\u0006\u00da@\u0000\u07e5\u01ba\u0001\u0000\u0000\u0000\u07e6\u07e7\u0003" + + "\u00bf]\u0000\u07e7\u07e8\u0001\u0000\u0000\u0000\u07e8\u07e9\u0006\u00db" + + "A\u0000\u07e9\u01bc\u0001\u0000\u0000\u0000\u07ea\u07eb\u0003\u00c1^\u0000" + + "\u07eb\u07ec\u0001\u0000\u0000\u0000\u07ec\u07ed\u0006\u00dcB\u0000\u07ed" + + "\u01be\u0001\u0000\u0000\u0000\u07ee\u07ef\u0003\u00c3_\u0000\u07ef\u07f0" + + "\u0001\u0000\u0000\u0000\u07f0\u07f1\u0006\u00ddC\u0000\u07f1\u01c0\u0001" + + "\u0000\u0000\u0000\u07f2\u07f3\u0003\u00c9b\u0000\u07f3\u07f4\u0001\u0000" + + "\u0000\u0000\u07f4\u07f5\u0006\u00deD\u0000\u07f5\u01c2\u0001\u0000\u0000" + + "\u0000\u07f6\u07f7\u0003\u00cbc\u0000\u07f7\u07f8\u0001\u0000\u0000\u0000" + + "\u07f8\u07f9\u0006\u00dfE\u0000\u07f9\u01c4\u0001\u0000\u0000\u0000\u07fa" + + "\u07fb\u0003\u00cdd\u0000\u07fb\u07fc\u0001\u0000\u0000\u0000\u07fc\u07fd" + + "\u0006\u00e0F\u0000\u07fd\u01c6\u0001\u0000\u0000\u0000\u07fe\u07ff\u0003" + + "\u00cfe\u0000\u07ff\u0800\u0001\u0000\u0000\u0000\u0800\u0801\u0006\u00e1" + + "G\u0000\u0801\u01c8\u0001\u0000\u0000\u0000\u0802\u0803\u0003\u00a9R\u0000" + + "\u0803\u0804\u0001\u0000\u0000\u0000\u0804\u0805\u0006\u00e2H\u0000\u0805" + + "\u01ca\u0001\u0000\u0000\u0000\u0806\u0807\u0003\u00abS\u0000\u0807\u0808" + + "\u0001\u0000\u0000\u0000\u0808\u0809\u0006\u00e3I\u0000\u0809\u01cc\u0001" + + "\u0000\u0000\u0000\u080a\u080b\u0003\u00adT\u0000\u080b\u080c\u0001\u0000" + + "\u0000\u0000\u080c\u080d\u0006\u00e4J\u0000\u080d\u01ce\u0001\u0000\u0000" + + "\u0000\u080e\u080f\u0003\u00afU\u0000\u080f\u0810\u0001\u0000\u0000\u0000" + + "\u0810\u0811\u0006\u00e5K\u0000\u0811\u01d0\u0001\u0000\u0000\u0000\u0812" + + "\u0813\u0003m4\u0000\u0813\u0814\u0001\u0000\u0000\u0000\u0814\u0815\u0006" + + "\u00e6L\u0000\u0815\u01d2\u0001\u0000\u0000\u0000\u0816\u0817\u0003o5" + + "\u0000\u0817\u0818\u0001\u0000\u0000\u0000\u0818\u0819\u0006\u00e7M\u0000" + + "\u0819\u01d4\u0001\u0000\u0000\u0000\u081a\u081b\u0003q6\u0000\u081b\u081c" + + "\u0001\u0000\u0000\u0000\u081c\u081d\u0006\u00e8N\u0000\u081d\u01d6\u0001" + + "\u0000\u0000\u0000\u081e\u081f\u0003\u0097I\u0000\u081f\u0820\u0001\u0000" + + "\u0000\u0000\u0820\u0821\u0006\u00e9O\u0000\u0821\u01d8\u0001\u0000\u0000" + + "\u0000\u0822\u0823\u0003\u0099J\u0000\u0823\u0824\u0001\u0000\u0000\u0000" + + "\u0824\u0825\u0006\u00eaP\u0000\u0825\u01da\u0001\u0000\u0000\u0000\u0826" + + "\u0827\u0003\u009bK\u0000\u0827\u0828\u0001\u0000\u0000\u0000\u0828\u0829" + + "\u0006\u00ebQ\u0000\u0829\u01dc\u0001\u0000\u0000\u0000\u082a\u082b\u0003" + + "\u009dL\u0000\u082b\u082c\u0001\u0000\u0000\u0000\u082c\u082d\u0006\u00ec" + + "R\u0000\u082d\u01de\u0001\u0000\u0000\u0000\u082e\u082f\u0003\u009fM\u0000" + + "\u082f\u0830\u0001\u0000\u0000\u0000\u0830\u0831\u0006\u00edS\u0000\u0831" + + "\u01e0\u0001\u0000\u0000\u0000\u0832\u0833\u0003\u00a1N\u0000\u0833\u0834" + + "\u0001\u0000\u0000\u0000\u0834\u0835\u0006\u00eeT\u0000\u0835\u01e2\u0001" + + "\u0000\u0000\u0000\u0836\u0837\u0003\u00a3O\u0000\u0837\u0838\u0001\u0000" + + "\u0000\u0000\u0838\u0839\u0006\u00efU\u0000\u0839\u01e4\u0001\u0000\u0000" + + "\u0000\u083a\u083b\u0003\u00a5P\u0000\u083b\u083c\u0001\u0000\u0000\u0000" + + "\u083c\u083d\u0006\u00f0V\u0000\u083d\u01e6\u0001\u0000\u0000\u0000\u083e" + + "\u083f\u0003\u00a7Q\u0000\u083f\u0840\u0001\u0000\u0000\u0000\u0840\u0841" + + "\u0006\u00f1W\u0000\u0841\u01e8\u0001\u0000\u0000\u0000\u0842\u0843\u0003" + + "\u00d3g\u0000\u0843\u0844\u0001\u0000\u0000\u0000\u0844\u0845\u0006\u00f2" + + "X\u0000\u0845\u01ea\u0001\u0000\u0000\u0000\u0846\u0847\u0003\u00d5h\u0000" + + "\u0847\u0848\u0001\u0000\u0000\u0000\u0848\u0849\u0006\u00f3Y\u0000\u0849" + + "\u01ec\u0001\u0000\u0000\u0000\u084a\u084b\u0003\u00d7i\u0000\u084b\u084c" + + "\u0001\u0000\u0000\u0000\u084c\u084d\u0006\u00f4Z\u0000\u084d\u01ee\u0001" + + "\u0000\u0000\u0000\u084e\u084f\u0003\u00d9j\u0000\u084f\u0850\u0001\u0000" + + "\u0000\u0000\u0850\u0851\u0006\u00f5[\u0000\u0851\u01f0\u0001\u0000\u0000" + + "\u0000\u0852\u0853\u0003\u00dbk\u0000\u0853\u0854\u0001\u0000\u0000\u0000" + + "\u0854\u0855\u0006\u00f6\\\u0000\u0855\u01f2\u0001\u0000\u0000\u0000\u0856" + + "\u0857\u0003\u00ddl\u0000\u0857\u0858\u0001\u0000\u0000\u0000\u0858\u0859" + + "\u0006\u00f7]\u0000\u0859\u01f4\u0001\u0000\u0000\u0000\u085a\u085b\u0003" + + "\u00dfm\u0000\u085b\u085c\u0001\u0000\u0000\u0000\u085c\u085d\u0006\u00f8" + + "^\u0000\u085d\u01f6\u0001\u0000\u0000\u0000\u085e\u085f\u0003\u00e1n\u0000" + + "\u085f\u0860\u0001\u0000\u0000\u0000\u0860\u0861\u0006\u00f9_\u0000\u0861" + + "\u01f8\u0001\u0000\u0000\u0000\u0862\u0863\u0003\u00e3o\u0000\u0863\u0864" + + "\u0001\u0000\u0000\u0000\u0864\u0865\u0006\u00fa`\u0000\u0865\u01fa\u0001" + + "\u0000\u0000\u0000\u0866\u0867\u0003\u00e5p\u0000\u0867\u0868\u0001\u0000" + + "\u0000\u0000\u0868\u0869\u0006\u00fba\u0000\u0869\u01fc\u0001\u0000\u0000" + + "\u0000\u086a\u086b\u0003\u00e7q\u0000\u086b\u086c\u0001\u0000\u0000\u0000" + + "\u086c\u086d\u0006\u00fcb\u0000\u086d\u01fe\u0001\u0000\u0000\u0000\u086e" + + "\u086f\u0003\u00e9r\u0000\u086f\u0870\u0001\u0000\u0000\u0000\u0870\u0871" + + "\u0006\u00fdc\u0000\u0871\u0200\u0001\u0000\u0000\u0000\u0872\u0873\u0003" + + "\u00ebs\u0000\u0873\u0874\u0001\u0000\u0000\u0000\u0874\u0875\u0006\u00fe" + + "d\u0000\u0875\u0202\u0001\u0000\u0000\u0000\u0876\u0877\u0003\u00edt\u0000" + + "\u0877\u0878\u0001\u0000\u0000\u0000\u0878\u0879\u0006\u00ffe\u0000\u0879" + + "\u0204\u0001\u0000\u0000\u0000\u087a\u087b\u0003\u00efu\u0000\u087b\u087c" + + "\u0001\u0000\u0000\u0000\u087c\u087d\u0006\u0100f\u0000\u087d\u0206\u0001" + + "\u0000\u0000\u0000\u087e\u087f\u0003\u00f1v\u0000\u087f\u0880\u0001\u0000" + + "\u0000\u0000\u0880\u0881\u0006\u0101g\u0000\u0881\u0208\u0001\u0000\u0000" + + "\u0000\u0882\u0883\u0003\u00f3w\u0000\u0883\u0884\u0001\u0000\u0000\u0000" + + "\u0884\u0885\u0006\u0102h\u0000\u0885\u020a\u0001\u0000\u0000\u0000\u0886" + + "\u0887\u0003\u00f5x\u0000\u0887\u0888\u0001\u0000\u0000\u0000\u0888\u0889" + + "\u0006\u0103i\u0000\u0889\u020c\u0001\u0000\u0000\u0000\u088a\u088b\u0003" + + "\u00f7y\u0000\u088b\u088c\u0001\u0000\u0000\u0000\u088c\u088d\u0006\u0104" + + "j\u0000\u088d\u020e\u0001\u0000\u0000\u0000\u088e\u088f\u0003\u00f9z\u0000" + + "\u088f\u0890\u0001\u0000\u0000\u0000\u0890\u0891\u0006\u0105k\u0000\u0891" + + "\u0210\u0001\u0000\u0000\u0000\u0892\u0893\u0003\u00fb{\u0000\u0893\u0894" + + "\u0001\u0000\u0000\u0000\u0894\u0895\u0006\u0106l\u0000\u0895\u0212\u0001" + + "\u0000\u0000\u0000\u0896\u0897\u0003\u00fd|\u0000\u0897\u0898\u0001\u0000" + + "\u0000\u0000\u0898\u0899\u0006\u0107m\u0000\u0899\u0214\u0001\u0000\u0000" + + "\u0000\u089a\u089b\u0003\u00ff}\u0000\u089b\u089c\u0001\u0000\u0000\u0000" + + "\u089c\u089d\u0006\u0108n\u0000\u089d\u0216\u0001\u0000\u0000\u0000\u089e" + + "\u089f\u0003\u0101~\u0000\u089f\u08a0\u0001\u0000\u0000\u0000\u08a0\u08a1" + + "\u0006\u0109o\u0000\u08a1\u0218\u0001\u0000\u0000\u0000\u08a2\u08a3\u0003" + + "\u0103\u007f\u0000\u08a3\u08a4\u0001\u0000\u0000\u0000\u08a4\u08a5\u0006" + + "\u010ap\u0000\u08a5\u021a\u0001\u0000\u0000\u0000\u08a6\u08a7\u0003\u0121" + + "\u008e\u0000\u08a7\u08a8\u0001\u0000\u0000\u0000\u08a8\u08a9\u0006\u010b" + + "q\u0000\u08a9\u021c\u0001\u0000\u0000\u0000\u08aa\u08ab\u0003\u0111\u0086" + + "\u0000\u08ab\u08ac\u0001\u0000\u0000\u0000\u08ac\u08ad\u0006\u010cr\u0000" + + "\u08ad\u021e\u0001\u0000\u0000\u0000\u08ae\u08af\u0003\u0119\u008a\u0000" + + "\u08af\u08b0\u0001\u0000\u0000\u0000\u08b0\u08b1\u0006\u010ds\u0000\u08b1" + + "\u0220\u0001\u0000\u0000\u0000\u08b2\u08b3\u0003\u011d\u008c\u0000\u08b3" + + "\u08b4\u0001\u0000\u0000\u0000\u08b4\u08b5\u0006\u010et\u0000\u08b5\u0222" + + "\u0001\u0000\u0000\u0000\u08b6\u08b7\u0003\u012d\u0094\u0000\u08b7\u08b8" + + "\u0001\u0000\u0000\u0000\u08b8\u08b9\u0006\u010fu\u0000\u08b9\u0224\u0001" + + "\u0000\u0000\u0000\u08ba\u08bb\u0003\u0109\u0082\u0000\u08bb\u08bc\u0001" + + "\u0000\u0000\u0000\u08bc\u08bd\u0006\u0110v\u0000\u08bd\u0226\u0001\u0000" + + "\u0000\u0000\u08be\u08bf\u0003\u0123\u008f\u0000\u08bf\u08c0\u0001\u0000" + + "\u0000\u0000\u08c0\u08c1\u0006\u0111w\u0000\u08c1\u0228\u0001\u0000\u0000" + + "\u0000\u08c2\u08c3\u0003\u010f\u0085\u0000\u08c3\u08c4\u0001\u0000\u0000" + + "\u0000\u08c4\u08c5\u0006\u0112x\u0000\u08c5\u022a\u0001\u0000\u0000\u0000" + + "\u08c6\u08c7\u0003\u0125\u0090\u0000\u08c7\u08c8\u0001\u0000\u0000\u0000" + + "\u08c8\u08c9\u0006\u0113y\u0000\u08c9\u022c\u0001\u0000\u0000\u0000\u08ca" + + "\u08cb\u0003\u0127\u0091\u0000\u08cb\u08cc\u0001\u0000\u0000\u0000\u08cc" + + "\u08cd\u0006\u0114z\u0000\u08cd\u022e\u0001\u0000\u0000\u0000\u08ce\u08cf" + + "\u0003\u0129\u0092\u0000\u08cf\u08d0\u0001\u0000\u0000\u0000\u08d0\u08d1" + + "\u0006\u0115{\u0000\u08d1\u0230\u0001\u0000\u0000\u0000\u08d2\u08d5\u0003" + + "\t\u0002\u0000\u08d3\u08d5\u0003\u0007\u0001\u0000\u08d4\u08d2\u0001\u0000" + + "\u0000\u0000\u08d4\u08d3\u0001\u0000\u0000\u0000\u08d5\u08d6\u0001\u0000" + + "\u0000\u0000\u08d6\u08d7\u0006\u0116\u0000\u0000\u08d7\u0232\u0001\u0000" + + "\u0000\u0000\u08d8\u08d9\u0003\u000b\u0003\u0000\u08d9\u08da\u0001\u0000" + + "\u0000\u0000\u08da\u08db\u0006\u0117\u0001\u0000\u08db\u0234\u0001\u0000" + + "\u0000\u0000\u08dc\u08dd\u0003\r\u0004\u0000\u08dd\u08de\u0001\u0000\u0000" + + "\u0000\u08de\u08df\u0006\u0118\u0001\u0000\u08df\u0236\u0001\u0000\u0000" + + "\u0000\u08e0\u08e1\u0005\"\u0000\u0000\u08e1\u08e2\u0001\u0000\u0000\u0000" + + "\u08e2\u08e3\u0006\u0119\u0005\u0000\u08e3\u0238\u0001\u0000\u0000\u0000" + + "\u08e4\u08e5\u0003\u012b\u0093\u0000\u08e5\u023a\u0001\u0000\u0000\u0000" + + "\u08e6\u08e8\b\u0013\u0000\u0000\u08e7\u08e6\u0001\u0000\u0000\u0000\u08e8" + + "\u08e9\u0001\u0000\u0000\u0000\u08e9\u08e7\u0001\u0000\u0000\u0000\u08e9" + + "\u08ea\u0001\u0000\u0000\u0000\u08ea\u08ed\u0001\u0000\u0000\u0000\u08eb" + + "\u08ed\u0005$\u0000\u0000\u08ec\u08e7\u0001\u0000\u0000\u0000\u08ec\u08eb" + + "\u0001\u0000\u0000\u0000\u08ed\u023c\u0001\u0000\u0000\u0000\u08ee\u08ef" + + "\u0005\\\u0000\u0000\u08ef\u08f2\t\u0000\u0000\u0000\u08f0\u08f2\u0003" + + "\u0131\u0096\u0000\u08f1\u08ee\u0001\u0000\u0000\u0000\u08f1\u08f0\u0001" + + "\u0000\u0000\u0000\u08f2\u023e\u0001\u0000\u0000\u0000\u08f3\u08f4\u0005" + + "$\u0000\u0000\u08f4\u08f5\u0005{\u0000\u0000\u08f5\u08f6\u0001\u0000\u0000" + + "\u0000\u08f6\u08f7\u0006\u011d|\u0000\u08f7\u0240\u0001\u0000\u0000\u0000" + + "\u08f8\u08fa\u0003\u0243\u011f\u0000\u08f9\u08f8\u0001\u0000\u0000\u0000" + + "\u08f9\u08fa\u0001\u0000\u0000\u0000\u08fa\u08fb\u0001\u0000\u0000\u0000" + + "\u08fb\u08fc\u0005\"\u0000\u0000\u08fc\u08fd\u0005\"\u0000\u0000\u08fd" + + "\u08fe\u0005\"\u0000\u0000\u08fe\u08ff\u0001\u0000\u0000\u0000\u08ff\u0900" + + "\u0006\u011e\u0005\u0000\u0900\u0242\u0001\u0000\u0000\u0000\u0901\u0903" + + "\u0005\"\u0000\u0000\u0902\u0901\u0001\u0000\u0000\u0000\u0903\u0904\u0001" + + "\u0000\u0000\u0000\u0904\u0902\u0001\u0000\u0000\u0000\u0904\u0905\u0001" + + "\u0000\u0000\u0000\u0905\u0244\u0001\u0000\u0000\u0000\u0906\u0907\u0003" + + "\u012b\u0093\u0000\u0907\u0246\u0001\u0000\u0000\u0000\u0908\u090a\b\u0013" + + "\u0000\u0000\u0909\u0908\u0001\u0000\u0000\u0000\u090a\u090b\u0001\u0000" + + "\u0000\u0000\u090b\u0909\u0001\u0000\u0000\u0000\u090b\u090c\u0001\u0000" + + "\u0000\u0000\u090c\u090f\u0001\u0000\u0000\u0000\u090d\u090f\u0005$\u0000" + + "\u0000\u090e\u0909\u0001\u0000\u0000\u0000\u090e\u090d\u0001\u0000\u0000" + + "\u0000\u090f\u0248\u0001\u0000\u0000\u0000\u0910\u0911\u0005\\\u0000\u0000" + + "\u0911\u0912\t\u0000\u0000\u0000\u0912\u024a\u0001\u0000\u0000\u0000\u0913" + + "\u0914\u0005$\u0000\u0000\u0914\u0915\u0005{\u0000\u0000\u0915\u0916\u0001" + + "\u0000\u0000\u0000\u0916\u0917\u0006\u0123|\u0000\u0917\u024c\u0001\u0000" + + "\u0000\u0000\u0918\u0919\u0003\r\u0004\u0000\u0919\u091a\u0001\u0000\u0000" + + "\u0000\u091a\u091b\u0006\u0124\u0001\u0000\u091b\u024e\u0001\u0000\u0000" + + "\u0000\u091c\u091d\u0003\u001f\r\u0000\u091d\u091e\u0001\u0000\u0000\u0000" + + "\u091e\u091f\u0006\u0125\u0005\u0000\u091f\u0920\u0006\u0125\u000b\u0000" + + "\u0920\u0250\u0001\u0000\u0000\u0000\u0921\u0922\u0003\u0015\b\u0000\u0922" + + "\u0923\u0001\u0000\u0000\u0000\u0923\u0924\u0006\u0126\u0002\u0000\u0924" + + "\u0925\u0006\u0126\b\u0000\u0925\u0252\u0001\u0000\u0000\u0000\u0926\u0927" + + "\u0003\u0019\n\u0000\u0927\u0928\u0001\u0000\u0000\u0000\u0928\u0929\u0006" + + "\u0127\u0002\u0000\u0929\u092a\u0006\u0127\t\u0000\u092a\u0254\u0001\u0000" + + "\u0000\u0000\u092b\u092c\u0005)\u0000\u0000\u092c\u092d\u0001\u0000\u0000" + + "\u0000\u092d\u092e\u0006\u0128\u0006\u0000\u092e\u0256\u0001\u0000\u0000" + + "\u0000\u092f\u0930\u0005]\u0000\u0000\u0930\u0931\u0001\u0000\u0000\u0000" + + "\u0931\u0932\u0006\u0129\u0007\u0000\u0932\u0258\u0001\u0000\u0000\u0000" + + "\u0933\u0934\u0003\u001d\f\u0000\u0934\u0935\u0001\u0000\u0000\u0000\u0935" + + "\u0936\u0006\u012a|\u0000\u0936\u0937\u0006\u012a\n\u0000\u0937\u025a" + + "\u0001\u0000\u0000\u0000\u0938\u0939\u0003\u0011\u0006\u0000\u0939\u093a" + + "\u0001\u0000\u0000\u0000\u093a\u093b\u0006\u012b\f\u0000\u093b\u025c\u0001" + + "\u0000\u0000\u0000\u093c\u093d\u0003\u0013\u0007\u0000\u093d\u093e\u0001" + + "\u0000\u0000\u0000\u093e\u093f\u0006\u012c\r\u0000\u093f\u025e\u0001\u0000" + + "\u0000\u0000\u0940\u0941\u0003!\u000e\u0000\u0941\u0942\u0001\u0000\u0000" + + "\u0000\u0942\u0943\u0006\u012d\u000e\u0000\u0943\u0260\u0001\u0000\u0000" + + "\u0000\u0944\u0945\u0003#\u000f\u0000\u0945\u0946\u0001\u0000\u0000\u0000" + + "\u0946\u0947\u0006\u012e\u000f\u0000\u0947\u0262\u0001\u0000\u0000\u0000" + + "\u0948\u0949\u0003%\u0010\u0000\u0949\u094a\u0001\u0000\u0000\u0000\u094a" + + "\u094b\u0006\u012f\u0010\u0000\u094b\u0264\u0001\u0000\u0000\u0000\u094c" + + "\u094d\u0003\'\u0011\u0000\u094d\u094e\u0001\u0000\u0000\u0000\u094e\u094f" + + "\u0006\u0130\u0011\u0000\u094f\u0266\u0001\u0000\u0000\u0000\u0950\u0951" + + "\u0003)\u0012\u0000\u0951\u0952\u0001\u0000\u0000\u0000\u0952\u0953\u0006" + + "\u0131\u0012\u0000\u0953\u0268\u0001\u0000\u0000\u0000\u0954\u0955\u0003" + + "+\u0013\u0000\u0955\u0956\u0001\u0000\u0000\u0000\u0956\u0957\u0006\u0132" + + "\u0013\u0000\u0957\u026a\u0001\u0000\u0000\u0000\u0958\u0959\u0003-\u0014" + + "\u0000\u0959\u095a\u0001\u0000\u0000\u0000\u095a\u095b\u0006\u0133\u0014" + + "\u0000\u095b\u026c\u0001\u0000\u0000\u0000\u095c\u095d\u0003/\u0015\u0000" + + "\u095d\u095e\u0001\u0000\u0000\u0000\u095e\u095f\u0006\u0134\u0015\u0000" + + "\u095f\u026e\u0001\u0000\u0000\u0000\u0960\u0961\u00031\u0016\u0000\u0961" + + "\u0962\u0001\u0000\u0000\u0000\u0962\u0963\u0006\u0135\u0016\u0000\u0963" + + "\u0270\u0001\u0000\u0000\u0000\u0964\u0965\u00033\u0017\u0000\u0965\u0966" + + "\u0001\u0000\u0000\u0000\u0966\u0967\u0006\u0136\u0017\u0000\u0967\u0272" + + "\u0001\u0000\u0000\u0000\u0968\u0969\u00035\u0018\u0000\u0969\u096a\u0001" + + "\u0000\u0000\u0000\u096a\u096b\u0006\u0137\u0018\u0000\u096b\u0274\u0001" + + "\u0000\u0000\u0000\u096c\u096d\u00037\u0019\u0000\u096d\u096e\u0001\u0000" + + "\u0000\u0000\u096e\u096f\u0006\u0138\u0019\u0000\u096f\u0276\u0001\u0000" + + "\u0000\u0000\u0970\u0971\u00039\u001a\u0000\u0971\u0972\u0001\u0000\u0000" + + "\u0000\u0972\u0973\u0006\u0139\u001a\u0000\u0973\u0278\u0001\u0000\u0000" + + "\u0000\u0974\u0975\u0003;\u001b\u0000\u0975\u0976\u0001\u0000\u0000\u0000" + + "\u0976\u0977\u0006\u013a\u001b\u0000\u0977\u027a\u0001\u0000\u0000\u0000" + + "\u0978\u0979\u0003=\u001c\u0000\u0979\u097a\u0001\u0000\u0000\u0000\u097a" + + "\u097b\u0006\u013b\u001c\u0000\u097b\u027c\u0001\u0000\u0000\u0000\u097c" + + "\u097d\u0003?\u001d\u0000\u097d\u097e\u0001\u0000\u0000\u0000\u097e\u097f" + + "\u0006\u013c\u001d\u0000\u097f\u027e\u0001\u0000\u0000\u0000\u0980\u0981" + + "\u0003A\u001e\u0000\u0981\u0982\u0001\u0000\u0000\u0000\u0982\u0983\u0006" + + "\u013d\u001e\u0000\u0983\u0280\u0001\u0000\u0000\u0000\u0984\u0985\u0003" + + "C\u001f\u0000\u0985\u0986\u0001\u0000\u0000\u0000\u0986\u0987\u0006\u013e" + + "\u001f\u0000\u0987\u0282\u0001\u0000\u0000\u0000\u0988\u0989\u0003E \u0000" + + "\u0989\u098a\u0001\u0000\u0000\u0000\u098a\u098b\u0006\u013f \u0000\u098b" + + "\u0284\u0001\u0000\u0000\u0000\u098c\u098d\u0003G!\u0000\u098d\u098e\u0001" + + "\u0000\u0000\u0000\u098e\u098f\u0006\u0140!\u0000\u098f\u0286\u0001\u0000" + + "\u0000\u0000\u0990\u0991\u0003I\"\u0000\u0991\u0992\u0001\u0000\u0000" + + "\u0000\u0992\u0993\u0006\u0141\"\u0000\u0993\u0288\u0001\u0000\u0000\u0000" + + "\u0994\u0995\u0003K#\u0000\u0995\u0996\u0001\u0000\u0000\u0000\u0996\u0997" + + "\u0006\u0142$\u0000\u0997\u028a\u0001\u0000\u0000\u0000\u0998\u0999\u0003" + + "M$\u0000\u0999\u099a\u0001\u0000\u0000\u0000\u099a\u099b\u0006\u0143%" + + "\u0000\u099b\u028c\u0001\u0000\u0000\u0000\u099c\u099d\u0003O%\u0000\u099d" + + "\u099e\u0001\u0000\u0000\u0000\u099e\u099f\u0006\u0144&\u0000\u099f\u028e" + + "\u0001\u0000\u0000\u0000\u09a0\u09a1\u0003Q&\u0000\u09a1\u09a2\u0001\u0000" + + "\u0000\u0000\u09a2\u09a3\u0006\u0145\'\u0000\u09a3\u0290\u0001\u0000\u0000" + + "\u0000\u09a4\u09a5\u0003S\'\u0000\u09a5\u09a6\u0001\u0000\u0000\u0000" + + "\u09a6\u09a7\u0006\u0146(\u0000\u09a7\u0292\u0001\u0000\u0000\u0000\u09a8" + + "\u09a9\u0003U(\u0000\u09a9\u09aa\u0001\u0000\u0000\u0000\u09aa\u09ab\u0006" + + "\u0147)\u0000\u09ab\u0294\u0001\u0000\u0000\u0000\u09ac\u09ad\u0003W)" + + "\u0000\u09ad\u09ae\u0001\u0000\u0000\u0000\u09ae\u09af\u0006\u0148*\u0000" + + "\u09af\u0296\u0001\u0000\u0000\u0000\u09b0\u09b1\u0003Y*\u0000\u09b1\u09b2" + + "\u0001\u0000\u0000\u0000\u09b2\u09b3\u0006\u0149+\u0000\u09b3\u0298\u0001" + + "\u0000\u0000\u0000\u09b4\u09b5\u0003[+\u0000\u09b5\u09b6\u0001\u0000\u0000" + + "\u0000\u09b6\u09b7\u0006\u014a,\u0000\u09b7\u029a\u0001\u0000\u0000\u0000" + + "\u09b8\u09b9\u0003],\u0000\u09b9\u09ba\u0001\u0000\u0000\u0000\u09ba\u09bb" + + "\u0006\u014b-\u0000\u09bb\u029c\u0001\u0000\u0000\u0000\u09bc\u09bd\u0003" + + "_-\u0000\u09bd\u09be\u0001\u0000\u0000\u0000\u09be\u09bf\u0006\u014c." + + "\u0000\u09bf\u029e\u0001\u0000\u0000\u0000\u09c0\u09c1\u0003a.\u0000\u09c1" + + "\u09c2\u0001\u0000\u0000\u0000\u09c2\u09c3\u0006\u014d/\u0000\u09c3\u02a0" + + "\u0001\u0000\u0000\u0000\u09c4\u09c5\u0003c/\u0000\u09c5\u09c6\u0001\u0000" + + "\u0000\u0000\u09c6\u09c7\u0006\u014e0\u0000\u09c7\u02a2\u0001\u0000\u0000" + + "\u0000\u09c8\u09c9\u0003\u00b1V\u0000\u09c9\u09ca\u0001\u0000\u0000\u0000" + + "\u09ca\u09cb\u0006\u014f}\u0000\u09cb\u02a4\u0001\u0000\u0000\u0000\u09cc" + + "\u09cd\u0003\u00b3W\u0000\u09cd\u09ce\u0001\u0000\u0000\u0000\u09ce\u09cf" + + "\u0006\u0150=\u0000\u09cf\u02a6\u0001\u0000\u0000\u0000\u09d0\u09d1\u0003" + + "\u00b5X\u0000\u09d1\u02a8\u0001\u0000\u0000\u0000\u09d2\u09d3\u0003\u00b7" + + "Y\u0000\u09d3\u09d4\u0001\u0000\u0000\u0000\u09d4\u09d5\u0006\u01521\u0000" + + "\u09d5\u02aa\u0001\u0000\u0000\u0000\u09d6\u09d7\u0003\u00b9Z\u0000\u09d7" + + "\u09d8\u0001\u0000\u0000\u0000\u09d8\u09d9\u0006\u01532\u0000\u09d9\u02ac" + + "\u0001\u0000\u0000\u0000\u09da\u09db\u0003e0\u0000\u09db\u09dc\u0001\u0000" + + "\u0000\u0000\u09dc\u09dd\u0006\u01543\u0000\u09dd\u02ae\u0001\u0000\u0000" + + "\u0000\u09de\u09df\u0003g1\u0000\u09df\u09e0\u0001\u0000\u0000\u0000\u09e0" + + "\u09e1\u0006\u01554\u0000\u09e1\u02b0\u0001\u0000\u0000\u0000\u09e2\u09e3" + + "\u0003i2\u0000\u09e3\u09e4\u0001\u0000\u0000\u0000\u09e4\u09e5\u0006\u0156" + + "5\u0000\u09e5\u02b2\u0001\u0000\u0000\u0000\u09e6\u09e7\u0003k3\u0000" + + "\u09e7\u09e8\u0001\u0000\u0000\u0000\u09e8\u09e9\u0006\u01576\u0000\u09e9" + + "\u02b4\u0001\u0000\u0000\u0000\u09ea\u09eb\u0003\u0105\u0080\u0000\u09eb" + + "\u09ec\u0001\u0000\u0000\u0000\u09ec\u09ed\u0006\u0158\u0003\u0000\u09ed" + + "\u09ee\u0006\u01587\u0000\u09ee\u02b6\u0001\u0000\u0000\u0000\u09ef\u09f0" + + "\u0003\u0107\u0081\u0000\u09f0\u09f1\u0001\u0000\u0000\u0000\u09f1\u09f2" + + "\u0006\u0159\u0004\u0000\u09f2\u09f3\u0006\u01598\u0000\u09f3\u02b8\u0001" + + "\u0000\u0000\u0000\u09f4\u09f5\u0003\u0121\u008e\u0000\u09f5\u09f6\u0001" + + "\u0000\u0000\u0000\u09f6\u09f7\u0006\u015aq\u0000\u09f7\u02ba\u0001\u0000" + + "\u0000\u0000\u09f8\u09f9\u0003\u0111\u0086\u0000\u09f9\u09fa\u0001\u0000" + + "\u0000\u0000\u09fa\u09fb\u0006\u015br\u0000\u09fb\u02bc\u0001\u0000\u0000" + + "\u0000\u09fc\u09fd\u0003\u0119\u008a\u0000\u09fd\u09fe\u0001\u0000\u0000" + + "\u0000\u09fe\u09ff\u0006\u015cs\u0000\u09ff\u02be\u0001\u0000\u0000\u0000" + + "\u0a00\u0a01\u0003\u011d\u008c\u0000\u0a01\u0a02\u0001\u0000\u0000\u0000" + + "\u0a02\u0a03\u0006\u015dt\u0000\u0a03\u02c0\u0001\u0000\u0000\u0000\u0a04" + + "\u0a05\u0003\u012d\u0094\u0000\u0a05\u0a06\u0001\u0000\u0000\u0000\u0a06" + + "\u0a07\u0006\u015eu\u0000\u0a07\u02c2\u0001\u0000\u0000\u0000\u0a08\u0a09" + + "\u0003\u0109\u0082\u0000\u0a09\u0a0a\u0001\u0000\u0000\u0000\u0a0a\u0a0b" + + "\u0006\u015fv\u0000\u0a0b\u02c4\u0001\u0000\u0000\u0000\u0a0c\u0a0d\u0003" + + "\u0123\u008f\u0000\u0a0d\u0a0e\u0001\u0000\u0000\u0000\u0a0e\u0a0f\u0006" + + "\u0160w\u0000\u0a0f\u02c6\u0001\u0000\u0000\u0000\u0a10\u0a11\u0003\u010f" + + "\u0085\u0000\u0a11\u0a12\u0001\u0000\u0000\u0000\u0a12\u0a13\u0006\u0161" + + "x\u0000\u0a13\u02c8\u0001\u0000\u0000\u0000\u0a14\u0a15\u0003\u0125\u0090" + + "\u0000\u0a15\u0a16\u0001\u0000\u0000\u0000\u0a16\u0a17\u0006\u0162y\u0000" + + "\u0a17\u02ca\u0001\u0000\u0000\u0000\u0a18\u0a19\u0003\u0127\u0091\u0000" + + "\u0a19\u0a1a\u0001\u0000\u0000\u0000\u0a1a\u0a1b\u0006\u0163z\u0000\u0a1b" + + "\u02cc\u0001\u0000\u0000\u0000\u0a1c\u0a1d\u0003\u0129\u0092\u0000\u0a1d" + + "\u0a1e\u0001\u0000\u0000\u0000\u0a1e\u0a1f\u0006\u0164{\u0000\u0a1f\u02ce" + + "\u0001\u0000\u0000\u0000\u0a20\u0a23\u0003\t\u0002\u0000\u0a21\u0a23\u0003" + + "\u0007\u0001\u0000\u0a22\u0a20\u0001\u0000\u0000\u0000\u0a22\u0a21\u0001" + + "\u0000\u0000\u0000\u0a23\u0a24\u0001\u0000\u0000\u0000\u0a24\u0a25\u0006" + + "\u0165\u0000\u0000\u0a25\u02d0\u0001\u0000\u0000\u0000\u0a26\u0a27\u0003" + + "\u000b\u0003\u0000\u0a27\u0a28\u0001\u0000\u0000\u0000\u0a28\u0a29\u0006" + + "\u0166\u0001\u0000\u0a29\u02d2\u0001\u0000\u0000\u0000\u0a2a\u0a2b\u0003" + + "\r\u0004\u0000\u0a2b\u0a2c\u0001\u0000\u0000\u0000\u0a2c\u0a2d\u0006\u0167" + + "\u0001\u0000\u0a2d\u02d4\u0001\u0000\u0000\u0000U\u0000\u0001\u0002\u0003" + + "\u0004\u02db\u02e5\u02e7\u02f5\u0301\u0470\u0472\u047a\u047c\u05a1\u05a5" + + "\u05ad\u05b1\u05b7\u05b9\u05be\u05c1\u05c6\u05cb\u05cd\u05d4\u05d8\u05dd" + + "\u05e2\u05e6\u05eb\u05ed\u05f4\u05f6\u05fb\u0600\u0605\u0607\u060c\u0611" + + "\u0613\u0617\u061c\u0625\u062b\u062d\u0635\u063a\u063f\u0645\u064a\u064f" + + "\u0651\u0658\u065a\u065f\u0664\u0669\u066b\u0670\u0675\u0677\u067b\u0688" + + "\u068a\u0694\u0696\u06a4\u06ad\u06b2\u06b4\u06bb\u06be\u06cc\u06d2\u06e4" + + "\u08d4\u08e9\u08ec\u08f1\u08f9\u0904\u090b\u090e\u0a22~\u0000\u0001\u0000" + + "\u0006\u0000\u0000\u0005\u0001\u0000\u0005\u0002\u0000\u0005\u0003\u0000" + + "\u0004\u0000\u0000\u0007\n\u0000\u0007\f\u0000\u0007\t\u0000\u0007\u000b" + + "\u0000\u0007\r\u0000\u0007\u000e\u0000\u0007\u0007\u0000\u0007\b\u0000" + + "\u0007\u000f\u0000\u0007\u0010\u0000\u0007\u0011\u0000\u0007\u0012\u0000" + + "\u0007\u0013\u0000\u0007\u0014\u0000\u0007\u0015\u0000\u0007\u0016\u0000" + + "\u0007\u0017\u0000\u0007\u0018\u0000\u0007\u0019\u0000\u0007\u001a\u0000" + + "\u0007\u001b\u0000\u0007\u001c\u0000\u0007\u001d\u0000\u0007\u001e\u0000" + + "\u0007\u001f\u0000\u0007 \u0000\u0007!\u0000\u0007\"\u0000\u0007#\u0000" + + "\u0007\u0006\u0000\u0007$\u0000\u0007%\u0000\u0007&\u0000\u0007\'\u0000" + + "\u0007(\u0000\u0007)\u0000\u0007*\u0000\u0007+\u0000\u0007,\u0000\u0007" + + "-\u0000\u0007.\u0000\u0007/\u0000\u00070\u0000\u0007Z\u0000\u0007[\u0000" + + "\u00071\u0000\u00072\u0000\u00073\u0000\u00074\u0000\u0007\u0081\u0000" + + "\u0007\u0082\u0000\u0007?\u0000\u0007@\u0000\u0007>\u0000\u0007G\u0000" + + "\u0007Y\u0000\u0007\\\u0000\u0007]\u0000\u00078\u0000\u0007^\u0000\u0007" + + "_\u0000\u0007`\u0000\u0007c\u0000\u0007d\u0000\u0007e\u0000\u0007f\u0000" + + "\u0007S\u0000\u0007T\u0000\u0007U\u0000\u0007V\u0000\u00075\u0000\u0007" + + "6\u0000\u00077\u0000\u0007J\u0000\u0007K\u0000\u0007L\u0000\u0007M\u0000" + + "\u0007N\u0000\u0007O\u0000\u0007P\u0000\u0007Q\u0000\u0007R\u0000\u0007" + + "h\u0000\u0007i\u0000\u0007j\u0000\u0007k\u0000\u0007l\u0000\u0007m\u0000" + + "\u0007n\u0000\u0007o\u0000\u0007p\u0000\u0007q\u0000\u0007r\u0000\u0007" + + "s\u0000\u0007t\u0000\u0007u\u0000\u0007v\u0000\u0007w\u0000\u0007x\u0000" + + "\u0007y\u0000\u0007z\u0000\u0007{\u0000\u0007|\u0000\u0007}\u0000\u0007" + + "~\u0000\u0007\u007f\u0000\u0007\u0080\u0000\u0007\u008a\u0000\u0007\u0087" + + "\u0000\u0007\u0088\u0000\u0007\u0089\u0000\u0007\u0090\u0000\u0007\u0083" + + "\u0000\u0007\u008b\u0000\u0007\u0086\u0000\u0007\u008c\u0000\u0007\u008d" + + "\u0000\u0007\u008e\u0000\u0005\u0004\u0000\u0007X\u0000"; + public static final String _serializedATN = Utils.join( + new String[]{ + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/KotlinLexer.tokens b/src/main/java/KotlinLexer.tokens new file mode 100644 index 0000000..fd7e064 --- /dev/null +++ b/src/main/java/KotlinLexer.tokens @@ -0,0 +1,288 @@ +ShebangLine=1 +DelimitedComment=2 +LineComment=3 +WS=4 +NL=5 +RESERVED=6 +DOT=7 +COMMA=8 +LPAREN=9 +RPAREN=10 +LSQUARE=11 +RSQUARE=12 +LCURL=13 +RCURL=14 +MULT=15 +MOD=16 +DIV=17 +ADD=18 +SUB=19 +INCR=20 +DECR=21 +CONJ=22 +DISJ=23 +EXCL=24 +COLON=25 +SEMICOLON=26 +ASSIGNMENT=27 +ADD_ASSIGNMENT=28 +SUB_ASSIGNMENT=29 +MULT_ASSIGNMENT=30 +DIV_ASSIGNMENT=31 +MOD_ASSIGNMENT=32 +ARROW=33 +DOUBLE_ARROW=34 +RANGE=35 +COLONCOLON=36 +Q_COLONCOLON=37 +DOUBLE_SEMICOLON=38 +HASH=39 +AT=40 +QUEST=41 +ELVIS=42 +LANGLE=43 +RANGLE=44 +LE=45 +GE=46 +EXCL_EQ=47 +EXCL_EQEQ=48 +AS_SAFE=49 +EQEQ=50 +EQEQEQ=51 +SINGLE_QUOTE=52 +RETURN_AT=53 +CONTINUE_AT=54 +BREAK_AT=55 +FILE=56 +PACKAGE=57 +IMPORT=58 +CLASS=59 +INTERFACE=60 +FUN=61 +OBJECT=62 +VAL=63 +VAR=64 +TYPE_ALIAS=65 +CONSTRUCTOR=66 +BY=67 +COMPANION=68 +INIT=69 +THIS=70 +SUPER=71 +TYPEOF=72 +WHERE=73 +IF=74 +ELSE=75 +WHEN=76 +TRY=77 +CATCH=78 +FINALLY=79 +FOR=80 +DO=81 +WHILE=82 +THROW=83 +RETURN=84 +CONTINUE=85 +BREAK=86 +AS=87 +IS=88 +IN=89 +NOT_IS=90 +NOT_IN=91 +OUT=92 +FIELD=93 +PROPERTY=94 +GET=95 +SET=96 +GETTER=97 +SETTER=98 +RECEIVER=99 +PARAM=100 +SETPARAM=101 +DELEGATE=102 +DYNAMIC=103 +PUBLIC=104 +PRIVATE=105 +PROTECTED=106 +INTERNAL=107 +ENUM=108 +SEALED=109 +ANNOTATION=110 +DATA=111 +INNER=112 +TAILREC=113 +OPERATOR=114 +INLINE=115 +INFIX=116 +EXTERNAL=117 +SUSPEND=118 +OVERRIDE=119 +ABSTRACT=120 +FINAL=121 +OPEN=122 +CONST=123 +LATEINIT=124 +VARARG=125 +NOINLINE=126 +CROSSINLINE=127 +REIFIED=128 +QUOTE_OPEN=129 +TRIPLE_QUOTE_OPEN=130 +RealLiteral=131 +FloatLiteral=132 +DoubleLiteral=133 +LongLiteral=134 +IntegerLiteral=135 +HexLiteral=136 +BinLiteral=137 +BooleanLiteral=138 +NullLiteral=139 +Identifier=140 +LabelReference=141 +LabelDefinition=142 +FieldIdentifier=143 +CharacterLiteral=144 +UNICODE_CLASS_LL=145 +UNICODE_CLASS_LM=146 +UNICODE_CLASS_LO=147 +UNICODE_CLASS_LT=148 +UNICODE_CLASS_LU=149 +UNICODE_CLASS_ND=150 +UNICODE_CLASS_NL=151 +Inside_Comment=152 +Inside_WS=153 +Inside_NL=154 +QUOTE_CLOSE=155 +LineStrRef=156 +LineStrText=157 +LineStrEscapedChar=158 +LineStrExprStart=159 +TRIPLE_QUOTE_CLOSE=160 +MultiLineStringQuote=161 +MultiLineStrRef=162 +MultiLineStrText=163 +MultiLineStrEscapedChar=164 +MultiLineStrExprStart=165 +MultiLineNL=166 +StrExpr_IN=167 +StrExpr_Comment=168 +StrExpr_WS=169 +StrExpr_NL=170 +'...'=6 +'.'=7 +','=8 +'('=9 +'['=11 +'{'=13 +'}'=14 +'*'=15 +'%'=16 +'/'=17 +'+'=18 +'-'=19 +'++'=20 +'--'=21 +'&&'=22 +'||'=23 +'!'=24 +':'=25 +';'=26 +'='=27 +'+='=28 +'-='=29 +'*='=30 +'/='=31 +'%='=32 +'->'=33 +'=>'=34 +'..'=35 +'::'=36 +'?::'=37 +';;'=38 +'#'=39 +'@'=40 +'?'=41 +'?:'=42 +'<'=43 +'>'=44 +'<='=45 +'>='=46 +'!='=47 +'!=='=48 +'as?'=49 +'=='=50 +'==='=51 +'\''=52 +'@file'=56 +'package'=57 +'import'=58 +'class'=59 +'interface'=60 +'fun'=61 +'object'=62 +'val'=63 +'var'=64 +'typealias'=65 +'constructor'=66 +'by'=67 +'companion'=68 +'init'=69 +'this'=70 +'super'=71 +'typeof'=72 +'where'=73 +'if'=74 +'else'=75 +'when'=76 +'try'=77 +'catch'=78 +'finally'=79 +'for'=80 +'do'=81 +'while'=82 +'throw'=83 +'return'=84 +'continue'=85 +'break'=86 +'as'=87 +'is'=88 +'in'=89 +'out'=92 +'@field'=93 +'@property'=94 +'@get'=95 +'@set'=96 +'get'=97 +'set'=98 +'@receiver'=99 +'@param'=100 +'@setparam'=101 +'@delegate'=102 +'dynamic'=103 +'public'=104 +'private'=105 +'protected'=106 +'internal'=107 +'enum'=108 +'sealed'=109 +'annotation'=110 +'data'=111 +'inner'=112 +'tailrec'=113 +'operator'=114 +'inline'=115 +'infix'=116 +'external'=117 +'suspend'=118 +'override'=119 +'abstract'=120 +'final'=121 +'open'=122 +'const'=123 +'lateinit'=124 +'vararg'=125 +'noinline'=126 +'crossinline'=127 +'reified'=128 +'"""'=130 +'null'=139 diff --git a/src/main/java/KotlinParser.interp b/src/main/java/KotlinParser.interp new file mode 100644 index 0000000..fc43d24 --- /dev/null +++ b/src/main/java/KotlinParser.interp @@ -0,0 +1,498 @@ +token literal names: +null +null +null +null +null +null +'...' +'.' +',' +'(' +null +'[' +null +'{' +'}' +'*' +'%' +'/' +'+' +'-' +'++' +'--' +'&&' +'||' +'!' +':' +';' +'=' +'+=' +'-=' +'*=' +'/=' +'%=' +'->' +'=>' +'..' +'::' +'?::' +';;' +'#' +'@' +'?' +'?:' +'<' +'>' +'<=' +'>=' +'!=' +'!==' +'as?' +'==' +'===' +'\'' +null +null +null +'@file' +'package' +'import' +'class' +'interface' +'fun' +'object' +'val' +'var' +'typealias' +'constructor' +'by' +'companion' +'init' +'this' +'super' +'typeof' +'where' +'if' +'else' +'when' +'try' +'catch' +'finally' +'for' +'do' +'while' +'throw' +'return' +'continue' +'break' +'as' +'is' +'in' +null +null +'out' +'@field' +'@property' +'@get' +'@set' +'get' +'set' +'@receiver' +'@param' +'@setparam' +'@delegate' +'dynamic' +'public' +'private' +'protected' +'internal' +'enum' +'sealed' +'annotation' +'data' +'inner' +'tailrec' +'operator' +'inline' +'infix' +'external' +'suspend' +'override' +'abstract' +'final' +'open' +'const' +'lateinit' +'vararg' +'noinline' +'crossinline' +'reified' +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 + +token symbolic names: +null +ShebangLine +DelimitedComment +LineComment +WS +NL +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +Q_COLONCOLON +DOUBLE_SEMICOLON +HASH +AT +QUEST +ELVIS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +RETURN_AT +CONTINUE_AT +BREAK_AT +FILE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +FIELD +PROPERTY +GET +SET +GETTER +SETTER +RECEIVER +PARAM +SETPARAM +DELEGATE +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +RealLiteral +FloatLiteral +DoubleLiteral +LongLiteral +IntegerLiteral +HexLiteral +BinLiteral +BooleanLiteral +NullLiteral +Identifier +LabelReference +LabelDefinition +FieldIdentifier +CharacterLiteral +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +Inside_Comment +Inside_WS +Inside_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrEscapedChar +MultiLineStrExprStart +MultiLineNL +StrExpr_IN +StrExpr_Comment +StrExpr_WS +StrExpr_NL + +rule names: +kotlinFile +script +preamble +fileAnnotations +fileAnnotation +packageHeader +importList +importHeader +importAlias +topLevelObject +classDeclaration +primaryConstructor +classParameters +classParameter +delegationSpecifiers +delegationSpecifier +constructorInvocation +explicitDelegation +classBody +classMemberDeclaration +anonymousInitializer +secondaryConstructor +constructorDelegationCall +enumClassBody +enumEntries +enumEntry +functionDeclaration +functionValueParameters +functionValueParameter +parameter +receiverType +functionBody +objectDeclaration +companionObject +propertyDeclaration +multiVariableDeclaration +variableDeclaration +getter +setter +typeAlias +typeParameters +typeParameter +type +typeModifierList +parenthesizedType +nullableType +typeReference +functionType +functionTypeReceiver +userType +simpleUserType +functionTypeParameters +typeConstraints +typeConstraint +block +statements +statement +blockLevelExpression +declaration +expression +disjunction +conjunction +equalityComparison +comparison +namedInfix +elvisExpression +infixFunctionCall +rangeExpression +additiveExpression +multiplicativeExpression +typeRHS +prefixUnaryExpression +postfixUnaryExpression +atomicExpression +parenthesizedExpression +callSuffix +annotatedLambda +arrayAccess +valueArguments +typeArguments +typeProjection +typeProjectionModifierList +valueArgument +literalConstant +stringLiteral +lineStringLiteral +multiLineStringLiteral +lineStringContent +lineStringExpression +multiLineStringContent +multiLineStringExpression +functionLiteral +lambdaParameters +lambdaParameter +objectLiteral +collectionLiteral +thisExpression +superExpression +conditionalExpression +ifExpression +controlStructureBody +whenExpression +whenEntry +whenCondition +rangeTest +typeTest +tryExpression +catchBlock +finallyBlock +loopExpression +forExpression +whileExpression +doWhileExpression +jumpExpression +callableReference +assignmentOperator +equalityOperation +comparisonOperator +inOperator +isOperator +additiveOperator +multiplicativeOperation +typeOperation +prefixUnaryOperation +postfixUnaryOperation +memberAccessOperator +modifierList +modifier +classModifier +memberModifier +visibilityModifier +varianceAnnotation +functionModifier +propertyModifier +inheritanceModifier +parameterModifier +typeParameterModifier +labelDefinition +annotations +annotation +annotationList +annotationUseSiteTarget +unescapedAnnotation +identifier +simpleIdentifier +semi +anysemi + + +atn: +[4, 1, 170, 2799, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 1, 0, 5, 0, 296, 8, 0, 10, 0, 12, 0, 299, 9, 0, 1, 0, 1, 0, 5, 0, 303, 8, 0, 10, 0, 12, 0, 306, 9, 0, 1, 0, 1, 0, 4, 0, 310, 8, 0, 11, 0, 12, 0, 311, 1, 0, 3, 0, 315, 8, 0, 5, 0, 317, 8, 0, 10, 0, 12, 0, 320, 9, 0, 3, 0, 322, 8, 0, 1, 0, 1, 0, 1, 1, 5, 1, 327, 8, 1, 10, 1, 12, 1, 330, 9, 1, 1, 1, 1, 1, 5, 1, 334, 8, 1, 10, 1, 12, 1, 337, 9, 1, 1, 1, 1, 1, 4, 1, 341, 8, 1, 11, 1, 12, 1, 342, 1, 1, 3, 1, 346, 8, 1, 5, 1, 348, 8, 1, 10, 1, 12, 1, 351, 9, 1, 3, 1, 353, 8, 1, 1, 1, 1, 1, 1, 2, 3, 2, 358, 8, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 364, 8, 3, 11, 3, 12, 3, 365, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 372, 8, 4, 11, 4, 12, 4, 373, 1, 4, 1, 4, 1, 4, 3, 4, 379, 8, 4, 1, 4, 3, 4, 382, 8, 4, 4, 4, 384, 8, 4, 11, 4, 12, 4, 385, 1, 5, 3, 5, 389, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 394, 8, 5, 3, 5, 396, 8, 5, 1, 6, 5, 6, 399, 8, 6, 10, 6, 12, 6, 402, 9, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 409, 8, 7, 1, 7, 3, 7, 412, 8, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 422, 8, 9, 1, 10, 3, 10, 425, 8, 10, 1, 10, 1, 10, 5, 10, 429, 8, 10, 10, 10, 12, 10, 432, 9, 10, 1, 10, 1, 10, 5, 10, 436, 8, 10, 10, 10, 12, 10, 439, 9, 10, 1, 10, 3, 10, 442, 8, 10, 1, 10, 5, 10, 445, 8, 10, 10, 10, 12, 10, 448, 9, 10, 1, 10, 3, 10, 451, 8, 10, 1, 10, 5, 10, 454, 8, 10, 10, 10, 12, 10, 457, 9, 10, 1, 10, 1, 10, 5, 10, 461, 8, 10, 10, 10, 12, 10, 464, 9, 10, 1, 10, 3, 10, 467, 8, 10, 1, 10, 5, 10, 470, 8, 10, 10, 10, 12, 10, 473, 9, 10, 1, 10, 3, 10, 476, 8, 10, 1, 10, 5, 10, 479, 8, 10, 10, 10, 12, 10, 482, 9, 10, 1, 10, 1, 10, 5, 10, 486, 8, 10, 10, 10, 12, 10, 489, 9, 10, 1, 10, 3, 10, 492, 8, 10, 1, 11, 3, 11, 495, 8, 11, 1, 11, 1, 11, 5, 11, 499, 8, 11, 10, 11, 12, 11, 502, 9, 11, 3, 11, 504, 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 512, 8, 12, 10, 12, 12, 12, 515, 9, 12, 1, 12, 3, 12, 518, 8, 12, 3, 12, 520, 8, 12, 1, 12, 1, 12, 1, 13, 3, 13, 525, 8, 13, 1, 13, 3, 13, 528, 8, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 535, 8, 13, 1, 14, 5, 14, 538, 8, 14, 10, 14, 12, 14, 541, 9, 14, 1, 14, 1, 14, 5, 14, 545, 8, 14, 10, 14, 12, 14, 548, 9, 14, 1, 14, 1, 14, 5, 14, 552, 8, 14, 10, 14, 12, 14, 555, 9, 14, 1, 14, 5, 14, 558, 8, 14, 10, 14, 12, 14, 561, 9, 14, 1, 14, 5, 14, 564, 8, 14, 10, 14, 12, 14, 567, 9, 14, 1, 15, 1, 15, 1, 15, 3, 15, 572, 8, 15, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 5, 17, 579, 8, 17, 10, 17, 12, 17, 582, 9, 17, 1, 17, 1, 17, 5, 17, 586, 8, 17, 10, 17, 12, 17, 589, 9, 17, 1, 17, 1, 17, 1, 18, 1, 18, 5, 18, 595, 8, 18, 10, 18, 12, 18, 598, 9, 18, 1, 18, 5, 18, 601, 8, 18, 10, 18, 12, 18, 604, 9, 18, 1, 18, 5, 18, 607, 8, 18, 10, 18, 12, 18, 610, 9, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 622, 8, 19, 1, 19, 4, 19, 625, 8, 19, 11, 19, 12, 19, 626, 1, 20, 1, 20, 5, 20, 631, 8, 20, 10, 20, 12, 20, 634, 9, 20, 1, 20, 1, 20, 1, 21, 3, 21, 639, 8, 21, 1, 21, 1, 21, 5, 21, 643, 8, 21, 10, 21, 12, 21, 646, 9, 21, 1, 21, 1, 21, 5, 21, 650, 8, 21, 10, 21, 12, 21, 653, 9, 21, 1, 21, 1, 21, 5, 21, 657, 8, 21, 10, 21, 12, 21, 660, 9, 21, 1, 21, 3, 21, 663, 8, 21, 1, 21, 5, 21, 666, 8, 21, 10, 21, 12, 21, 669, 9, 21, 1, 21, 3, 21, 672, 8, 21, 1, 22, 1, 22, 5, 22, 676, 8, 22, 10, 22, 12, 22, 679, 9, 22, 1, 22, 1, 22, 1, 22, 5, 22, 684, 8, 22, 10, 22, 12, 22, 687, 9, 22, 1, 22, 3, 22, 690, 8, 22, 1, 23, 1, 23, 5, 23, 694, 8, 23, 10, 23, 12, 23, 697, 9, 23, 1, 23, 3, 23, 700, 8, 23, 1, 23, 5, 23, 703, 8, 23, 10, 23, 12, 23, 706, 9, 23, 1, 23, 1, 23, 5, 23, 710, 8, 23, 10, 23, 12, 23, 713, 9, 23, 1, 23, 5, 23, 716, 8, 23, 10, 23, 12, 23, 719, 9, 23, 3, 23, 721, 8, 23, 1, 23, 5, 23, 724, 8, 23, 10, 23, 12, 23, 727, 9, 23, 1, 23, 1, 23, 1, 24, 1, 24, 5, 24, 733, 8, 24, 10, 24, 12, 24, 736, 9, 24, 4, 24, 738, 8, 24, 11, 24, 12, 24, 739, 1, 24, 3, 24, 743, 8, 24, 1, 25, 5, 25, 746, 8, 25, 10, 25, 12, 25, 749, 9, 25, 1, 25, 1, 25, 5, 25, 753, 8, 25, 10, 25, 12, 25, 756, 9, 25, 1, 25, 3, 25, 759, 8, 25, 1, 25, 5, 25, 762, 8, 25, 10, 25, 12, 25, 765, 9, 25, 1, 25, 3, 25, 768, 8, 25, 1, 25, 5, 25, 771, 8, 25, 10, 25, 12, 25, 774, 9, 25, 1, 25, 3, 25, 777, 8, 25, 1, 26, 3, 26, 780, 8, 26, 1, 26, 1, 26, 5, 26, 784, 8, 26, 10, 26, 12, 26, 787, 9, 26, 1, 26, 1, 26, 5, 26, 791, 8, 26, 10, 26, 12, 26, 794, 9, 26, 1, 26, 1, 26, 3, 26, 798, 8, 26, 1, 26, 5, 26, 801, 8, 26, 10, 26, 12, 26, 804, 9, 26, 1, 26, 3, 26, 807, 8, 26, 1, 26, 5, 26, 810, 8, 26, 10, 26, 12, 26, 813, 9, 26, 1, 26, 1, 26, 5, 26, 817, 8, 26, 10, 26, 12, 26, 820, 9, 26, 1, 26, 1, 26, 3, 26, 824, 8, 26, 1, 26, 5, 26, 827, 8, 26, 10, 26, 12, 26, 830, 9, 26, 1, 26, 3, 26, 833, 8, 26, 1, 26, 5, 26, 836, 8, 26, 10, 26, 12, 26, 839, 9, 26, 1, 26, 1, 26, 5, 26, 843, 8, 26, 10, 26, 12, 26, 846, 9, 26, 1, 26, 1, 26, 5, 26, 850, 8, 26, 10, 26, 12, 26, 853, 9, 26, 1, 26, 3, 26, 856, 8, 26, 1, 26, 5, 26, 859, 8, 26, 10, 26, 12, 26, 862, 9, 26, 1, 26, 3, 26, 865, 8, 26, 1, 26, 5, 26, 868, 8, 26, 10, 26, 12, 26, 871, 9, 26, 1, 26, 3, 26, 874, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 880, 8, 27, 10, 27, 12, 27, 883, 9, 27, 1, 27, 3, 27, 886, 8, 27, 3, 27, 888, 8, 27, 1, 27, 1, 27, 1, 28, 3, 28, 893, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 898, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 3, 30, 905, 8, 30, 1, 30, 1, 30, 1, 30, 3, 30, 910, 8, 30, 1, 31, 1, 31, 1, 31, 5, 31, 915, 8, 31, 10, 31, 12, 31, 918, 9, 31, 1, 31, 3, 31, 921, 8, 31, 1, 32, 3, 32, 924, 8, 32, 1, 32, 1, 32, 5, 32, 928, 8, 32, 10, 32, 12, 32, 931, 9, 32, 1, 32, 1, 32, 5, 32, 935, 8, 32, 10, 32, 12, 32, 938, 9, 32, 1, 32, 3, 32, 941, 8, 32, 1, 32, 5, 32, 944, 8, 32, 10, 32, 12, 32, 947, 9, 32, 1, 32, 1, 32, 5, 32, 951, 8, 32, 10, 32, 12, 32, 954, 9, 32, 1, 32, 3, 32, 957, 8, 32, 1, 32, 5, 32, 960, 8, 32, 10, 32, 12, 32, 963, 9, 32, 1, 32, 3, 32, 966, 8, 32, 1, 33, 3, 33, 969, 8, 33, 1, 33, 1, 33, 5, 33, 973, 8, 33, 10, 33, 12, 33, 976, 9, 33, 1, 33, 3, 33, 979, 8, 33, 1, 33, 1, 33, 5, 33, 983, 8, 33, 10, 33, 12, 33, 986, 9, 33, 1, 33, 3, 33, 989, 8, 33, 1, 33, 5, 33, 992, 8, 33, 10, 33, 12, 33, 995, 9, 33, 1, 33, 1, 33, 5, 33, 999, 8, 33, 10, 33, 12, 33, 1002, 9, 33, 1, 33, 3, 33, 1005, 8, 33, 1, 33, 5, 33, 1008, 8, 33, 10, 33, 12, 33, 1011, 9, 33, 1, 33, 3, 33, 1014, 8, 33, 1, 34, 3, 34, 1017, 8, 34, 1, 34, 1, 34, 5, 34, 1021, 8, 34, 10, 34, 12, 34, 1024, 9, 34, 1, 34, 3, 34, 1027, 8, 34, 1, 34, 5, 34, 1030, 8, 34, 10, 34, 12, 34, 1033, 9, 34, 1, 34, 1, 34, 5, 34, 1037, 8, 34, 10, 34, 12, 34, 1040, 9, 34, 1, 34, 1, 34, 3, 34, 1044, 8, 34, 1, 34, 5, 34, 1047, 8, 34, 10, 34, 12, 34, 1050, 9, 34, 1, 34, 1, 34, 3, 34, 1054, 8, 34, 1, 34, 5, 34, 1057, 8, 34, 10, 34, 12, 34, 1060, 9, 34, 1, 34, 3, 34, 1063, 8, 34, 1, 34, 5, 34, 1066, 8, 34, 10, 34, 12, 34, 1069, 9, 34, 1, 34, 1, 34, 5, 34, 1073, 8, 34, 10, 34, 12, 34, 1076, 9, 34, 1, 34, 3, 34, 1079, 8, 34, 1, 34, 5, 34, 1082, 8, 34, 10, 34, 12, 34, 1085, 9, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1091, 8, 34, 1, 34, 5, 34, 1094, 8, 34, 10, 34, 12, 34, 1097, 9, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1103, 8, 34, 3, 34, 1105, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 1111, 8, 35, 10, 35, 12, 35, 1114, 9, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 3, 36, 1121, 8, 36, 1, 37, 3, 37, 1124, 8, 37, 1, 37, 1, 37, 3, 37, 1128, 8, 37, 1, 37, 1, 37, 5, 37, 1132, 8, 37, 10, 37, 12, 37, 1135, 9, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1140, 8, 37, 10, 37, 12, 37, 1143, 9, 37, 1, 37, 1, 37, 5, 37, 1147, 8, 37, 10, 37, 12, 37, 1150, 9, 37, 1, 37, 3, 37, 1153, 8, 37, 1, 37, 5, 37, 1156, 8, 37, 10, 37, 12, 37, 1159, 9, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1164, 8, 37, 10, 37, 12, 37, 1167, 9, 37, 1, 37, 3, 37, 1170, 8, 37, 3, 37, 1172, 8, 37, 1, 38, 3, 38, 1175, 8, 38, 1, 38, 1, 38, 3, 38, 1179, 8, 38, 1, 38, 1, 38, 5, 38, 1183, 8, 38, 10, 38, 12, 38, 1186, 9, 38, 1, 38, 1, 38, 1, 38, 5, 38, 1191, 8, 38, 10, 38, 12, 38, 1194, 9, 38, 1, 38, 1, 38, 3, 38, 1198, 8, 38, 1, 38, 1, 38, 5, 38, 1202, 8, 38, 10, 38, 12, 38, 1205, 9, 38, 1, 38, 1, 38, 3, 38, 1209, 8, 38, 1, 39, 3, 39, 1212, 8, 39, 1, 39, 1, 39, 5, 39, 1216, 8, 39, 10, 39, 12, 39, 1219, 9, 39, 1, 39, 1, 39, 5, 39, 1223, 8, 39, 10, 39, 12, 39, 1226, 9, 39, 1, 39, 3, 39, 1229, 8, 39, 1, 39, 5, 39, 1232, 8, 39, 10, 39, 12, 39, 1235, 9, 39, 1, 39, 1, 39, 5, 39, 1239, 8, 39, 10, 39, 12, 39, 1242, 9, 39, 1, 39, 1, 39, 1, 40, 1, 40, 5, 40, 1248, 8, 40, 10, 40, 12, 40, 1251, 9, 40, 1, 40, 1, 40, 5, 40, 1255, 8, 40, 10, 40, 12, 40, 1258, 9, 40, 1, 40, 1, 40, 5, 40, 1262, 8, 40, 10, 40, 12, 40, 1265, 9, 40, 1, 40, 5, 40, 1268, 8, 40, 10, 40, 12, 40, 1271, 9, 40, 1, 40, 5, 40, 1274, 8, 40, 10, 40, 12, 40, 1277, 9, 40, 1, 40, 3, 40, 1280, 8, 40, 1, 40, 5, 40, 1283, 8, 40, 10, 40, 12, 40, 1286, 9, 40, 1, 40, 1, 40, 1, 41, 3, 41, 1291, 8, 41, 1, 41, 5, 41, 1294, 8, 41, 10, 41, 12, 41, 1297, 9, 41, 1, 41, 1, 41, 3, 41, 1301, 8, 41, 1, 41, 5, 41, 1304, 8, 41, 10, 41, 12, 41, 1307, 9, 41, 1, 41, 1, 41, 5, 41, 1311, 8, 41, 10, 41, 12, 41, 1314, 9, 41, 1, 41, 3, 41, 1317, 8, 41, 1, 42, 3, 42, 1320, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1326, 8, 42, 1, 43, 1, 43, 1, 43, 5, 43, 1331, 8, 43, 10, 43, 12, 43, 1334, 9, 43, 4, 43, 1336, 8, 43, 11, 43, 12, 43, 1337, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 3, 45, 1346, 8, 45, 1, 45, 5, 45, 1349, 8, 45, 10, 45, 12, 45, 1352, 9, 45, 1, 45, 4, 45, 1355, 8, 45, 11, 45, 12, 45, 1356, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1365, 8, 46, 1, 47, 1, 47, 5, 47, 1369, 8, 47, 10, 47, 12, 47, 1372, 9, 47, 1, 47, 1, 47, 5, 47, 1376, 8, 47, 10, 47, 12, 47, 1379, 9, 47, 3, 47, 1381, 8, 47, 1, 47, 1, 47, 5, 47, 1385, 8, 47, 10, 47, 12, 47, 1388, 9, 47, 1, 47, 1, 47, 5, 47, 1392, 8, 47, 10, 47, 12, 47, 1395, 9, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 3, 48, 1402, 8, 48, 1, 49, 1, 49, 5, 49, 1406, 8, 49, 10, 49, 12, 49, 1409, 9, 49, 1, 49, 1, 49, 5, 49, 1413, 8, 49, 10, 49, 12, 49, 1416, 9, 49, 1, 49, 5, 49, 1419, 8, 49, 10, 49, 12, 49, 1422, 9, 49, 1, 50, 1, 50, 5, 50, 1426, 8, 50, 10, 50, 12, 50, 1429, 9, 50, 1, 50, 3, 50, 1432, 8, 50, 1, 51, 1, 51, 5, 51, 1436, 8, 51, 10, 51, 12, 51, 1439, 9, 51, 1, 51, 1, 51, 3, 51, 1443, 8, 51, 1, 51, 5, 51, 1446, 8, 51, 10, 51, 12, 51, 1449, 9, 51, 1, 51, 1, 51, 5, 51, 1453, 8, 51, 10, 51, 12, 51, 1456, 9, 51, 1, 51, 1, 51, 3, 51, 1460, 8, 51, 5, 51, 1462, 8, 51, 10, 51, 12, 51, 1465, 9, 51, 1, 51, 5, 51, 1468, 8, 51, 10, 51, 12, 51, 1471, 9, 51, 1, 51, 3, 51, 1474, 8, 51, 1, 51, 5, 51, 1477, 8, 51, 10, 51, 12, 51, 1480, 9, 51, 1, 51, 1, 51, 1, 52, 1, 52, 5, 52, 1486, 8, 52, 10, 52, 12, 52, 1489, 9, 52, 1, 52, 1, 52, 5, 52, 1493, 8, 52, 10, 52, 12, 52, 1496, 9, 52, 1, 52, 1, 52, 5, 52, 1500, 8, 52, 10, 52, 12, 52, 1503, 9, 52, 1, 52, 5, 52, 1506, 8, 52, 10, 52, 12, 52, 1509, 9, 52, 1, 53, 5, 53, 1512, 8, 53, 10, 53, 12, 53, 1515, 9, 53, 1, 53, 1, 53, 5, 53, 1519, 8, 53, 10, 53, 12, 53, 1522, 9, 53, 1, 53, 1, 53, 5, 53, 1526, 8, 53, 10, 53, 12, 53, 1529, 9, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 5, 55, 1538, 8, 55, 10, 55, 12, 55, 1541, 9, 55, 1, 55, 1, 55, 4, 55, 1545, 8, 55, 11, 55, 12, 55, 1546, 1, 55, 3, 55, 1550, 8, 55, 5, 55, 1552, 8, 55, 10, 55, 12, 55, 1555, 9, 55, 3, 55, 1557, 8, 55, 1, 56, 1, 56, 3, 56, 1561, 8, 56, 1, 57, 5, 57, 1564, 8, 57, 10, 57, 12, 57, 1567, 9, 57, 1, 57, 5, 57, 1570, 8, 57, 10, 57, 12, 57, 1573, 9, 57, 1, 57, 1, 57, 1, 58, 5, 58, 1578, 8, 58, 10, 58, 12, 58, 1581, 9, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1587, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1593, 8, 59, 10, 59, 12, 59, 1596, 9, 59, 1, 60, 1, 60, 5, 60, 1600, 8, 60, 10, 60, 12, 60, 1603, 9, 60, 1, 60, 1, 60, 5, 60, 1607, 8, 60, 10, 60, 12, 60, 1610, 9, 60, 1, 60, 5, 60, 1613, 8, 60, 10, 60, 12, 60, 1616, 9, 60, 1, 61, 1, 61, 5, 61, 1620, 8, 61, 10, 61, 12, 61, 1623, 9, 61, 1, 61, 1, 61, 5, 61, 1627, 8, 61, 10, 61, 12, 61, 1630, 9, 61, 1, 61, 5, 61, 1633, 8, 61, 10, 61, 12, 61, 1636, 9, 61, 1, 62, 1, 62, 1, 62, 5, 62, 1641, 8, 62, 10, 62, 12, 62, 1644, 9, 62, 1, 62, 1, 62, 5, 62, 1648, 8, 62, 10, 62, 12, 62, 1651, 9, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1656, 8, 63, 10, 63, 12, 63, 1659, 9, 63, 1, 63, 1, 63, 3, 63, 1663, 8, 63, 1, 64, 1, 64, 1, 64, 5, 64, 1668, 8, 64, 10, 64, 12, 64, 1671, 9, 64, 1, 64, 1, 64, 4, 64, 1675, 8, 64, 11, 64, 12, 64, 1676, 1, 64, 1, 64, 5, 64, 1681, 8, 64, 10, 64, 12, 64, 1684, 9, 64, 1, 64, 1, 64, 3, 64, 1688, 8, 64, 1, 65, 1, 65, 5, 65, 1692, 8, 65, 10, 65, 12, 65, 1695, 9, 65, 1, 65, 1, 65, 5, 65, 1699, 8, 65, 10, 65, 12, 65, 1702, 9, 65, 1, 65, 5, 65, 1705, 8, 65, 10, 65, 12, 65, 1708, 9, 65, 1, 66, 1, 66, 1, 66, 5, 66, 1713, 8, 66, 10, 66, 12, 66, 1716, 9, 66, 1, 66, 1, 66, 5, 66, 1720, 8, 66, 10, 66, 12, 66, 1723, 9, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1728, 8, 67, 10, 67, 12, 67, 1731, 9, 67, 1, 67, 5, 67, 1734, 8, 67, 10, 67, 12, 67, 1737, 9, 67, 1, 68, 1, 68, 1, 68, 5, 68, 1742, 8, 68, 10, 68, 12, 68, 1745, 9, 68, 1, 68, 1, 68, 5, 68, 1749, 8, 68, 10, 68, 12, 68, 1752, 9, 68, 1, 69, 1, 69, 1, 69, 5, 69, 1757, 8, 69, 10, 69, 12, 69, 1760, 9, 69, 1, 69, 1, 69, 5, 69, 1764, 8, 69, 10, 69, 12, 69, 1767, 9, 69, 1, 70, 1, 70, 5, 70, 1771, 8, 70, 10, 70, 12, 70, 1774, 9, 70, 1, 70, 1, 70, 1, 70, 5, 70, 1779, 8, 70, 10, 70, 12, 70, 1782, 9, 70, 1, 71, 5, 71, 1785, 8, 71, 10, 71, 12, 71, 1788, 9, 71, 1, 71, 1, 71, 1, 72, 1, 72, 3, 72, 1794, 8, 72, 1, 72, 5, 72, 1797, 8, 72, 10, 72, 12, 72, 1800, 9, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1816, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 3, 75, 1824, 8, 75, 1, 75, 5, 75, 1827, 8, 75, 10, 75, 12, 75, 1830, 9, 75, 1, 75, 1, 75, 5, 75, 1834, 8, 75, 10, 75, 12, 75, 1837, 9, 75, 1, 75, 4, 75, 1840, 8, 75, 11, 75, 12, 75, 1841, 3, 75, 1844, 8, 75, 1, 76, 5, 76, 1847, 8, 76, 10, 76, 12, 76, 1850, 9, 76, 1, 76, 3, 76, 1853, 8, 76, 1, 76, 5, 76, 1856, 8, 76, 10, 76, 12, 76, 1859, 9, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1867, 8, 77, 10, 77, 12, 77, 1870, 9, 77, 3, 77, 1872, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 5, 78, 1880, 8, 78, 10, 78, 12, 78, 1883, 9, 78, 1, 78, 5, 78, 1886, 8, 78, 10, 78, 12, 78, 1889, 9, 78, 1, 78, 3, 78, 1892, 8, 78, 3, 78, 1894, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 5, 79, 1900, 8, 79, 10, 79, 12, 79, 1903, 9, 79, 1, 79, 1, 79, 5, 79, 1907, 8, 79, 10, 79, 12, 79, 1910, 9, 79, 1, 79, 1, 79, 5, 79, 1914, 8, 79, 10, 79, 12, 79, 1917, 9, 79, 1, 79, 5, 79, 1920, 8, 79, 10, 79, 12, 79, 1923, 9, 79, 1, 79, 3, 79, 1926, 8, 79, 1, 79, 5, 79, 1929, 8, 79, 10, 79, 12, 79, 1932, 9, 79, 1, 79, 1, 79, 3, 79, 1936, 8, 79, 1, 80, 3, 80, 1939, 8, 80, 1, 80, 1, 80, 3, 80, 1943, 8, 80, 1, 81, 4, 81, 1946, 8, 81, 11, 81, 12, 81, 1947, 1, 82, 1, 82, 5, 82, 1952, 8, 82, 10, 82, 12, 82, 1955, 9, 82, 1, 82, 1, 82, 5, 82, 1959, 8, 82, 10, 82, 12, 82, 1962, 9, 82, 3, 82, 1964, 8, 82, 1, 82, 3, 82, 1967, 8, 82, 1, 82, 5, 82, 1970, 8, 82, 10, 82, 12, 82, 1973, 9, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1986, 8, 83, 1, 84, 1, 84, 3, 84, 1990, 8, 84, 1, 85, 1, 85, 1, 85, 5, 85, 1995, 8, 85, 10, 85, 12, 85, 1998, 9, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 5, 86, 2007, 8, 86, 10, 86, 12, 86, 2010, 9, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 5, 91, 2027, 8, 91, 10, 91, 12, 91, 2030, 9, 91, 1, 91, 1, 91, 5, 91, 2034, 8, 91, 10, 91, 12, 91, 2037, 9, 91, 1, 91, 1, 91, 5, 91, 2041, 8, 91, 10, 91, 12, 91, 2044, 9, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2050, 8, 91, 10, 91, 12, 91, 2053, 9, 91, 1, 91, 1, 91, 5, 91, 2057, 8, 91, 10, 91, 12, 91, 2060, 9, 91, 1, 91, 1, 91, 5, 91, 2064, 8, 91, 10, 91, 12, 91, 2067, 9, 91, 1, 91, 1, 91, 5, 91, 2071, 8, 91, 10, 91, 12, 91, 2074, 9, 91, 1, 91, 1, 91, 3, 91, 2078, 8, 91, 1, 92, 3, 92, 2081, 8, 92, 1, 92, 5, 92, 2084, 8, 92, 10, 92, 12, 92, 2087, 9, 92, 1, 92, 1, 92, 5, 92, 2091, 8, 92, 10, 92, 12, 92, 2094, 9, 92, 1, 92, 5, 92, 2097, 8, 92, 10, 92, 12, 92, 2100, 9, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2105, 8, 93, 10, 93, 12, 93, 2108, 9, 93, 1, 93, 1, 93, 5, 93, 2112, 8, 93, 10, 93, 12, 93, 2115, 9, 93, 1, 93, 3, 93, 2118, 8, 93, 3, 93, 2120, 8, 93, 1, 94, 1, 94, 5, 94, 2124, 8, 94, 10, 94, 12, 94, 2127, 9, 94, 1, 94, 1, 94, 5, 94, 2131, 8, 94, 10, 94, 12, 94, 2134, 9, 94, 1, 94, 3, 94, 2137, 8, 94, 1, 94, 5, 94, 2140, 8, 94, 10, 94, 12, 94, 2143, 9, 94, 1, 94, 3, 94, 2146, 8, 94, 1, 95, 1, 95, 3, 95, 2150, 8, 95, 1, 95, 1, 95, 5, 95, 2154, 8, 95, 10, 95, 12, 95, 2157, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 3, 96, 2163, 8, 96, 1, 97, 1, 97, 1, 97, 5, 97, 2168, 8, 97, 10, 97, 12, 97, 2171, 9, 97, 1, 97, 1, 97, 5, 97, 2175, 8, 97, 10, 97, 12, 97, 2178, 9, 97, 1, 97, 1, 97, 3, 97, 2182, 8, 97, 1, 97, 3, 97, 2185, 8, 97, 1, 98, 1, 98, 3, 98, 2189, 8, 98, 1, 99, 1, 99, 5, 99, 2193, 8, 99, 10, 99, 12, 99, 2196, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2202, 8, 99, 10, 99, 12, 99, 2205, 9, 99, 1, 99, 3, 99, 2208, 8, 99, 1, 99, 3, 99, 2211, 8, 99, 1, 99, 5, 99, 2214, 8, 99, 10, 99, 12, 99, 2217, 9, 99, 1, 99, 1, 99, 5, 99, 2221, 8, 99, 10, 99, 12, 99, 2224, 9, 99, 1, 99, 3, 99, 2227, 8, 99, 3, 99, 2229, 8, 99, 1, 100, 1, 100, 3, 100, 2233, 8, 100, 1, 101, 1, 101, 5, 101, 2237, 8, 101, 10, 101, 12, 101, 2240, 9, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2246, 8, 101, 1, 101, 5, 101, 2249, 8, 101, 10, 101, 12, 101, 2252, 9, 101, 1, 101, 1, 101, 5, 101, 2256, 8, 101, 10, 101, 12, 101, 2259, 9, 101, 1, 101, 1, 101, 5, 101, 2263, 8, 101, 10, 101, 12, 101, 2266, 9, 101, 5, 101, 2268, 8, 101, 10, 101, 12, 101, 2271, 9, 101, 1, 101, 5, 101, 2274, 8, 101, 10, 101, 12, 101, 2277, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 5, 102, 2283, 8, 102, 10, 102, 12, 102, 2286, 9, 102, 1, 102, 1, 102, 5, 102, 2290, 8, 102, 10, 102, 12, 102, 2293, 9, 102, 1, 102, 5, 102, 2296, 8, 102, 10, 102, 12, 102, 2299, 9, 102, 1, 102, 5, 102, 2302, 8, 102, 10, 102, 12, 102, 2305, 9, 102, 1, 102, 1, 102, 5, 102, 2309, 8, 102, 10, 102, 12, 102, 2312, 9, 102, 1, 102, 1, 102, 3, 102, 2316, 8, 102, 1, 102, 1, 102, 5, 102, 2320, 8, 102, 10, 102, 12, 102, 2323, 9, 102, 1, 102, 1, 102, 5, 102, 2327, 8, 102, 10, 102, 12, 102, 2330, 9, 102, 1, 102, 3, 102, 2333, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2338, 8, 103, 1, 104, 1, 104, 5, 104, 2342, 8, 104, 10, 104, 12, 104, 2345, 9, 104, 1, 104, 1, 104, 1, 105, 1, 105, 5, 105, 2351, 8, 105, 10, 105, 12, 105, 2354, 9, 105, 1, 105, 1, 105, 1, 106, 1, 106, 5, 106, 2360, 8, 106, 10, 106, 12, 106, 2363, 9, 106, 1, 106, 1, 106, 5, 106, 2367, 8, 106, 10, 106, 12, 106, 2370, 9, 106, 1, 106, 5, 106, 2373, 8, 106, 10, 106, 12, 106, 2376, 9, 106, 1, 106, 5, 106, 2379, 8, 106, 10, 106, 12, 106, 2382, 9, 106, 1, 106, 3, 106, 2385, 8, 106, 1, 107, 1, 107, 5, 107, 2389, 8, 107, 10, 107, 12, 107, 2392, 9, 107, 1, 107, 1, 107, 5, 107, 2396, 8, 107, 10, 107, 12, 107, 2399, 9, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 5, 107, 2406, 8, 107, 10, 107, 12, 107, 2409, 9, 107, 1, 107, 1, 107, 1, 108, 1, 108, 5, 108, 2415, 8, 108, 10, 108, 12, 108, 2418, 9, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 3, 109, 2425, 8, 109, 1, 110, 1, 110, 5, 110, 2429, 8, 110, 10, 110, 12, 110, 2432, 9, 110, 1, 110, 1, 110, 5, 110, 2436, 8, 110, 10, 110, 12, 110, 2439, 9, 110, 1, 110, 1, 110, 3, 110, 2443, 8, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2449, 8, 110, 10, 110, 12, 110, 2452, 9, 110, 1, 110, 3, 110, 2455, 8, 110, 1, 111, 1, 111, 5, 111, 2459, 8, 111, 10, 111, 12, 111, 2462, 9, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 2468, 8, 111, 10, 111, 12, 111, 2471, 9, 111, 1, 111, 3, 111, 2474, 8, 111, 1, 112, 1, 112, 5, 112, 2478, 8, 112, 10, 112, 12, 112, 2481, 9, 112, 1, 112, 3, 112, 2484, 8, 112, 1, 112, 5, 112, 2487, 8, 112, 10, 112, 12, 112, 2490, 9, 112, 1, 112, 1, 112, 5, 112, 2494, 8, 112, 10, 112, 12, 112, 2497, 9, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 5, 113, 2505, 8, 113, 10, 113, 12, 113, 2508, 9, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2513, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2519, 8, 113, 1, 114, 1, 114, 1, 114, 5, 114, 2524, 8, 114, 10, 114, 12, 114, 2527, 9, 114, 5, 114, 2529, 8, 114, 10, 114, 12, 114, 2532, 9, 114, 3, 114, 2534, 8, 114, 1, 114, 5, 114, 2537, 8, 114, 10, 114, 12, 114, 2540, 9, 114, 1, 114, 1, 114, 5, 114, 2544, 8, 114, 10, 114, 12, 114, 2547, 9, 114, 1, 114, 1, 114, 3, 114, 2551, 8, 114, 1, 114, 1, 114, 5, 114, 2555, 8, 114, 10, 114, 12, 114, 2558, 9, 114, 1, 114, 1, 114, 5, 114, 2562, 8, 114, 10, 114, 12, 114, 2565, 9, 114, 1, 114, 3, 114, 2568, 8, 114, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 2593, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 5, 124, 2602, 8, 124, 10, 124, 12, 124, 2605, 9, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2610, 8, 124, 1, 125, 1, 125, 1, 125, 3, 125, 2615, 8, 125, 1, 126, 1, 126, 4, 126, 2619, 8, 126, 11, 126, 12, 126, 2620, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2632, 8, 127, 1, 127, 5, 127, 2635, 8, 127, 10, 127, 12, 127, 2638, 9, 127, 1, 128, 1, 128, 1, 129, 1, 129, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 5, 137, 2660, 8, 137, 10, 137, 12, 137, 2663, 9, 137, 1, 138, 1, 138, 3, 138, 2667, 8, 138, 1, 138, 5, 138, 2670, 8, 138, 10, 138, 12, 138, 2673, 9, 138, 1, 139, 1, 139, 5, 139, 2677, 8, 139, 10, 139, 12, 139, 2680, 9, 139, 1, 139, 1, 139, 5, 139, 2684, 8, 139, 10, 139, 12, 139, 2687, 9, 139, 1, 139, 1, 139, 1, 139, 1, 139, 5, 139, 2693, 8, 139, 10, 139, 12, 139, 2696, 9, 139, 1, 139, 1, 139, 5, 139, 2700, 8, 139, 10, 139, 12, 139, 2703, 9, 139, 1, 139, 5, 139, 2706, 8, 139, 10, 139, 12, 139, 2709, 9, 139, 1, 139, 5, 139, 2712, 8, 139, 10, 139, 12, 139, 2715, 9, 139, 1, 139, 3, 139, 2718, 8, 139, 1, 139, 5, 139, 2721, 8, 139, 10, 139, 12, 139, 2724, 9, 139, 1, 139, 3, 139, 2727, 8, 139, 3, 139, 2729, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 4, 140, 2735, 8, 140, 11, 140, 12, 140, 2736, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 4, 140, 2744, 8, 140, 11, 140, 12, 140, 2745, 1, 140, 1, 140, 3, 140, 2750, 8, 140, 1, 141, 1, 141, 1, 142, 1, 142, 3, 142, 2756, 8, 142, 1, 142, 3, 142, 2759, 8, 142, 1, 143, 1, 143, 5, 143, 2763, 8, 143, 10, 143, 12, 143, 2766, 9, 143, 1, 143, 1, 143, 5, 143, 2770, 8, 143, 10, 143, 12, 143, 2773, 9, 143, 1, 144, 1, 144, 1, 145, 4, 145, 2778, 8, 145, 11, 145, 12, 145, 2779, 1, 145, 5, 145, 2783, 8, 145, 10, 145, 12, 145, 2786, 9, 145, 1, 145, 1, 145, 5, 145, 2790, 8, 145, 10, 145, 12, 145, 2793, 9, 145, 3, 145, 2795, 8, 145, 1, 146, 1, 146, 1, 146, 0, 0, 147, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 0, 25, 1, 0, 59, 60, 1, 0, 63, 64, 2, 0, 27, 27, 67, 67, 1, 0, 156, 158, 1, 0, 162, 164, 2, 0, 53, 53, 84, 84, 1, 0, 36, 37, 1, 0, 27, 32, 2, 0, 47, 48, 50, 51, 1, 0, 43, 46, 2, 0, 89, 89, 91, 91, 2, 0, 88, 88, 90, 90, 1, 0, 18, 19, 1, 0, 15, 17, 3, 0, 25, 25, 49, 49, 87, 87, 1, 0, 108, 112, 2, 0, 119, 119, 124, 124, 1, 0, 104, 107, 2, 0, 89, 89, 92, 92, 1, 0, 113, 118, 1, 0, 120, 122, 1, 0, 125, 127, 3, 0, 56, 56, 93, 96, 99, 102, 8, 0, 58, 58, 66, 69, 73, 73, 78, 79, 92, 92, 97, 98, 103, 128, 140, 140, 2, 0, 5, 5, 26, 26, 3145, 0, 297, 1, 0, 0, 0, 2, 328, 1, 0, 0, 0, 4, 357, 1, 0, 0, 0, 6, 363, 1, 0, 0, 0, 8, 383, 1, 0, 0, 0, 10, 395, 1, 0, 0, 0, 12, 400, 1, 0, 0, 0, 14, 403, 1, 0, 0, 0, 16, 413, 1, 0, 0, 0, 18, 421, 1, 0, 0, 0, 20, 424, 1, 0, 0, 0, 22, 494, 1, 0, 0, 0, 24, 507, 1, 0, 0, 0, 26, 524, 1, 0, 0, 0, 28, 539, 1, 0, 0, 0, 30, 571, 1, 0, 0, 0, 32, 573, 1, 0, 0, 0, 34, 576, 1, 0, 0, 0, 36, 592, 1, 0, 0, 0, 38, 621, 1, 0, 0, 0, 40, 628, 1, 0, 0, 0, 42, 638, 1, 0, 0, 0, 44, 689, 1, 0, 0, 0, 46, 691, 1, 0, 0, 0, 48, 737, 1, 0, 0, 0, 50, 747, 1, 0, 0, 0, 52, 779, 1, 0, 0, 0, 54, 875, 1, 0, 0, 0, 56, 892, 1, 0, 0, 0, 58, 899, 1, 0, 0, 0, 60, 904, 1, 0, 0, 0, 62, 920, 1, 0, 0, 0, 64, 923, 1, 0, 0, 0, 66, 968, 1, 0, 0, 0, 68, 1016, 1, 0, 0, 0, 70, 1106, 1, 0, 0, 0, 72, 1117, 1, 0, 0, 0, 74, 1171, 1, 0, 0, 0, 76, 1208, 1, 0, 0, 0, 78, 1211, 1, 0, 0, 0, 80, 1245, 1, 0, 0, 0, 82, 1290, 1, 0, 0, 0, 84, 1319, 1, 0, 0, 0, 86, 1335, 1, 0, 0, 0, 88, 1339, 1, 0, 0, 0, 90, 1345, 1, 0, 0, 0, 92, 1364, 1, 0, 0, 0, 94, 1380, 1, 0, 0, 0, 96, 1401, 1, 0, 0, 0, 98, 1403, 1, 0, 0, 0, 100, 1423, 1, 0, 0, 0, 102, 1433, 1, 0, 0, 0, 104, 1483, 1, 0, 0, 0, 106, 1513, 1, 0, 0, 0, 108, 1532, 1, 0, 0, 0, 110, 1539, 1, 0, 0, 0, 112, 1560, 1, 0, 0, 0, 114, 1565, 1, 0, 0, 0, 116, 1579, 1, 0, 0, 0, 118, 1588, 1, 0, 0, 0, 120, 1597, 1, 0, 0, 0, 122, 1617, 1, 0, 0, 0, 124, 1637, 1, 0, 0, 0, 126, 1652, 1, 0, 0, 0, 128, 1664, 1, 0, 0, 0, 130, 1689, 1, 0, 0, 0, 132, 1709, 1, 0, 0, 0, 134, 1724, 1, 0, 0, 0, 136, 1738, 1, 0, 0, 0, 138, 1753, 1, 0, 0, 0, 140, 1768, 1, 0, 0, 0, 142, 1786, 1, 0, 0, 0, 144, 1793, 1, 0, 0, 0, 146, 1815, 1, 0, 0, 0, 148, 1817, 1, 0, 0, 0, 150, 1843, 1, 0, 0, 0, 152, 1848, 1, 0, 0, 0, 154, 1862, 1, 0, 0, 0, 156, 1875, 1, 0, 0, 0, 158, 1897, 1, 0, 0, 0, 160, 1942, 1, 0, 0, 0, 162, 1945, 1, 0, 0, 0, 164, 1963, 1, 0, 0, 0, 166, 1985, 1, 0, 0, 0, 168, 1989, 1, 0, 0, 0, 170, 1991, 1, 0, 0, 0, 172, 2001, 1, 0, 0, 0, 174, 2013, 1, 0, 0, 0, 176, 2015, 1, 0, 0, 0, 178, 2019, 1, 0, 0, 0, 180, 2021, 1, 0, 0, 0, 182, 2028, 1, 0, 0, 0, 184, 2080, 1, 0, 0, 0, 186, 2119, 1, 0, 0, 0, 188, 2121, 1, 0, 0, 0, 190, 2147, 1, 0, 0, 0, 192, 2160, 1, 0, 0, 0, 194, 2164, 1, 0, 0, 0, 196, 2188, 1, 0, 0, 0, 198, 2190, 1, 0, 0, 0, 200, 2232, 1, 0, 0, 0, 202, 2234, 1, 0, 0, 0, 204, 2332, 1, 0, 0, 0, 206, 2337, 1, 0, 0, 0, 208, 2339, 1, 0, 0, 0, 210, 2348, 1, 0, 0, 0, 212, 2357, 1, 0, 0, 0, 214, 2386, 1, 0, 0, 0, 216, 2412, 1, 0, 0, 0, 218, 2424, 1, 0, 0, 0, 220, 2426, 1, 0, 0, 0, 222, 2456, 1, 0, 0, 0, 224, 2475, 1, 0, 0, 0, 226, 2518, 1, 0, 0, 0, 228, 2567, 1, 0, 0, 0, 230, 2569, 1, 0, 0, 0, 232, 2571, 1, 0, 0, 0, 234, 2573, 1, 0, 0, 0, 236, 2575, 1, 0, 0, 0, 238, 2577, 1, 0, 0, 0, 240, 2579, 1, 0, 0, 0, 242, 2581, 1, 0, 0, 0, 244, 2583, 1, 0, 0, 0, 246, 2592, 1, 0, 0, 0, 248, 2609, 1, 0, 0, 0, 250, 2614, 1, 0, 0, 0, 252, 2618, 1, 0, 0, 0, 254, 2631, 1, 0, 0, 0, 256, 2639, 1, 0, 0, 0, 258, 2641, 1, 0, 0, 0, 260, 2643, 1, 0, 0, 0, 262, 2645, 1, 0, 0, 0, 264, 2647, 1, 0, 0, 0, 266, 2649, 1, 0, 0, 0, 268, 2651, 1, 0, 0, 0, 270, 2653, 1, 0, 0, 0, 272, 2655, 1, 0, 0, 0, 274, 2657, 1, 0, 0, 0, 276, 2666, 1, 0, 0, 0, 278, 2728, 1, 0, 0, 0, 280, 2749, 1, 0, 0, 0, 282, 2751, 1, 0, 0, 0, 284, 2753, 1, 0, 0, 0, 286, 2760, 1, 0, 0, 0, 288, 2774, 1, 0, 0, 0, 290, 2794, 1, 0, 0, 0, 292, 2796, 1, 0, 0, 0, 294, 296, 5, 5, 0, 0, 295, 294, 1, 0, 0, 0, 296, 299, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 297, 298, 1, 0, 0, 0, 298, 300, 1, 0, 0, 0, 299, 297, 1, 0, 0, 0, 300, 304, 3, 4, 2, 0, 301, 303, 3, 292, 146, 0, 302, 301, 1, 0, 0, 0, 303, 306, 1, 0, 0, 0, 304, 302, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, 305, 321, 1, 0, 0, 0, 306, 304, 1, 0, 0, 0, 307, 318, 3, 18, 9, 0, 308, 310, 3, 292, 146, 0, 309, 308, 1, 0, 0, 0, 310, 311, 1, 0, 0, 0, 311, 309, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 314, 1, 0, 0, 0, 313, 315, 3, 18, 9, 0, 314, 313, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 317, 1, 0, 0, 0, 316, 309, 1, 0, 0, 0, 317, 320, 1, 0, 0, 0, 318, 316, 1, 0, 0, 0, 318, 319, 1, 0, 0, 0, 319, 322, 1, 0, 0, 0, 320, 318, 1, 0, 0, 0, 321, 307, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 323, 1, 0, 0, 0, 323, 324, 5, 0, 0, 1, 324, 1, 1, 0, 0, 0, 325, 327, 5, 5, 0, 0, 326, 325, 1, 0, 0, 0, 327, 330, 1, 0, 0, 0, 328, 326, 1, 0, 0, 0, 328, 329, 1, 0, 0, 0, 329, 331, 1, 0, 0, 0, 330, 328, 1, 0, 0, 0, 331, 335, 3, 4, 2, 0, 332, 334, 3, 292, 146, 0, 333, 332, 1, 0, 0, 0, 334, 337, 1, 0, 0, 0, 335, 333, 1, 0, 0, 0, 335, 336, 1, 0, 0, 0, 336, 352, 1, 0, 0, 0, 337, 335, 1, 0, 0, 0, 338, 349, 3, 118, 59, 0, 339, 341, 3, 292, 146, 0, 340, 339, 1, 0, 0, 0, 341, 342, 1, 0, 0, 0, 342, 340, 1, 0, 0, 0, 342, 343, 1, 0, 0, 0, 343, 345, 1, 0, 0, 0, 344, 346, 3, 118, 59, 0, 345, 344, 1, 0, 0, 0, 345, 346, 1, 0, 0, 0, 346, 348, 1, 0, 0, 0, 347, 340, 1, 0, 0, 0, 348, 351, 1, 0, 0, 0, 349, 347, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 353, 1, 0, 0, 0, 351, 349, 1, 0, 0, 0, 352, 338, 1, 0, 0, 0, 352, 353, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 355, 5, 0, 0, 1, 355, 3, 1, 0, 0, 0, 356, 358, 3, 6, 3, 0, 357, 356, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 360, 3, 10, 5, 0, 360, 361, 3, 12, 6, 0, 361, 5, 1, 0, 0, 0, 362, 364, 3, 8, 4, 0, 363, 362, 1, 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 363, 1, 0, 0, 0, 365, 366, 1, 0, 0, 0, 366, 7, 1, 0, 0, 0, 367, 368, 5, 56, 0, 0, 368, 378, 5, 25, 0, 0, 369, 371, 5, 11, 0, 0, 370, 372, 3, 284, 142, 0, 371, 370, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 371, 1, 0, 0, 0, 373, 374, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 376, 5, 12, 0, 0, 376, 379, 1, 0, 0, 0, 377, 379, 3, 284, 142, 0, 378, 369, 1, 0, 0, 0, 378, 377, 1, 0, 0, 0, 379, 381, 1, 0, 0, 0, 380, 382, 3, 290, 145, 0, 381, 380, 1, 0, 0, 0, 381, 382, 1, 0, 0, 0, 382, 384, 1, 0, 0, 0, 383, 367, 1, 0, 0, 0, 384, 385, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 9, 1, 0, 0, 0, 387, 389, 3, 252, 126, 0, 388, 387, 1, 0, 0, 0, 388, 389, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 391, 5, 57, 0, 0, 391, 393, 3, 286, 143, 0, 392, 394, 3, 290, 145, 0, 393, 392, 1, 0, 0, 0, 393, 394, 1, 0, 0, 0, 394, 396, 1, 0, 0, 0, 395, 388, 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 11, 1, 0, 0, 0, 397, 399, 3, 14, 7, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 13, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 5, 58, 0, 0, 404, 408, 3, 286, 143, 0, 405, 406, 5, 7, 0, 0, 406, 409, 5, 15, 0, 0, 407, 409, 3, 16, 8, 0, 408, 405, 1, 0, 0, 0, 408, 407, 1, 0, 0, 0, 408, 409, 1, 0, 0, 0, 409, 411, 1, 0, 0, 0, 410, 412, 3, 290, 145, 0, 411, 410, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 15, 1, 0, 0, 0, 413, 414, 5, 87, 0, 0, 414, 415, 3, 288, 144, 0, 415, 17, 1, 0, 0, 0, 416, 422, 3, 20, 10, 0, 417, 422, 3, 64, 32, 0, 418, 422, 3, 52, 26, 0, 419, 422, 3, 68, 34, 0, 420, 422, 3, 78, 39, 0, 421, 416, 1, 0, 0, 0, 421, 417, 1, 0, 0, 0, 421, 418, 1, 0, 0, 0, 421, 419, 1, 0, 0, 0, 421, 420, 1, 0, 0, 0, 422, 19, 1, 0, 0, 0, 423, 425, 3, 252, 126, 0, 424, 423, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 430, 7, 0, 0, 0, 427, 429, 5, 5, 0, 0, 428, 427, 1, 0, 0, 0, 429, 432, 1, 0, 0, 0, 430, 428, 1, 0, 0, 0, 430, 431, 1, 0, 0, 0, 431, 433, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 433, 441, 3, 288, 144, 0, 434, 436, 5, 5, 0, 0, 435, 434, 1, 0, 0, 0, 436, 439, 1, 0, 0, 0, 437, 435, 1, 0, 0, 0, 437, 438, 1, 0, 0, 0, 438, 440, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 440, 442, 3, 80, 40, 0, 441, 437, 1, 0, 0, 0, 441, 442, 1, 0, 0, 0, 442, 450, 1, 0, 0, 0, 443, 445, 5, 5, 0, 0, 444, 443, 1, 0, 0, 0, 445, 448, 1, 0, 0, 0, 446, 444, 1, 0, 0, 0, 446, 447, 1, 0, 0, 0, 447, 449, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 449, 451, 3, 22, 11, 0, 450, 446, 1, 0, 0, 0, 450, 451, 1, 0, 0, 0, 451, 466, 1, 0, 0, 0, 452, 454, 5, 5, 0, 0, 453, 452, 1, 0, 0, 0, 454, 457, 1, 0, 0, 0, 455, 453, 1, 0, 0, 0, 455, 456, 1, 0, 0, 0, 456, 458, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 458, 462, 5, 25, 0, 0, 459, 461, 5, 5, 0, 0, 460, 459, 1, 0, 0, 0, 461, 464, 1, 0, 0, 0, 462, 460, 1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 465, 1, 0, 0, 0, 464, 462, 1, 0, 0, 0, 465, 467, 3, 28, 14, 0, 466, 455, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 475, 1, 0, 0, 0, 468, 470, 5, 5, 0, 0, 469, 468, 1, 0, 0, 0, 470, 473, 1, 0, 0, 0, 471, 469, 1, 0, 0, 0, 471, 472, 1, 0, 0, 0, 472, 474, 1, 0, 0, 0, 473, 471, 1, 0, 0, 0, 474, 476, 3, 104, 52, 0, 475, 471, 1, 0, 0, 0, 475, 476, 1, 0, 0, 0, 476, 491, 1, 0, 0, 0, 477, 479, 5, 5, 0, 0, 478, 477, 1, 0, 0, 0, 479, 482, 1, 0, 0, 0, 480, 478, 1, 0, 0, 0, 480, 481, 1, 0, 0, 0, 481, 483, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 483, 492, 3, 36, 18, 0, 484, 486, 5, 5, 0, 0, 485, 484, 1, 0, 0, 0, 486, 489, 1, 0, 0, 0, 487, 485, 1, 0, 0, 0, 487, 488, 1, 0, 0, 0, 488, 490, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 492, 3, 46, 23, 0, 491, 480, 1, 0, 0, 0, 491, 487, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 21, 1, 0, 0, 0, 493, 495, 3, 252, 126, 0, 494, 493, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 503, 1, 0, 0, 0, 496, 500, 5, 66, 0, 0, 497, 499, 5, 5, 0, 0, 498, 497, 1, 0, 0, 0, 499, 502, 1, 0, 0, 0, 500, 498, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501, 504, 1, 0, 0, 0, 502, 500, 1, 0, 0, 0, 503, 496, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 505, 1, 0, 0, 0, 505, 506, 3, 24, 12, 0, 506, 23, 1, 0, 0, 0, 507, 519, 5, 9, 0, 0, 508, 513, 3, 26, 13, 0, 509, 510, 5, 8, 0, 0, 510, 512, 3, 26, 13, 0, 511, 509, 1, 0, 0, 0, 512, 515, 1, 0, 0, 0, 513, 511, 1, 0, 0, 0, 513, 514, 1, 0, 0, 0, 514, 517, 1, 0, 0, 0, 515, 513, 1, 0, 0, 0, 516, 518, 5, 8, 0, 0, 517, 516, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 520, 1, 0, 0, 0, 519, 508, 1, 0, 0, 0, 519, 520, 1, 0, 0, 0, 520, 521, 1, 0, 0, 0, 521, 522, 5, 10, 0, 0, 522, 25, 1, 0, 0, 0, 523, 525, 3, 252, 126, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 527, 1, 0, 0, 0, 526, 528, 7, 1, 0, 0, 527, 526, 1, 0, 0, 0, 527, 528, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 530, 3, 288, 144, 0, 530, 531, 5, 25, 0, 0, 531, 534, 3, 84, 42, 0, 532, 533, 5, 27, 0, 0, 533, 535, 3, 118, 59, 0, 534, 532, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 27, 1, 0, 0, 0, 536, 538, 3, 276, 138, 0, 537, 536, 1, 0, 0, 0, 538, 541, 1, 0, 0, 0, 539, 537, 1, 0, 0, 0, 539, 540, 1, 0, 0, 0, 540, 542, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 542, 565, 3, 30, 15, 0, 543, 545, 5, 5, 0, 0, 544, 543, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 549, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 553, 5, 8, 0, 0, 550, 552, 5, 5, 0, 0, 551, 550, 1, 0, 0, 0, 552, 555, 1, 0, 0, 0, 553, 551, 1, 0, 0, 0, 553, 554, 1, 0, 0, 0, 554, 559, 1, 0, 0, 0, 555, 553, 1, 0, 0, 0, 556, 558, 3, 276, 138, 0, 557, 556, 1, 0, 0, 0, 558, 561, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 559, 560, 1, 0, 0, 0, 560, 562, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, 562, 564, 3, 30, 15, 0, 563, 546, 1, 0, 0, 0, 564, 567, 1, 0, 0, 0, 565, 563, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 29, 1, 0, 0, 0, 567, 565, 1, 0, 0, 0, 568, 572, 3, 32, 16, 0, 569, 572, 3, 98, 49, 0, 570, 572, 3, 34, 17, 0, 571, 568, 1, 0, 0, 0, 571, 569, 1, 0, 0, 0, 571, 570, 1, 0, 0, 0, 572, 31, 1, 0, 0, 0, 573, 574, 3, 98, 49, 0, 574, 575, 3, 150, 75, 0, 575, 33, 1, 0, 0, 0, 576, 580, 3, 98, 49, 0, 577, 579, 5, 5, 0, 0, 578, 577, 1, 0, 0, 0, 579, 582, 1, 0, 0, 0, 580, 578, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 583, 1, 0, 0, 0, 582, 580, 1, 0, 0, 0, 583, 587, 5, 67, 0, 0, 584, 586, 5, 5, 0, 0, 585, 584, 1, 0, 0, 0, 586, 589, 1, 0, 0, 0, 587, 585, 1, 0, 0, 0, 587, 588, 1, 0, 0, 0, 588, 590, 1, 0, 0, 0, 589, 587, 1, 0, 0, 0, 590, 591, 3, 118, 59, 0, 591, 35, 1, 0, 0, 0, 592, 596, 5, 13, 0, 0, 593, 595, 5, 5, 0, 0, 594, 593, 1, 0, 0, 0, 595, 598, 1, 0, 0, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 602, 1, 0, 0, 0, 598, 596, 1, 0, 0, 0, 599, 601, 3, 38, 19, 0, 600, 599, 1, 0, 0, 0, 601, 604, 1, 0, 0, 0, 602, 600, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, 603, 608, 1, 0, 0, 0, 604, 602, 1, 0, 0, 0, 605, 607, 5, 5, 0, 0, 606, 605, 1, 0, 0, 0, 607, 610, 1, 0, 0, 0, 608, 606, 1, 0, 0, 0, 608, 609, 1, 0, 0, 0, 609, 611, 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 611, 612, 5, 14, 0, 0, 612, 37, 1, 0, 0, 0, 613, 622, 3, 20, 10, 0, 614, 622, 3, 52, 26, 0, 615, 622, 3, 64, 32, 0, 616, 622, 3, 66, 33, 0, 617, 622, 3, 68, 34, 0, 618, 622, 3, 40, 20, 0, 619, 622, 3, 42, 21, 0, 620, 622, 3, 78, 39, 0, 621, 613, 1, 0, 0, 0, 621, 614, 1, 0, 0, 0, 621, 615, 1, 0, 0, 0, 621, 616, 1, 0, 0, 0, 621, 617, 1, 0, 0, 0, 621, 618, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 621, 620, 1, 0, 0, 0, 622, 624, 1, 0, 0, 0, 623, 625, 3, 292, 146, 0, 624, 623, 1, 0, 0, 0, 625, 626, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 39, 1, 0, 0, 0, 628, 632, 5, 69, 0, 0, 629, 631, 5, 5, 0, 0, 630, 629, 1, 0, 0, 0, 631, 634, 1, 0, 0, 0, 632, 630, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 635, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 635, 636, 3, 108, 54, 0, 636, 41, 1, 0, 0, 0, 637, 639, 3, 252, 126, 0, 638, 637, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 644, 5, 66, 0, 0, 641, 643, 5, 5, 0, 0, 642, 641, 1, 0, 0, 0, 643, 646, 1, 0, 0, 0, 644, 642, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 647, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 647, 662, 3, 54, 27, 0, 648, 650, 5, 5, 0, 0, 649, 648, 1, 0, 0, 0, 650, 653, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 651, 652, 1, 0, 0, 0, 652, 654, 1, 0, 0, 0, 653, 651, 1, 0, 0, 0, 654, 658, 5, 25, 0, 0, 655, 657, 5, 5, 0, 0, 656, 655, 1, 0, 0, 0, 657, 660, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 661, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 663, 3, 44, 22, 0, 662, 651, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 667, 1, 0, 0, 0, 664, 666, 5, 5, 0, 0, 665, 664, 1, 0, 0, 0, 666, 669, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 671, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 670, 672, 3, 108, 54, 0, 671, 670, 1, 0, 0, 0, 671, 672, 1, 0, 0, 0, 672, 43, 1, 0, 0, 0, 673, 677, 5, 70, 0, 0, 674, 676, 5, 5, 0, 0, 675, 674, 1, 0, 0, 0, 676, 679, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 677, 678, 1, 0, 0, 0, 678, 680, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 690, 3, 156, 78, 0, 681, 685, 5, 71, 0, 0, 682, 684, 5, 5, 0, 0, 683, 682, 1, 0, 0, 0, 684, 687, 1, 0, 0, 0, 685, 683, 1, 0, 0, 0, 685, 686, 1, 0, 0, 0, 686, 688, 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 688, 690, 3, 156, 78, 0, 689, 673, 1, 0, 0, 0, 689, 681, 1, 0, 0, 0, 690, 45, 1, 0, 0, 0, 691, 695, 5, 13, 0, 0, 692, 694, 5, 5, 0, 0, 693, 692, 1, 0, 0, 0, 694, 697, 1, 0, 0, 0, 695, 693, 1, 0, 0, 0, 695, 696, 1, 0, 0, 0, 696, 699, 1, 0, 0, 0, 697, 695, 1, 0, 0, 0, 698, 700, 3, 48, 24, 0, 699, 698, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 720, 1, 0, 0, 0, 701, 703, 5, 5, 0, 0, 702, 701, 1, 0, 0, 0, 703, 706, 1, 0, 0, 0, 704, 702, 1, 0, 0, 0, 704, 705, 1, 0, 0, 0, 705, 707, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 707, 711, 5, 26, 0, 0, 708, 710, 5, 5, 0, 0, 709, 708, 1, 0, 0, 0, 710, 713, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 717, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 716, 3, 38, 19, 0, 715, 714, 1, 0, 0, 0, 716, 719, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 717, 718, 1, 0, 0, 0, 718, 721, 1, 0, 0, 0, 719, 717, 1, 0, 0, 0, 720, 704, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 725, 1, 0, 0, 0, 722, 724, 5, 5, 0, 0, 723, 722, 1, 0, 0, 0, 724, 727, 1, 0, 0, 0, 725, 723, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 728, 1, 0, 0, 0, 727, 725, 1, 0, 0, 0, 728, 729, 5, 14, 0, 0, 729, 47, 1, 0, 0, 0, 730, 734, 3, 50, 25, 0, 731, 733, 5, 5, 0, 0, 732, 731, 1, 0, 0, 0, 733, 736, 1, 0, 0, 0, 734, 732, 1, 0, 0, 0, 734, 735, 1, 0, 0, 0, 735, 738, 1, 0, 0, 0, 736, 734, 1, 0, 0, 0, 737, 730, 1, 0, 0, 0, 738, 739, 1, 0, 0, 0, 739, 737, 1, 0, 0, 0, 739, 740, 1, 0, 0, 0, 740, 742, 1, 0, 0, 0, 741, 743, 5, 26, 0, 0, 742, 741, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 49, 1, 0, 0, 0, 744, 746, 3, 276, 138, 0, 745, 744, 1, 0, 0, 0, 746, 749, 1, 0, 0, 0, 747, 745, 1, 0, 0, 0, 747, 748, 1, 0, 0, 0, 748, 750, 1, 0, 0, 0, 749, 747, 1, 0, 0, 0, 750, 758, 3, 288, 144, 0, 751, 753, 5, 5, 0, 0, 752, 751, 1, 0, 0, 0, 753, 756, 1, 0, 0, 0, 754, 752, 1, 0, 0, 0, 754, 755, 1, 0, 0, 0, 755, 757, 1, 0, 0, 0, 756, 754, 1, 0, 0, 0, 757, 759, 3, 156, 78, 0, 758, 754, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 767, 1, 0, 0, 0, 760, 762, 5, 5, 0, 0, 761, 760, 1, 0, 0, 0, 762, 765, 1, 0, 0, 0, 763, 761, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 766, 1, 0, 0, 0, 765, 763, 1, 0, 0, 0, 766, 768, 3, 36, 18, 0, 767, 763, 1, 0, 0, 0, 767, 768, 1, 0, 0, 0, 768, 776, 1, 0, 0, 0, 769, 771, 5, 5, 0, 0, 770, 769, 1, 0, 0, 0, 771, 774, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 772, 773, 1, 0, 0, 0, 773, 775, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 775, 777, 5, 8, 0, 0, 776, 772, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 51, 1, 0, 0, 0, 778, 780, 3, 252, 126, 0, 779, 778, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 797, 5, 61, 0, 0, 782, 784, 5, 5, 0, 0, 783, 782, 1, 0, 0, 0, 784, 787, 1, 0, 0, 0, 785, 783, 1, 0, 0, 0, 785, 786, 1, 0, 0, 0, 786, 788, 1, 0, 0, 0, 787, 785, 1, 0, 0, 0, 788, 792, 3, 84, 42, 0, 789, 791, 5, 5, 0, 0, 790, 789, 1, 0, 0, 0, 791, 794, 1, 0, 0, 0, 792, 790, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 795, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 795, 796, 5, 7, 0, 0, 796, 798, 1, 0, 0, 0, 797, 785, 1, 0, 0, 0, 797, 798, 1, 0, 0, 0, 798, 806, 1, 0, 0, 0, 799, 801, 5, 5, 0, 0, 800, 799, 1, 0, 0, 0, 801, 804, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 802, 803, 1, 0, 0, 0, 803, 805, 1, 0, 0, 0, 804, 802, 1, 0, 0, 0, 805, 807, 3, 80, 40, 0, 806, 802, 1, 0, 0, 0, 806, 807, 1, 0, 0, 0, 807, 823, 1, 0, 0, 0, 808, 810, 5, 5, 0, 0, 809, 808, 1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 814, 1, 0, 0, 0, 813, 811, 1, 0, 0, 0, 814, 818, 3, 60, 30, 0, 815, 817, 5, 5, 0, 0, 816, 815, 1, 0, 0, 0, 817, 820, 1, 0, 0, 0, 818, 816, 1, 0, 0, 0, 818, 819, 1, 0, 0, 0, 819, 821, 1, 0, 0, 0, 820, 818, 1, 0, 0, 0, 821, 822, 5, 7, 0, 0, 822, 824, 1, 0, 0, 0, 823, 811, 1, 0, 0, 0, 823, 824, 1, 0, 0, 0, 824, 832, 1, 0, 0, 0, 825, 827, 5, 5, 0, 0, 826, 825, 1, 0, 0, 0, 827, 830, 1, 0, 0, 0, 828, 826, 1, 0, 0, 0, 828, 829, 1, 0, 0, 0, 829, 831, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 831, 833, 3, 286, 143, 0, 832, 828, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 837, 1, 0, 0, 0, 834, 836, 5, 5, 0, 0, 835, 834, 1, 0, 0, 0, 836, 839, 1, 0, 0, 0, 837, 835, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 840, 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 840, 855, 3, 54, 27, 0, 841, 843, 5, 5, 0, 0, 842, 841, 1, 0, 0, 0, 843, 846, 1, 0, 0, 0, 844, 842, 1, 0, 0, 0, 844, 845, 1, 0, 0, 0, 845, 847, 1, 0, 0, 0, 846, 844, 1, 0, 0, 0, 847, 851, 5, 25, 0, 0, 848, 850, 5, 5, 0, 0, 849, 848, 1, 0, 0, 0, 850, 853, 1, 0, 0, 0, 851, 849, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0, 852, 854, 1, 0, 0, 0, 853, 851, 1, 0, 0, 0, 854, 856, 3, 84, 42, 0, 855, 844, 1, 0, 0, 0, 855, 856, 1, 0, 0, 0, 856, 864, 1, 0, 0, 0, 857, 859, 5, 5, 0, 0, 858, 857, 1, 0, 0, 0, 859, 862, 1, 0, 0, 0, 860, 858, 1, 0, 0, 0, 860, 861, 1, 0, 0, 0, 861, 863, 1, 0, 0, 0, 862, 860, 1, 0, 0, 0, 863, 865, 3, 104, 52, 0, 864, 860, 1, 0, 0, 0, 864, 865, 1, 0, 0, 0, 865, 873, 1, 0, 0, 0, 866, 868, 5, 5, 0, 0, 867, 866, 1, 0, 0, 0, 868, 871, 1, 0, 0, 0, 869, 867, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 872, 1, 0, 0, 0, 871, 869, 1, 0, 0, 0, 872, 874, 3, 62, 31, 0, 873, 869, 1, 0, 0, 0, 873, 874, 1, 0, 0, 0, 874, 53, 1, 0, 0, 0, 875, 887, 5, 9, 0, 0, 876, 881, 3, 56, 28, 0, 877, 878, 5, 8, 0, 0, 878, 880, 3, 56, 28, 0, 879, 877, 1, 0, 0, 0, 880, 883, 1, 0, 0, 0, 881, 879, 1, 0, 0, 0, 881, 882, 1, 0, 0, 0, 882, 885, 1, 0, 0, 0, 883, 881, 1, 0, 0, 0, 884, 886, 5, 8, 0, 0, 885, 884, 1, 0, 0, 0, 885, 886, 1, 0, 0, 0, 886, 888, 1, 0, 0, 0, 887, 876, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 889, 1, 0, 0, 0, 889, 890, 5, 10, 0, 0, 890, 55, 1, 0, 0, 0, 891, 893, 3, 252, 126, 0, 892, 891, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 897, 3, 58, 29, 0, 895, 896, 5, 27, 0, 0, 896, 898, 3, 118, 59, 0, 897, 895, 1, 0, 0, 0, 897, 898, 1, 0, 0, 0, 898, 57, 1, 0, 0, 0, 899, 900, 3, 288, 144, 0, 900, 901, 5, 25, 0, 0, 901, 902, 3, 84, 42, 0, 902, 59, 1, 0, 0, 0, 903, 905, 3, 86, 43, 0, 904, 903, 1, 0, 0, 0, 904, 905, 1, 0, 0, 0, 905, 909, 1, 0, 0, 0, 906, 910, 3, 88, 44, 0, 907, 910, 3, 90, 45, 0, 908, 910, 3, 92, 46, 0, 909, 906, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 909, 908, 1, 0, 0, 0, 910, 61, 1, 0, 0, 0, 911, 921, 3, 108, 54, 0, 912, 916, 5, 27, 0, 0, 913, 915, 5, 5, 0, 0, 914, 913, 1, 0, 0, 0, 915, 918, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 916, 917, 1, 0, 0, 0, 917, 919, 1, 0, 0, 0, 918, 916, 1, 0, 0, 0, 919, 921, 3, 118, 59, 0, 920, 911, 1, 0, 0, 0, 920, 912, 1, 0, 0, 0, 921, 63, 1, 0, 0, 0, 922, 924, 3, 252, 126, 0, 923, 922, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 929, 5, 62, 0, 0, 926, 928, 5, 5, 0, 0, 927, 926, 1, 0, 0, 0, 928, 931, 1, 0, 0, 0, 929, 927, 1, 0, 0, 0, 929, 930, 1, 0, 0, 0, 930, 932, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 932, 940, 3, 288, 144, 0, 933, 935, 5, 5, 0, 0, 934, 933, 1, 0, 0, 0, 935, 938, 1, 0, 0, 0, 936, 934, 1, 0, 0, 0, 936, 937, 1, 0, 0, 0, 937, 939, 1, 0, 0, 0, 938, 936, 1, 0, 0, 0, 939, 941, 3, 22, 11, 0, 940, 936, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0, 941, 956, 1, 0, 0, 0, 942, 944, 5, 5, 0, 0, 943, 942, 1, 0, 0, 0, 944, 947, 1, 0, 0, 0, 945, 943, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 948, 1, 0, 0, 0, 947, 945, 1, 0, 0, 0, 948, 952, 5, 25, 0, 0, 949, 951, 5, 5, 0, 0, 950, 949, 1, 0, 0, 0, 951, 954, 1, 0, 0, 0, 952, 950, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 955, 1, 0, 0, 0, 954, 952, 1, 0, 0, 0, 955, 957, 3, 28, 14, 0, 956, 945, 1, 0, 0, 0, 956, 957, 1, 0, 0, 0, 957, 965, 1, 0, 0, 0, 958, 960, 5, 5, 0, 0, 959, 958, 1, 0, 0, 0, 960, 963, 1, 0, 0, 0, 961, 959, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 964, 1, 0, 0, 0, 963, 961, 1, 0, 0, 0, 964, 966, 3, 36, 18, 0, 965, 961, 1, 0, 0, 0, 965, 966, 1, 0, 0, 0, 966, 65, 1, 0, 0, 0, 967, 969, 3, 252, 126, 0, 968, 967, 1, 0, 0, 0, 968, 969, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 974, 5, 68, 0, 0, 971, 973, 5, 5, 0, 0, 972, 971, 1, 0, 0, 0, 973, 976, 1, 0, 0, 0, 974, 972, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 978, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 977, 979, 3, 252, 126, 0, 978, 977, 1, 0, 0, 0, 978, 979, 1, 0, 0, 0, 979, 980, 1, 0, 0, 0, 980, 988, 5, 62, 0, 0, 981, 983, 5, 5, 0, 0, 982, 981, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 987, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 989, 3, 288, 144, 0, 988, 984, 1, 0, 0, 0, 988, 989, 1, 0, 0, 0, 989, 1004, 1, 0, 0, 0, 990, 992, 5, 5, 0, 0, 991, 990, 1, 0, 0, 0, 992, 995, 1, 0, 0, 0, 993, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 996, 1, 0, 0, 0, 995, 993, 1, 0, 0, 0, 996, 1000, 5, 25, 0, 0, 997, 999, 5, 5, 0, 0, 998, 997, 1, 0, 0, 0, 999, 1002, 1, 0, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1003, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1003, 1005, 3, 28, 14, 0, 1004, 993, 1, 0, 0, 0, 1004, 1005, 1, 0, 0, 0, 1005, 1013, 1, 0, 0, 0, 1006, 1008, 5, 5, 0, 0, 1007, 1006, 1, 0, 0, 0, 1008, 1011, 1, 0, 0, 0, 1009, 1007, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1012, 1, 0, 0, 0, 1011, 1009, 1, 0, 0, 0, 1012, 1014, 3, 36, 18, 0, 1013, 1009, 1, 0, 0, 0, 1013, 1014, 1, 0, 0, 0, 1014, 67, 1, 0, 0, 0, 1015, 1017, 3, 252, 126, 0, 1016, 1015, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1026, 7, 1, 0, 0, 1019, 1021, 5, 5, 0, 0, 1020, 1019, 1, 0, 0, 0, 1021, 1024, 1, 0, 0, 0, 1022, 1020, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1025, 1, 0, 0, 0, 1024, 1022, 1, 0, 0, 0, 1025, 1027, 3, 80, 40, 0, 1026, 1022, 1, 0, 0, 0, 1026, 1027, 1, 0, 0, 0, 1027, 1043, 1, 0, 0, 0, 1028, 1030, 5, 5, 0, 0, 1029, 1028, 1, 0, 0, 0, 1030, 1033, 1, 0, 0, 0, 1031, 1029, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 1034, 1, 0, 0, 0, 1033, 1031, 1, 0, 0, 0, 1034, 1038, 3, 84, 42, 0, 1035, 1037, 5, 5, 0, 0, 1036, 1035, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1041, 1, 0, 0, 0, 1040, 1038, 1, 0, 0, 0, 1041, 1042, 5, 7, 0, 0, 1042, 1044, 1, 0, 0, 0, 1043, 1031, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1048, 1, 0, 0, 0, 1045, 1047, 5, 5, 0, 0, 1046, 1045, 1, 0, 0, 0, 1047, 1050, 1, 0, 0, 0, 1048, 1046, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1053, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1051, 1054, 3, 70, 35, 0, 1052, 1054, 3, 72, 36, 0, 1053, 1051, 1, 0, 0, 0, 1053, 1052, 1, 0, 0, 0, 1054, 1062, 1, 0, 0, 0, 1055, 1057, 5, 5, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1060, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1061, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1061, 1063, 3, 104, 52, 0, 1062, 1058, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1078, 1, 0, 0, 0, 1064, 1066, 5, 5, 0, 0, 1065, 1064, 1, 0, 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1074, 7, 2, 0, 0, 1071, 1073, 5, 5, 0, 0, 1072, 1071, 1, 0, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1072, 1, 0, 0, 0, 1074, 1075, 1, 0, 0, 0, 1075, 1077, 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1077, 1079, 3, 118, 59, 0, 1078, 1067, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1104, 1, 0, 0, 0, 1080, 1082, 5, 5, 0, 0, 1081, 1080, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1086, 1090, 3, 74, 37, 0, 1087, 1088, 3, 290, 145, 0, 1088, 1089, 3, 76, 38, 0, 1089, 1091, 1, 0, 0, 0, 1090, 1087, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1105, 1, 0, 0, 0, 1092, 1094, 5, 5, 0, 0, 1093, 1092, 1, 0, 0, 0, 1094, 1097, 1, 0, 0, 0, 1095, 1093, 1, 0, 0, 0, 1095, 1096, 1, 0, 0, 0, 1096, 1098, 1, 0, 0, 0, 1097, 1095, 1, 0, 0, 0, 1098, 1102, 3, 76, 38, 0, 1099, 1100, 3, 290, 145, 0, 1100, 1101, 3, 74, 37, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1099, 1, 0, 0, 0, 1102, 1103, 1, 0, 0, 0, 1103, 1105, 1, 0, 0, 0, 1104, 1083, 1, 0, 0, 0, 1104, 1095, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 69, 1, 0, 0, 0, 1106, 1107, 5, 9, 0, 0, 1107, 1112, 3, 72, 36, 0, 1108, 1109, 5, 8, 0, 0, 1109, 1111, 3, 72, 36, 0, 1110, 1108, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 5, 10, 0, 0, 1116, 71, 1, 0, 0, 0, 1117, 1120, 3, 288, 144, 0, 1118, 1119, 5, 25, 0, 0, 1119, 1121, 3, 84, 42, 0, 1120, 1118, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 73, 1, 0, 0, 0, 1122, 1124, 3, 252, 126, 0, 1123, 1122, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, 1125, 1172, 5, 97, 0, 0, 1126, 1128, 3, 252, 126, 0, 1127, 1126, 1, 0, 0, 0, 1127, 1128, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1133, 5, 97, 0, 0, 1130, 1132, 5, 5, 0, 0, 1131, 1130, 1, 0, 0, 0, 1132, 1135, 1, 0, 0, 0, 1133, 1131, 1, 0, 0, 0, 1133, 1134, 1, 0, 0, 0, 1134, 1136, 1, 0, 0, 0, 1135, 1133, 1, 0, 0, 0, 1136, 1137, 5, 9, 0, 0, 1137, 1152, 5, 10, 0, 0, 1138, 1140, 5, 5, 0, 0, 1139, 1138, 1, 0, 0, 0, 1140, 1143, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 1144, 1, 0, 0, 0, 1143, 1141, 1, 0, 0, 0, 1144, 1148, 5, 25, 0, 0, 1145, 1147, 5, 5, 0, 0, 1146, 1145, 1, 0, 0, 0, 1147, 1150, 1, 0, 0, 0, 1148, 1146, 1, 0, 0, 0, 1148, 1149, 1, 0, 0, 0, 1149, 1151, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1151, 1153, 3, 84, 42, 0, 1152, 1141, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1157, 1, 0, 0, 0, 1154, 1156, 5, 5, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 1159, 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1169, 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1160, 1170, 3, 108, 54, 0, 1161, 1165, 5, 27, 0, 0, 1162, 1164, 5, 5, 0, 0, 1163, 1162, 1, 0, 0, 0, 1164, 1167, 1, 0, 0, 0, 1165, 1163, 1, 0, 0, 0, 1165, 1166, 1, 0, 0, 0, 1166, 1168, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1168, 1170, 3, 118, 59, 0, 1169, 1160, 1, 0, 0, 0, 1169, 1161, 1, 0, 0, 0, 1170, 1172, 1, 0, 0, 0, 1171, 1123, 1, 0, 0, 0, 1171, 1127, 1, 0, 0, 0, 1172, 75, 1, 0, 0, 0, 1173, 1175, 3, 252, 126, 0, 1174, 1173, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1209, 5, 98, 0, 0, 1177, 1179, 3, 252, 126, 0, 1178, 1177, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1184, 5, 98, 0, 0, 1181, 1183, 5, 5, 0, 0, 1182, 1181, 1, 0, 0, 0, 1183, 1186, 1, 0, 0, 0, 1184, 1182, 1, 0, 0, 0, 1184, 1185, 1, 0, 0, 0, 1185, 1187, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1187, 1192, 5, 9, 0, 0, 1188, 1191, 3, 276, 138, 0, 1189, 1191, 3, 270, 135, 0, 1190, 1188, 1, 0, 0, 0, 1190, 1189, 1, 0, 0, 0, 1191, 1194, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1197, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1195, 1198, 3, 288, 144, 0, 1196, 1198, 3, 58, 29, 0, 1197, 1195, 1, 0, 0, 0, 1197, 1196, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 1203, 5, 10, 0, 0, 1200, 1202, 5, 5, 0, 0, 1201, 1200, 1, 0, 0, 0, 1202, 1205, 1, 0, 0, 0, 1203, 1201, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, 1203, 1, 0, 0, 0, 1206, 1207, 3, 62, 31, 0, 1207, 1209, 1, 0, 0, 0, 1208, 1174, 1, 0, 0, 0, 1208, 1178, 1, 0, 0, 0, 1209, 77, 1, 0, 0, 0, 1210, 1212, 3, 252, 126, 0, 1211, 1210, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1217, 5, 65, 0, 0, 1214, 1216, 5, 5, 0, 0, 1215, 1214, 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1228, 3, 288, 144, 0, 1221, 1223, 5, 5, 0, 0, 1222, 1221, 1, 0, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1222, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1227, 1, 0, 0, 0, 1226, 1224, 1, 0, 0, 0, 1227, 1229, 3, 80, 40, 0, 1228, 1224, 1, 0, 0, 0, 1228, 1229, 1, 0, 0, 0, 1229, 1233, 1, 0, 0, 0, 1230, 1232, 5, 5, 0, 0, 1231, 1230, 1, 0, 0, 0, 1232, 1235, 1, 0, 0, 0, 1233, 1231, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1236, 1, 0, 0, 0, 1235, 1233, 1, 0, 0, 0, 1236, 1240, 5, 27, 0, 0, 1237, 1239, 5, 5, 0, 0, 1238, 1237, 1, 0, 0, 0, 1239, 1242, 1, 0, 0, 0, 1240, 1238, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1243, 1, 0, 0, 0, 1242, 1240, 1, 0, 0, 0, 1243, 1244, 3, 84, 42, 0, 1244, 79, 1, 0, 0, 0, 1245, 1249, 5, 43, 0, 0, 1246, 1248, 5, 5, 0, 0, 1247, 1246, 1, 0, 0, 0, 1248, 1251, 1, 0, 0, 0, 1249, 1247, 1, 0, 0, 0, 1249, 1250, 1, 0, 0, 0, 1250, 1252, 1, 0, 0, 0, 1251, 1249, 1, 0, 0, 0, 1252, 1269, 3, 82, 41, 0, 1253, 1255, 5, 5, 0, 0, 1254, 1253, 1, 0, 0, 0, 1255, 1258, 1, 0, 0, 0, 1256, 1254, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1259, 1, 0, 0, 0, 1258, 1256, 1, 0, 0, 0, 1259, 1263, 5, 8, 0, 0, 1260, 1262, 5, 5, 0, 0, 1261, 1260, 1, 0, 0, 0, 1262, 1265, 1, 0, 0, 0, 1263, 1261, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1266, 1, 0, 0, 0, 1265, 1263, 1, 0, 0, 0, 1266, 1268, 3, 82, 41, 0, 1267, 1256, 1, 0, 0, 0, 1268, 1271, 1, 0, 0, 0, 1269, 1267, 1, 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1279, 1, 0, 0, 0, 1271, 1269, 1, 0, 0, 0, 1272, 1274, 5, 5, 0, 0, 1273, 1272, 1, 0, 0, 0, 1274, 1277, 1, 0, 0, 0, 1275, 1273, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1278, 1, 0, 0, 0, 1277, 1275, 1, 0, 0, 0, 1278, 1280, 5, 8, 0, 0, 1279, 1275, 1, 0, 0, 0, 1279, 1280, 1, 0, 0, 0, 1280, 1284, 1, 0, 0, 0, 1281, 1283, 5, 5, 0, 0, 1282, 1281, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1282, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1287, 1288, 5, 44, 0, 0, 1288, 81, 1, 0, 0, 0, 1289, 1291, 3, 252, 126, 0, 1290, 1289, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1295, 1, 0, 0, 0, 1292, 1294, 5, 5, 0, 0, 1293, 1292, 1, 0, 0, 0, 1294, 1297, 1, 0, 0, 0, 1295, 1293, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1300, 1, 0, 0, 0, 1297, 1295, 1, 0, 0, 0, 1298, 1301, 3, 288, 144, 0, 1299, 1301, 5, 15, 0, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1299, 1, 0, 0, 0, 1301, 1316, 1, 0, 0, 0, 1302, 1304, 5, 5, 0, 0, 1303, 1302, 1, 0, 0, 0, 1304, 1307, 1, 0, 0, 0, 1305, 1303, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1308, 1, 0, 0, 0, 1307, 1305, 1, 0, 0, 0, 1308, 1312, 5, 25, 0, 0, 1309, 1311, 5, 5, 0, 0, 1310, 1309, 1, 0, 0, 0, 1311, 1314, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1312, 1, 0, 0, 0, 1315, 1317, 3, 84, 42, 0, 1316, 1305, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 83, 1, 0, 0, 0, 1318, 1320, 3, 86, 43, 0, 1319, 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1325, 1, 0, 0, 0, 1321, 1326, 3, 94, 47, 0, 1322, 1326, 3, 88, 44, 0, 1323, 1326, 3, 90, 45, 0, 1324, 1326, 3, 92, 46, 0, 1325, 1321, 1, 0, 0, 0, 1325, 1322, 1, 0, 0, 0, 1325, 1323, 1, 0, 0, 0, 1325, 1324, 1, 0, 0, 0, 1326, 85, 1, 0, 0, 0, 1327, 1336, 3, 276, 138, 0, 1328, 1332, 5, 118, 0, 0, 1329, 1331, 5, 5, 0, 0, 1330, 1329, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1336, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1335, 1327, 1, 0, 0, 0, 1335, 1328, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, 1337, 1338, 1, 0, 0, 0, 1338, 87, 1, 0, 0, 0, 1339, 1340, 5, 9, 0, 0, 1340, 1341, 3, 84, 42, 0, 1341, 1342, 5, 10, 0, 0, 1342, 89, 1, 0, 0, 0, 1343, 1346, 3, 92, 46, 0, 1344, 1346, 3, 88, 44, 0, 1345, 1343, 1, 0, 0, 0, 1345, 1344, 1, 0, 0, 0, 1346, 1350, 1, 0, 0, 0, 1347, 1349, 5, 5, 0, 0, 1348, 1347, 1, 0, 0, 0, 1349, 1352, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1350, 1351, 1, 0, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1350, 1, 0, 0, 0, 1353, 1355, 5, 41, 0, 0, 1354, 1353, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 91, 1, 0, 0, 0, 1358, 1359, 5, 9, 0, 0, 1359, 1360, 3, 92, 46, 0, 1360, 1361, 5, 10, 0, 0, 1361, 1365, 1, 0, 0, 0, 1362, 1365, 3, 98, 49, 0, 1363, 1365, 5, 103, 0, 0, 1364, 1358, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1363, 1, 0, 0, 0, 1365, 93, 1, 0, 0, 0, 1366, 1370, 3, 96, 48, 0, 1367, 1369, 5, 5, 0, 0, 1368, 1367, 1, 0, 0, 0, 1369, 1372, 1, 0, 0, 0, 1370, 1368, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1373, 1, 0, 0, 0, 1372, 1370, 1, 0, 0, 0, 1373, 1377, 5, 7, 0, 0, 1374, 1376, 5, 5, 0, 0, 1375, 1374, 1, 0, 0, 0, 1376, 1379, 1, 0, 0, 0, 1377, 1375, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1381, 1, 0, 0, 0, 1379, 1377, 1, 0, 0, 0, 1380, 1366, 1, 0, 0, 0, 1380, 1381, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 1386, 3, 102, 51, 0, 1383, 1385, 5, 5, 0, 0, 1384, 1383, 1, 0, 0, 0, 1385, 1388, 1, 0, 0, 0, 1386, 1384, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1389, 1, 0, 0, 0, 1388, 1386, 1, 0, 0, 0, 1389, 1393, 5, 33, 0, 0, 1390, 1392, 5, 5, 0, 0, 1391, 1390, 1, 0, 0, 0, 1392, 1395, 1, 0, 0, 0, 1393, 1391, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 1396, 1, 0, 0, 0, 1395, 1393, 1, 0, 0, 0, 1396, 1397, 3, 84, 42, 0, 1397, 95, 1, 0, 0, 0, 1398, 1402, 3, 88, 44, 0, 1399, 1402, 3, 90, 45, 0, 1400, 1402, 3, 92, 46, 0, 1401, 1398, 1, 0, 0, 0, 1401, 1399, 1, 0, 0, 0, 1401, 1400, 1, 0, 0, 0, 1402, 97, 1, 0, 0, 0, 1403, 1420, 3, 100, 50, 0, 1404, 1406, 5, 5, 0, 0, 1405, 1404, 1, 0, 0, 0, 1406, 1409, 1, 0, 0, 0, 1407, 1405, 1, 0, 0, 0, 1407, 1408, 1, 0, 0, 0, 1408, 1410, 1, 0, 0, 0, 1409, 1407, 1, 0, 0, 0, 1410, 1414, 5, 7, 0, 0, 1411, 1413, 5, 5, 0, 0, 1412, 1411, 1, 0, 0, 0, 1413, 1416, 1, 0, 0, 0, 1414, 1412, 1, 0, 0, 0, 1414, 1415, 1, 0, 0, 0, 1415, 1417, 1, 0, 0, 0, 1416, 1414, 1, 0, 0, 0, 1417, 1419, 3, 100, 50, 0, 1418, 1407, 1, 0, 0, 0, 1419, 1422, 1, 0, 0, 0, 1420, 1418, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 99, 1, 0, 0, 0, 1422, 1420, 1, 0, 0, 0, 1423, 1431, 3, 288, 144, 0, 1424, 1426, 5, 5, 0, 0, 1425, 1424, 1, 0, 0, 0, 1426, 1429, 1, 0, 0, 0, 1427, 1425, 1, 0, 0, 0, 1427, 1428, 1, 0, 0, 0, 1428, 1430, 1, 0, 0, 0, 1429, 1427, 1, 0, 0, 0, 1430, 1432, 3, 158, 79, 0, 1431, 1427, 1, 0, 0, 0, 1431, 1432, 1, 0, 0, 0, 1432, 101, 1, 0, 0, 0, 1433, 1437, 5, 9, 0, 0, 1434, 1436, 5, 5, 0, 0, 1435, 1434, 1, 0, 0, 0, 1436, 1439, 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1437, 1438, 1, 0, 0, 0, 1438, 1442, 1, 0, 0, 0, 1439, 1437, 1, 0, 0, 0, 1440, 1443, 3, 58, 29, 0, 1441, 1443, 3, 84, 42, 0, 1442, 1440, 1, 0, 0, 0, 1442, 1441, 1, 0, 0, 0, 1442, 1443, 1, 0, 0, 0, 1443, 1463, 1, 0, 0, 0, 1444, 1446, 5, 5, 0, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1450, 1454, 5, 8, 0, 0, 1451, 1453, 5, 5, 0, 0, 1452, 1451, 1, 0, 0, 0, 1453, 1456, 1, 0, 0, 0, 1454, 1452, 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 1459, 1, 0, 0, 0, 1456, 1454, 1, 0, 0, 0, 1457, 1460, 3, 58, 29, 0, 1458, 1460, 3, 84, 42, 0, 1459, 1457, 1, 0, 0, 0, 1459, 1458, 1, 0, 0, 0, 1460, 1462, 1, 0, 0, 0, 1461, 1447, 1, 0, 0, 0, 1462, 1465, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1463, 1464, 1, 0, 0, 0, 1464, 1473, 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1466, 1468, 5, 5, 0, 0, 1467, 1466, 1, 0, 0, 0, 1468, 1471, 1, 0, 0, 0, 1469, 1467, 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1472, 1, 0, 0, 0, 1471, 1469, 1, 0, 0, 0, 1472, 1474, 5, 8, 0, 0, 1473, 1469, 1, 0, 0, 0, 1473, 1474, 1, 0, 0, 0, 1474, 1478, 1, 0, 0, 0, 1475, 1477, 5, 5, 0, 0, 1476, 1475, 1, 0, 0, 0, 1477, 1480, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1481, 1, 0, 0, 0, 1480, 1478, 1, 0, 0, 0, 1481, 1482, 5, 10, 0, 0, 1482, 103, 1, 0, 0, 0, 1483, 1487, 5, 73, 0, 0, 1484, 1486, 5, 5, 0, 0, 1485, 1484, 1, 0, 0, 0, 1486, 1489, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1490, 1, 0, 0, 0, 1489, 1487, 1, 0, 0, 0, 1490, 1507, 3, 106, 53, 0, 1491, 1493, 5, 5, 0, 0, 1492, 1491, 1, 0, 0, 0, 1493, 1496, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1494, 1495, 1, 0, 0, 0, 1495, 1497, 1, 0, 0, 0, 1496, 1494, 1, 0, 0, 0, 1497, 1501, 5, 8, 0, 0, 1498, 1500, 5, 5, 0, 0, 1499, 1498, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1504, 1, 0, 0, 0, 1503, 1501, 1, 0, 0, 0, 1504, 1506, 3, 106, 53, 0, 1505, 1494, 1, 0, 0, 0, 1506, 1509, 1, 0, 0, 0, 1507, 1505, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 105, 1, 0, 0, 0, 1509, 1507, 1, 0, 0, 0, 1510, 1512, 3, 276, 138, 0, 1511, 1510, 1, 0, 0, 0, 1512, 1515, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1513, 1514, 1, 0, 0, 0, 1514, 1516, 1, 0, 0, 0, 1515, 1513, 1, 0, 0, 0, 1516, 1520, 3, 288, 144, 0, 1517, 1519, 5, 5, 0, 0, 1518, 1517, 1, 0, 0, 0, 1519, 1522, 1, 0, 0, 0, 1520, 1518, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, 0, 1521, 1523, 1, 0, 0, 0, 1522, 1520, 1, 0, 0, 0, 1523, 1527, 5, 25, 0, 0, 1524, 1526, 5, 5, 0, 0, 1525, 1524, 1, 0, 0, 0, 1526, 1529, 1, 0, 0, 0, 1527, 1525, 1, 0, 0, 0, 1527, 1528, 1, 0, 0, 0, 1528, 1530, 1, 0, 0, 0, 1529, 1527, 1, 0, 0, 0, 1530, 1531, 3, 84, 42, 0, 1531, 107, 1, 0, 0, 0, 1532, 1533, 5, 13, 0, 0, 1533, 1534, 3, 110, 55, 0, 1534, 1535, 5, 14, 0, 0, 1535, 109, 1, 0, 0, 0, 1536, 1538, 3, 292, 146, 0, 1537, 1536, 1, 0, 0, 0, 1538, 1541, 1, 0, 0, 0, 1539, 1537, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1556, 1, 0, 0, 0, 1541, 1539, 1, 0, 0, 0, 1542, 1553, 3, 112, 56, 0, 1543, 1545, 3, 292, 146, 0, 1544, 1543, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, 0, 1546, 1547, 1, 0, 0, 0, 1547, 1549, 1, 0, 0, 0, 1548, 1550, 3, 112, 56, 0, 1549, 1548, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1552, 1, 0, 0, 0, 1551, 1544, 1, 0, 0, 0, 1552, 1555, 1, 0, 0, 0, 1553, 1551, 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1557, 1, 0, 0, 0, 1555, 1553, 1, 0, 0, 0, 1556, 1542, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 111, 1, 0, 0, 0, 1558, 1561, 3, 116, 58, 0, 1559, 1561, 3, 114, 57, 0, 1560, 1558, 1, 0, 0, 0, 1560, 1559, 1, 0, 0, 0, 1561, 113, 1, 0, 0, 0, 1562, 1564, 3, 276, 138, 0, 1563, 1562, 1, 0, 0, 0, 1564, 1567, 1, 0, 0, 0, 1565, 1563, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1571, 1, 0, 0, 0, 1567, 1565, 1, 0, 0, 0, 1568, 1570, 5, 5, 0, 0, 1569, 1568, 1, 0, 0, 0, 1570, 1573, 1, 0, 0, 0, 1571, 1569, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1574, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1574, 1575, 3, 118, 59, 0, 1575, 115, 1, 0, 0, 0, 1576, 1578, 3, 274, 137, 0, 1577, 1576, 1, 0, 0, 0, 1578, 1581, 1, 0, 0, 0, 1579, 1577, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1586, 1, 0, 0, 0, 1581, 1579, 1, 0, 0, 0, 1582, 1587, 3, 20, 10, 0, 1583, 1587, 3, 52, 26, 0, 1584, 1587, 3, 68, 34, 0, 1585, 1587, 3, 78, 39, 0, 1586, 1582, 1, 0, 0, 0, 1586, 1583, 1, 0, 0, 0, 1586, 1584, 1, 0, 0, 0, 1586, 1585, 1, 0, 0, 0, 1587, 117, 1, 0, 0, 0, 1588, 1594, 3, 120, 60, 0, 1589, 1590, 3, 230, 115, 0, 1590, 1591, 3, 120, 60, 0, 1591, 1593, 1, 0, 0, 0, 1592, 1589, 1, 0, 0, 0, 1593, 1596, 1, 0, 0, 0, 1594, 1592, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 119, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1597, 1614, 3, 122, 61, 0, 1598, 1600, 5, 5, 0, 0, 1599, 1598, 1, 0, 0, 0, 1600, 1603, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1604, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1604, 1608, 5, 23, 0, 0, 1605, 1607, 5, 5, 0, 0, 1606, 1605, 1, 0, 0, 0, 1607, 1610, 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1608, 1, 0, 0, 0, 1611, 1613, 3, 122, 61, 0, 1612, 1601, 1, 0, 0, 0, 1613, 1616, 1, 0, 0, 0, 1614, 1612, 1, 0, 0, 0, 1614, 1615, 1, 0, 0, 0, 1615, 121, 1, 0, 0, 0, 1616, 1614, 1, 0, 0, 0, 1617, 1634, 3, 124, 62, 0, 1618, 1620, 5, 5, 0, 0, 1619, 1618, 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1624, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1628, 5, 22, 0, 0, 1625, 1627, 5, 5, 0, 0, 1626, 1625, 1, 0, 0, 0, 1627, 1630, 1, 0, 0, 0, 1628, 1626, 1, 0, 0, 0, 1628, 1629, 1, 0, 0, 0, 1629, 1631, 1, 0, 0, 0, 1630, 1628, 1, 0, 0, 0, 1631, 1633, 3, 124, 62, 0, 1632, 1621, 1, 0, 0, 0, 1633, 1636, 1, 0, 0, 0, 1634, 1632, 1, 0, 0, 0, 1634, 1635, 1, 0, 0, 0, 1635, 123, 1, 0, 0, 0, 1636, 1634, 1, 0, 0, 0, 1637, 1649, 3, 126, 63, 0, 1638, 1642, 3, 232, 116, 0, 1639, 1641, 5, 5, 0, 0, 1640, 1639, 1, 0, 0, 0, 1641, 1644, 1, 0, 0, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1645, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1645, 1646, 3, 126, 63, 0, 1646, 1648, 1, 0, 0, 0, 1647, 1638, 1, 0, 0, 0, 1648, 1651, 1, 0, 0, 0, 1649, 1647, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 125, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1652, 1662, 3, 128, 64, 0, 1653, 1657, 3, 234, 117, 0, 1654, 1656, 5, 5, 0, 0, 1655, 1654, 1, 0, 0, 0, 1656, 1659, 1, 0, 0, 0, 1657, 1655, 1, 0, 0, 0, 1657, 1658, 1, 0, 0, 0, 1658, 1660, 1, 0, 0, 0, 1659, 1657, 1, 0, 0, 0, 1660, 1661, 3, 128, 64, 0, 1661, 1663, 1, 0, 0, 0, 1662, 1653, 1, 0, 0, 0, 1662, 1663, 1, 0, 0, 0, 1663, 127, 1, 0, 0, 0, 1664, 1687, 3, 130, 65, 0, 1665, 1669, 3, 236, 118, 0, 1666, 1668, 5, 5, 0, 0, 1667, 1666, 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1672, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1673, 3, 130, 65, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1674, 1, 0, 0, 0, 1676, 1677, 1, 0, 0, 0, 1677, 1688, 1, 0, 0, 0, 1678, 1682, 3, 238, 119, 0, 1679, 1681, 5, 5, 0, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 1685, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1686, 3, 84, 42, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1674, 1, 0, 0, 0, 1687, 1678, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 129, 1, 0, 0, 0, 1689, 1706, 3, 132, 66, 0, 1690, 1692, 5, 5, 0, 0, 1691, 1690, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 1696, 1, 0, 0, 0, 1695, 1693, 1, 0, 0, 0, 1696, 1700, 5, 42, 0, 0, 1697, 1699, 5, 5, 0, 0, 1698, 1697, 1, 0, 0, 0, 1699, 1702, 1, 0, 0, 0, 1700, 1698, 1, 0, 0, 0, 1700, 1701, 1, 0, 0, 0, 1701, 1703, 1, 0, 0, 0, 1702, 1700, 1, 0, 0, 0, 1703, 1705, 3, 132, 66, 0, 1704, 1693, 1, 0, 0, 0, 1705, 1708, 1, 0, 0, 0, 1706, 1704, 1, 0, 0, 0, 1706, 1707, 1, 0, 0, 0, 1707, 131, 1, 0, 0, 0, 1708, 1706, 1, 0, 0, 0, 1709, 1721, 3, 134, 67, 0, 1710, 1714, 3, 288, 144, 0, 1711, 1713, 5, 5, 0, 0, 1712, 1711, 1, 0, 0, 0, 1713, 1716, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1714, 1715, 1, 0, 0, 0, 1715, 1717, 1, 0, 0, 0, 1716, 1714, 1, 0, 0, 0, 1717, 1718, 3, 134, 67, 0, 1718, 1720, 1, 0, 0, 0, 1719, 1710, 1, 0, 0, 0, 1720, 1723, 1, 0, 0, 0, 1721, 1719, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 133, 1, 0, 0, 0, 1723, 1721, 1, 0, 0, 0, 1724, 1735, 3, 136, 68, 0, 1725, 1729, 5, 35, 0, 0, 1726, 1728, 5, 5, 0, 0, 1727, 1726, 1, 0, 0, 0, 1728, 1731, 1, 0, 0, 0, 1729, 1727, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, 0, 1731, 1729, 1, 0, 0, 0, 1732, 1734, 3, 136, 68, 0, 1733, 1725, 1, 0, 0, 0, 1734, 1737, 1, 0, 0, 0, 1735, 1733, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 135, 1, 0, 0, 0, 1737, 1735, 1, 0, 0, 0, 1738, 1750, 3, 138, 69, 0, 1739, 1743, 3, 240, 120, 0, 1740, 1742, 5, 5, 0, 0, 1741, 1740, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1747, 3, 138, 69, 0, 1747, 1749, 1, 0, 0, 0, 1748, 1739, 1, 0, 0, 0, 1749, 1752, 1, 0, 0, 0, 1750, 1748, 1, 0, 0, 0, 1750, 1751, 1, 0, 0, 0, 1751, 137, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1753, 1765, 3, 140, 70, 0, 1754, 1758, 3, 242, 121, 0, 1755, 1757, 5, 5, 0, 0, 1756, 1755, 1, 0, 0, 0, 1757, 1760, 1, 0, 0, 0, 1758, 1756, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1761, 1, 0, 0, 0, 1760, 1758, 1, 0, 0, 0, 1761, 1762, 3, 140, 70, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1754, 1, 0, 0, 0, 1764, 1767, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1765, 1766, 1, 0, 0, 0, 1766, 139, 1, 0, 0, 0, 1767, 1765, 1, 0, 0, 0, 1768, 1780, 3, 142, 71, 0, 1769, 1771, 5, 5, 0, 0, 1770, 1769, 1, 0, 0, 0, 1771, 1774, 1, 0, 0, 0, 1772, 1770, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1775, 1, 0, 0, 0, 1774, 1772, 1, 0, 0, 0, 1775, 1776, 3, 244, 122, 0, 1776, 1777, 3, 142, 71, 0, 1777, 1779, 1, 0, 0, 0, 1778, 1772, 1, 0, 0, 0, 1779, 1782, 1, 0, 0, 0, 1780, 1778, 1, 0, 0, 0, 1780, 1781, 1, 0, 0, 0, 1781, 141, 1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1783, 1785, 3, 246, 123, 0, 1784, 1783, 1, 0, 0, 0, 1785, 1788, 1, 0, 0, 0, 1786, 1784, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1789, 1, 0, 0, 0, 1788, 1786, 1, 0, 0, 0, 1789, 1790, 3, 144, 72, 0, 1790, 143, 1, 0, 0, 0, 1791, 1794, 3, 146, 73, 0, 1792, 1794, 3, 228, 114, 0, 1793, 1791, 1, 0, 0, 0, 1793, 1792, 1, 0, 0, 0, 1794, 1798, 1, 0, 0, 0, 1795, 1797, 3, 248, 124, 0, 1796, 1795, 1, 0, 0, 0, 1797, 1800, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1798, 1799, 1, 0, 0, 0, 1799, 145, 1, 0, 0, 0, 1800, 1798, 1, 0, 0, 0, 1801, 1816, 3, 148, 74, 0, 1802, 1816, 3, 166, 83, 0, 1803, 1816, 3, 182, 91, 0, 1804, 1816, 3, 192, 96, 0, 1805, 1816, 3, 194, 97, 0, 1806, 1816, 3, 196, 98, 0, 1807, 1816, 3, 212, 106, 0, 1808, 1816, 3, 188, 94, 0, 1809, 1816, 3, 226, 113, 0, 1810, 1816, 3, 218, 109, 0, 1811, 1816, 3, 190, 95, 0, 1812, 1816, 3, 288, 144, 0, 1813, 1814, 5, 63, 0, 0, 1814, 1816, 3, 286, 143, 0, 1815, 1801, 1, 0, 0, 0, 1815, 1802, 1, 0, 0, 0, 1815, 1803, 1, 0, 0, 0, 1815, 1804, 1, 0, 0, 0, 1815, 1805, 1, 0, 0, 0, 1815, 1806, 1, 0, 0, 0, 1815, 1807, 1, 0, 0, 0, 1815, 1808, 1, 0, 0, 0, 1815, 1809, 1, 0, 0, 0, 1815, 1810, 1, 0, 0, 0, 1815, 1811, 1, 0, 0, 0, 1815, 1812, 1, 0, 0, 0, 1815, 1813, 1, 0, 0, 0, 1816, 147, 1, 0, 0, 0, 1817, 1818, 5, 9, 0, 0, 1818, 1819, 3, 118, 59, 0, 1819, 1820, 5, 10, 0, 0, 1820, 149, 1, 0, 0, 0, 1821, 1823, 3, 158, 79, 0, 1822, 1824, 3, 156, 78, 0, 1823, 1822, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1828, 1, 0, 0, 0, 1825, 1827, 3, 152, 76, 0, 1826, 1825, 1, 0, 0, 0, 1827, 1830, 1, 0, 0, 0, 1828, 1826, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1844, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1831, 1835, 3, 156, 78, 0, 1832, 1834, 3, 152, 76, 0, 1833, 1832, 1, 0, 0, 0, 1834, 1837, 1, 0, 0, 0, 1835, 1833, 1, 0, 0, 0, 1835, 1836, 1, 0, 0, 0, 1836, 1844, 1, 0, 0, 0, 1837, 1835, 1, 0, 0, 0, 1838, 1840, 3, 152, 76, 0, 1839, 1838, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1844, 1, 0, 0, 0, 1843, 1821, 1, 0, 0, 0, 1843, 1831, 1, 0, 0, 0, 1843, 1839, 1, 0, 0, 0, 1844, 151, 1, 0, 0, 0, 1845, 1847, 3, 284, 142, 0, 1846, 1845, 1, 0, 0, 0, 1847, 1850, 1, 0, 0, 0, 1848, 1846, 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849, 1852, 1, 0, 0, 0, 1850, 1848, 1, 0, 0, 0, 1851, 1853, 5, 142, 0, 0, 1852, 1851, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 1857, 1, 0, 0, 0, 1854, 1856, 5, 5, 0, 0, 1855, 1854, 1, 0, 0, 0, 1856, 1859, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1860, 1861, 3, 182, 91, 0, 1861, 153, 1, 0, 0, 0, 1862, 1871, 5, 11, 0, 0, 1863, 1868, 3, 118, 59, 0, 1864, 1865, 5, 8, 0, 0, 1865, 1867, 3, 118, 59, 0, 1866, 1864, 1, 0, 0, 0, 1867, 1870, 1, 0, 0, 0, 1868, 1866, 1, 0, 0, 0, 1868, 1869, 1, 0, 0, 0, 1869, 1872, 1, 0, 0, 0, 1870, 1868, 1, 0, 0, 0, 1871, 1863, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, 1874, 5, 12, 0, 0, 1874, 155, 1, 0, 0, 0, 1875, 1893, 5, 9, 0, 0, 1876, 1881, 3, 164, 82, 0, 1877, 1878, 5, 8, 0, 0, 1878, 1880, 3, 164, 82, 0, 1879, 1877, 1, 0, 0, 0, 1880, 1883, 1, 0, 0, 0, 1881, 1879, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1891, 1, 0, 0, 0, 1883, 1881, 1, 0, 0, 0, 1884, 1886, 5, 5, 0, 0, 1885, 1884, 1, 0, 0, 0, 1886, 1889, 1, 0, 0, 0, 1887, 1885, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1887, 1, 0, 0, 0, 1890, 1892, 5, 8, 0, 0, 1891, 1887, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1894, 1, 0, 0, 0, 1893, 1876, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1896, 5, 10, 0, 0, 1896, 157, 1, 0, 0, 0, 1897, 1901, 5, 43, 0, 0, 1898, 1900, 5, 5, 0, 0, 1899, 1898, 1, 0, 0, 0, 1900, 1903, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1904, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1904, 1915, 3, 160, 80, 0, 1905, 1907, 5, 5, 0, 0, 1906, 1905, 1, 0, 0, 0, 1907, 1910, 1, 0, 0, 0, 1908, 1906, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909, 1911, 1, 0, 0, 0, 1910, 1908, 1, 0, 0, 0, 1911, 1912, 5, 8, 0, 0, 1912, 1914, 3, 160, 80, 0, 1913, 1908, 1, 0, 0, 0, 1914, 1917, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1925, 1, 0, 0, 0, 1917, 1915, 1, 0, 0, 0, 1918, 1920, 5, 5, 0, 0, 1919, 1918, 1, 0, 0, 0, 1920, 1923, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, 1922, 1924, 1, 0, 0, 0, 1923, 1921, 1, 0, 0, 0, 1924, 1926, 5, 8, 0, 0, 1925, 1921, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 1930, 1, 0, 0, 0, 1927, 1929, 5, 5, 0, 0, 1928, 1927, 1, 0, 0, 0, 1929, 1932, 1, 0, 0, 0, 1930, 1928, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931, 1933, 1, 0, 0, 0, 1932, 1930, 1, 0, 0, 0, 1933, 1935, 5, 44, 0, 0, 1934, 1936, 5, 41, 0, 0, 1935, 1934, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 159, 1, 0, 0, 0, 1937, 1939, 3, 162, 81, 0, 1938, 1937, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1943, 3, 84, 42, 0, 1941, 1943, 5, 15, 0, 0, 1942, 1938, 1, 0, 0, 0, 1942, 1941, 1, 0, 0, 0, 1943, 161, 1, 0, 0, 0, 1944, 1946, 3, 262, 131, 0, 1945, 1944, 1, 0, 0, 0, 1946, 1947, 1, 0, 0, 0, 1947, 1945, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 163, 1, 0, 0, 0, 1949, 1953, 3, 288, 144, 0, 1950, 1952, 5, 5, 0, 0, 1951, 1950, 1, 0, 0, 0, 1952, 1955, 1, 0, 0, 0, 1953, 1951, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1956, 1, 0, 0, 0, 1955, 1953, 1, 0, 0, 0, 1956, 1960, 5, 27, 0, 0, 1957, 1959, 5, 5, 0, 0, 1958, 1957, 1, 0, 0, 0, 1959, 1962, 1, 0, 0, 0, 1960, 1958, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1964, 1, 0, 0, 0, 1962, 1960, 1, 0, 0, 0, 1963, 1949, 1, 0, 0, 0, 1963, 1964, 1, 0, 0, 0, 1964, 1966, 1, 0, 0, 0, 1965, 1967, 5, 15, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1971, 1, 0, 0, 0, 1968, 1970, 5, 5, 0, 0, 1969, 1968, 1, 0, 0, 0, 1970, 1973, 1, 0, 0, 0, 1971, 1969, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972, 1974, 1, 0, 0, 0, 1973, 1971, 1, 0, 0, 0, 1974, 1975, 3, 118, 59, 0, 1975, 165, 1, 0, 0, 0, 1976, 1986, 5, 138, 0, 0, 1977, 1986, 5, 135, 0, 0, 1978, 1986, 3, 168, 84, 0, 1979, 1986, 5, 136, 0, 0, 1980, 1986, 5, 137, 0, 0, 1981, 1986, 5, 144, 0, 0, 1982, 1986, 5, 131, 0, 0, 1983, 1986, 5, 139, 0, 0, 1984, 1986, 5, 134, 0, 0, 1985, 1976, 1, 0, 0, 0, 1985, 1977, 1, 0, 0, 0, 1985, 1978, 1, 0, 0, 0, 1985, 1979, 1, 0, 0, 0, 1985, 1980, 1, 0, 0, 0, 1985, 1981, 1, 0, 0, 0, 1985, 1982, 1, 0, 0, 0, 1985, 1983, 1, 0, 0, 0, 1985, 1984, 1, 0, 0, 0, 1986, 167, 1, 0, 0, 0, 1987, 1990, 3, 170, 85, 0, 1988, 1990, 3, 172, 86, 0, 1989, 1987, 1, 0, 0, 0, 1989, 1988, 1, 0, 0, 0, 1990, 169, 1, 0, 0, 0, 1991, 1996, 5, 129, 0, 0, 1992, 1995, 3, 174, 87, 0, 1993, 1995, 3, 176, 88, 0, 1994, 1992, 1, 0, 0, 0, 1994, 1993, 1, 0, 0, 0, 1995, 1998, 1, 0, 0, 0, 1996, 1994, 1, 0, 0, 0, 1996, 1997, 1, 0, 0, 0, 1997, 1999, 1, 0, 0, 0, 1998, 1996, 1, 0, 0, 0, 1999, 2000, 5, 155, 0, 0, 2000, 171, 1, 0, 0, 0, 2001, 2008, 5, 130, 0, 0, 2002, 2007, 3, 178, 89, 0, 2003, 2007, 3, 180, 90, 0, 2004, 2007, 3, 170, 85, 0, 2005, 2007, 5, 161, 0, 0, 2006, 2002, 1, 0, 0, 0, 2006, 2003, 1, 0, 0, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2005, 1, 0, 0, 0, 2007, 2010, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0, 2011, 2012, 5, 160, 0, 0, 2012, 173, 1, 0, 0, 0, 2013, 2014, 7, 3, 0, 0, 2014, 175, 1, 0, 0, 0, 2015, 2016, 5, 159, 0, 0, 2016, 2017, 3, 118, 59, 0, 2017, 2018, 5, 14, 0, 0, 2018, 177, 1, 0, 0, 0, 2019, 2020, 7, 4, 0, 0, 2020, 179, 1, 0, 0, 0, 2021, 2022, 5, 165, 0, 0, 2022, 2023, 3, 118, 59, 0, 2023, 2024, 5, 14, 0, 0, 2024, 181, 1, 0, 0, 0, 2025, 2027, 3, 276, 138, 0, 2026, 2025, 1, 0, 0, 0, 2027, 2030, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2029, 1, 0, 0, 0, 2029, 2077, 1, 0, 0, 0, 2030, 2028, 1, 0, 0, 0, 2031, 2035, 5, 13, 0, 0, 2032, 2034, 5, 5, 0, 0, 2033, 2032, 1, 0, 0, 0, 2034, 2037, 1, 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2038, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2038, 2042, 3, 110, 55, 0, 2039, 2041, 5, 5, 0, 0, 2040, 2039, 1, 0, 0, 0, 2041, 2044, 1, 0, 0, 0, 2042, 2040, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2045, 1, 0, 0, 0, 2044, 2042, 1, 0, 0, 0, 2045, 2046, 5, 14, 0, 0, 2046, 2078, 1, 0, 0, 0, 2047, 2051, 5, 13, 0, 0, 2048, 2050, 5, 5, 0, 0, 2049, 2048, 1, 0, 0, 0, 2050, 2053, 1, 0, 0, 0, 2051, 2049, 1, 0, 0, 0, 2051, 2052, 1, 0, 0, 0, 2052, 2054, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2054, 2058, 3, 184, 92, 0, 2055, 2057, 5, 5, 0, 0, 2056, 2055, 1, 0, 0, 0, 2057, 2060, 1, 0, 0, 0, 2058, 2056, 1, 0, 0, 0, 2058, 2059, 1, 0, 0, 0, 2059, 2061, 1, 0, 0, 0, 2060, 2058, 1, 0, 0, 0, 2061, 2065, 5, 33, 0, 0, 2062, 2064, 5, 5, 0, 0, 2063, 2062, 1, 0, 0, 0, 2064, 2067, 1, 0, 0, 0, 2065, 2063, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 2068, 1, 0, 0, 0, 2067, 2065, 1, 0, 0, 0, 2068, 2072, 3, 110, 55, 0, 2069, 2071, 5, 5, 0, 0, 2070, 2069, 1, 0, 0, 0, 2071, 2074, 1, 0, 0, 0, 2072, 2070, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 2075, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2075, 2076, 5, 14, 0, 0, 2076, 2078, 1, 0, 0, 0, 2077, 2031, 1, 0, 0, 0, 2077, 2047, 1, 0, 0, 0, 2078, 183, 1, 0, 0, 0, 2079, 2081, 3, 186, 93, 0, 2080, 2079, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2098, 1, 0, 0, 0, 2082, 2084, 5, 5, 0, 0, 2083, 2082, 1, 0, 0, 0, 2084, 2087, 1, 0, 0, 0, 2085, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2088, 1, 0, 0, 0, 2087, 2085, 1, 0, 0, 0, 2088, 2092, 5, 8, 0, 0, 2089, 2091, 5, 5, 0, 0, 2090, 2089, 1, 0, 0, 0, 2091, 2094, 1, 0, 0, 0, 2092, 2090, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2095, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2095, 2097, 3, 186, 93, 0, 2096, 2085, 1, 0, 0, 0, 2097, 2100, 1, 0, 0, 0, 2098, 2096, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 185, 1, 0, 0, 0, 2100, 2098, 1, 0, 0, 0, 2101, 2120, 3, 72, 36, 0, 2102, 2117, 3, 70, 35, 0, 2103, 2105, 5, 5, 0, 0, 2104, 2103, 1, 0, 0, 0, 2105, 2108, 1, 0, 0, 0, 2106, 2104, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 1, 0, 0, 0, 2108, 2106, 1, 0, 0, 0, 2109, 2113, 5, 25, 0, 0, 2110, 2112, 5, 5, 0, 0, 2111, 2110, 1, 0, 0, 0, 2112, 2115, 1, 0, 0, 0, 2113, 2111, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2116, 1, 0, 0, 0, 2115, 2113, 1, 0, 0, 0, 2116, 2118, 3, 84, 42, 0, 2117, 2106, 1, 0, 0, 0, 2117, 2118, 1, 0, 0, 0, 2118, 2120, 1, 0, 0, 0, 2119, 2101, 1, 0, 0, 0, 2119, 2102, 1, 0, 0, 0, 2120, 187, 1, 0, 0, 0, 2121, 2136, 5, 62, 0, 0, 2122, 2124, 5, 5, 0, 0, 2123, 2122, 1, 0, 0, 0, 2124, 2127, 1, 0, 0, 0, 2125, 2123, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2128, 2132, 5, 25, 0, 0, 2129, 2131, 5, 5, 0, 0, 2130, 2129, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2135, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2137, 3, 28, 14, 0, 2136, 2125, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2141, 1, 0, 0, 0, 2138, 2140, 5, 5, 0, 0, 2139, 2138, 1, 0, 0, 0, 2140, 2143, 1, 0, 0, 0, 2141, 2139, 1, 0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2145, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2144, 2146, 3, 36, 18, 0, 2145, 2144, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 189, 1, 0, 0, 0, 2147, 2149, 5, 11, 0, 0, 2148, 2150, 3, 118, 59, 0, 2149, 2148, 1, 0, 0, 0, 2149, 2150, 1, 0, 0, 0, 2150, 2155, 1, 0, 0, 0, 2151, 2152, 5, 8, 0, 0, 2152, 2154, 3, 118, 59, 0, 2153, 2151, 1, 0, 0, 0, 2154, 2157, 1, 0, 0, 0, 2155, 2153, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2158, 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2158, 2159, 5, 12, 0, 0, 2159, 191, 1, 0, 0, 0, 2160, 2162, 5, 70, 0, 0, 2161, 2163, 5, 141, 0, 0, 2162, 2161, 1, 0, 0, 0, 2162, 2163, 1, 0, 0, 0, 2163, 193, 1, 0, 0, 0, 2164, 2181, 5, 71, 0, 0, 2165, 2169, 5, 43, 0, 0, 2166, 2168, 5, 5, 0, 0, 2167, 2166, 1, 0, 0, 0, 2168, 2171, 1, 0, 0, 0, 2169, 2167, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2172, 1, 0, 0, 0, 2171, 2169, 1, 0, 0, 0, 2172, 2176, 3, 84, 42, 0, 2173, 2175, 5, 5, 0, 0, 2174, 2173, 1, 0, 0, 0, 2175, 2178, 1, 0, 0, 0, 2176, 2174, 1, 0, 0, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2179, 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2179, 2180, 5, 44, 0, 0, 2180, 2182, 1, 0, 0, 0, 2181, 2165, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2184, 1, 0, 0, 0, 2183, 2185, 5, 141, 0, 0, 2184, 2183, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 195, 1, 0, 0, 0, 2186, 2189, 3, 198, 99, 0, 2187, 2189, 3, 202, 101, 0, 2188, 2186, 1, 0, 0, 0, 2188, 2187, 1, 0, 0, 0, 2189, 197, 1, 0, 0, 0, 2190, 2194, 5, 74, 0, 0, 2191, 2193, 5, 5, 0, 0, 2192, 2191, 1, 0, 0, 0, 2193, 2196, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 2197, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2197, 2198, 5, 9, 0, 0, 2198, 2199, 3, 118, 59, 0, 2199, 2203, 5, 10, 0, 0, 2200, 2202, 5, 5, 0, 0, 2201, 2200, 1, 0, 0, 0, 2202, 2205, 1, 0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2203, 2204, 1, 0, 0, 0, 2204, 2207, 1, 0, 0, 0, 2205, 2203, 1, 0, 0, 0, 2206, 2208, 3, 200, 100, 0, 2207, 2206, 1, 0, 0, 0, 2207, 2208, 1, 0, 0, 0, 2208, 2210, 1, 0, 0, 0, 2209, 2211, 5, 26, 0, 0, 2210, 2209, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2228, 1, 0, 0, 0, 2212, 2214, 5, 5, 0, 0, 2213, 2212, 1, 0, 0, 0, 2214, 2217, 1, 0, 0, 0, 2215, 2213, 1, 0, 0, 0, 2215, 2216, 1, 0, 0, 0, 2216, 2218, 1, 0, 0, 0, 2217, 2215, 1, 0, 0, 0, 2218, 2222, 5, 75, 0, 0, 2219, 2221, 5, 5, 0, 0, 2220, 2219, 1, 0, 0, 0, 2221, 2224, 1, 0, 0, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2226, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2225, 2227, 3, 200, 100, 0, 2226, 2225, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2229, 1, 0, 0, 0, 2228, 2215, 1, 0, 0, 0, 2228, 2229, 1, 0, 0, 0, 2229, 199, 1, 0, 0, 0, 2230, 2233, 3, 108, 54, 0, 2231, 2233, 3, 118, 59, 0, 2232, 2230, 1, 0, 0, 0, 2232, 2231, 1, 0, 0, 0, 2233, 201, 1, 0, 0, 0, 2234, 2238, 5, 76, 0, 0, 2235, 2237, 5, 5, 0, 0, 2236, 2235, 1, 0, 0, 0, 2237, 2240, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, 2245, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2241, 2242, 5, 9, 0, 0, 2242, 2243, 3, 118, 59, 0, 2243, 2244, 5, 10, 0, 0, 2244, 2246, 1, 0, 0, 0, 2245, 2241, 1, 0, 0, 0, 2245, 2246, 1, 0, 0, 0, 2246, 2250, 1, 0, 0, 0, 2247, 2249, 5, 5, 0, 0, 2248, 2247, 1, 0, 0, 0, 2249, 2252, 1, 0, 0, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2251, 1, 0, 0, 0, 2251, 2253, 1, 0, 0, 0, 2252, 2250, 1, 0, 0, 0, 2253, 2257, 5, 13, 0, 0, 2254, 2256, 5, 5, 0, 0, 2255, 2254, 1, 0, 0, 0, 2256, 2259, 1, 0, 0, 0, 2257, 2255, 1, 0, 0, 0, 2257, 2258, 1, 0, 0, 0, 2258, 2269, 1, 0, 0, 0, 2259, 2257, 1, 0, 0, 0, 2260, 2264, 3, 204, 102, 0, 2261, 2263, 5, 5, 0, 0, 2262, 2261, 1, 0, 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2268, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2260, 1, 0, 0, 0, 2268, 2271, 1, 0, 0, 0, 2269, 2267, 1, 0, 0, 0, 2269, 2270, 1, 0, 0, 0, 2270, 2275, 1, 0, 0, 0, 2271, 2269, 1, 0, 0, 0, 2272, 2274, 5, 5, 0, 0, 2273, 2272, 1, 0, 0, 0, 2274, 2277, 1, 0, 0, 0, 2275, 2273, 1, 0, 0, 0, 2275, 2276, 1, 0, 0, 0, 2276, 2278, 1, 0, 0, 0, 2277, 2275, 1, 0, 0, 0, 2278, 2279, 5, 14, 0, 0, 2279, 203, 1, 0, 0, 0, 2280, 2297, 3, 206, 103, 0, 2281, 2283, 5, 5, 0, 0, 2282, 2281, 1, 0, 0, 0, 2283, 2286, 1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 2287, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2291, 5, 8, 0, 0, 2288, 2290, 5, 5, 0, 0, 2289, 2288, 1, 0, 0, 0, 2290, 2293, 1, 0, 0, 0, 2291, 2289, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2294, 1, 0, 0, 0, 2293, 2291, 1, 0, 0, 0, 2294, 2296, 3, 206, 103, 0, 2295, 2284, 1, 0, 0, 0, 2296, 2299, 1, 0, 0, 0, 2297, 2295, 1, 0, 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2303, 1, 0, 0, 0, 2299, 2297, 1, 0, 0, 0, 2300, 2302, 5, 5, 0, 0, 2301, 2300, 1, 0, 0, 0, 2302, 2305, 1, 0, 0, 0, 2303, 2301, 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2306, 1, 0, 0, 0, 2305, 2303, 1, 0, 0, 0, 2306, 2310, 5, 33, 0, 0, 2307, 2309, 5, 5, 0, 0, 2308, 2307, 1, 0, 0, 0, 2309, 2312, 1, 0, 0, 0, 2310, 2308, 1, 0, 0, 0, 2310, 2311, 1, 0, 0, 0, 2311, 2313, 1, 0, 0, 0, 2312, 2310, 1, 0, 0, 0, 2313, 2315, 3, 200, 100, 0, 2314, 2316, 3, 290, 145, 0, 2315, 2314, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2333, 1, 0, 0, 0, 2317, 2321, 5, 75, 0, 0, 2318, 2320, 5, 5, 0, 0, 2319, 2318, 1, 0, 0, 0, 2320, 2323, 1, 0, 0, 0, 2321, 2319, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2321, 1, 0, 0, 0, 2324, 2328, 5, 33, 0, 0, 2325, 2327, 5, 5, 0, 0, 2326, 2325, 1, 0, 0, 0, 2327, 2330, 1, 0, 0, 0, 2328, 2326, 1, 0, 0, 0, 2328, 2329, 1, 0, 0, 0, 2329, 2331, 1, 0, 0, 0, 2330, 2328, 1, 0, 0, 0, 2331, 2333, 3, 200, 100, 0, 2332, 2280, 1, 0, 0, 0, 2332, 2317, 1, 0, 0, 0, 2333, 205, 1, 0, 0, 0, 2334, 2338, 3, 118, 59, 0, 2335, 2338, 3, 208, 104, 0, 2336, 2338, 3, 210, 105, 0, 2337, 2334, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2337, 2336, 1, 0, 0, 0, 2338, 207, 1, 0, 0, 0, 2339, 2343, 3, 236, 118, 0, 2340, 2342, 5, 5, 0, 0, 2341, 2340, 1, 0, 0, 0, 2342, 2345, 1, 0, 0, 0, 2343, 2341, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2346, 1, 0, 0, 0, 2345, 2343, 1, 0, 0, 0, 2346, 2347, 3, 118, 59, 0, 2347, 209, 1, 0, 0, 0, 2348, 2352, 3, 238, 119, 0, 2349, 2351, 5, 5, 0, 0, 2350, 2349, 1, 0, 0, 0, 2351, 2354, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2355, 1, 0, 0, 0, 2354, 2352, 1, 0, 0, 0, 2355, 2356, 3, 84, 42, 0, 2356, 211, 1, 0, 0, 0, 2357, 2361, 5, 77, 0, 0, 2358, 2360, 5, 5, 0, 0, 2359, 2358, 1, 0, 0, 0, 2360, 2363, 1, 0, 0, 0, 2361, 2359, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2361, 1, 0, 0, 0, 2364, 2374, 3, 108, 54, 0, 2365, 2367, 5, 5, 0, 0, 2366, 2365, 1, 0, 0, 0, 2367, 2370, 1, 0, 0, 0, 2368, 2366, 1, 0, 0, 0, 2368, 2369, 1, 0, 0, 0, 2369, 2371, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2371, 2373, 3, 214, 107, 0, 2372, 2368, 1, 0, 0, 0, 2373, 2376, 1, 0, 0, 0, 2374, 2372, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2384, 1, 0, 0, 0, 2376, 2374, 1, 0, 0, 0, 2377, 2379, 5, 5, 0, 0, 2378, 2377, 1, 0, 0, 0, 2379, 2382, 1, 0, 0, 0, 2380, 2378, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 2383, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 2385, 3, 216, 108, 0, 2384, 2380, 1, 0, 0, 0, 2384, 2385, 1, 0, 0, 0, 2385, 213, 1, 0, 0, 0, 2386, 2390, 5, 78, 0, 0, 2387, 2389, 5, 5, 0, 0, 2388, 2387, 1, 0, 0, 0, 2389, 2392, 1, 0, 0, 0, 2390, 2388, 1, 0, 0, 0, 2390, 2391, 1, 0, 0, 0, 2391, 2393, 1, 0, 0, 0, 2392, 2390, 1, 0, 0, 0, 2393, 2397, 5, 9, 0, 0, 2394, 2396, 3, 276, 138, 0, 2395, 2394, 1, 0, 0, 0, 2396, 2399, 1, 0, 0, 0, 2397, 2395, 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 2400, 1, 0, 0, 0, 2399, 2397, 1, 0, 0, 0, 2400, 2401, 3, 288, 144, 0, 2401, 2402, 5, 25, 0, 0, 2402, 2403, 3, 98, 49, 0, 2403, 2407, 5, 10, 0, 0, 2404, 2406, 5, 5, 0, 0, 2405, 2404, 1, 0, 0, 0, 2406, 2409, 1, 0, 0, 0, 2407, 2405, 1, 0, 0, 0, 2407, 2408, 1, 0, 0, 0, 2408, 2410, 1, 0, 0, 0, 2409, 2407, 1, 0, 0, 0, 2410, 2411, 3, 108, 54, 0, 2411, 215, 1, 0, 0, 0, 2412, 2416, 5, 79, 0, 0, 2413, 2415, 5, 5, 0, 0, 2414, 2413, 1, 0, 0, 0, 2415, 2418, 1, 0, 0, 0, 2416, 2414, 1, 0, 0, 0, 2416, 2417, 1, 0, 0, 0, 2417, 2419, 1, 0, 0, 0, 2418, 2416, 1, 0, 0, 0, 2419, 2420, 3, 108, 54, 0, 2420, 217, 1, 0, 0, 0, 2421, 2425, 3, 220, 110, 0, 2422, 2425, 3, 222, 111, 0, 2423, 2425, 3, 224, 112, 0, 2424, 2421, 1, 0, 0, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2423, 1, 0, 0, 0, 2425, 219, 1, 0, 0, 0, 2426, 2430, 5, 80, 0, 0, 2427, 2429, 5, 5, 0, 0, 2428, 2427, 1, 0, 0, 0, 2429, 2432, 1, 0, 0, 0, 2430, 2428, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2433, 1, 0, 0, 0, 2432, 2430, 1, 0, 0, 0, 2433, 2437, 5, 9, 0, 0, 2434, 2436, 3, 276, 138, 0, 2435, 2434, 1, 0, 0, 0, 2436, 2439, 1, 0, 0, 0, 2437, 2435, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2442, 1, 0, 0, 0, 2439, 2437, 1, 0, 0, 0, 2440, 2443, 3, 72, 36, 0, 2441, 2443, 3, 70, 35, 0, 2442, 2440, 1, 0, 0, 0, 2442, 2441, 1, 0, 0, 0, 2443, 2444, 1, 0, 0, 0, 2444, 2445, 5, 89, 0, 0, 2445, 2446, 3, 118, 59, 0, 2446, 2450, 5, 10, 0, 0, 2447, 2449, 5, 5, 0, 0, 2448, 2447, 1, 0, 0, 0, 2449, 2452, 1, 0, 0, 0, 2450, 2448, 1, 0, 0, 0, 2450, 2451, 1, 0, 0, 0, 2451, 2454, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2453, 2455, 3, 200, 100, 0, 2454, 2453, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 221, 1, 0, 0, 0, 2456, 2460, 5, 82, 0, 0, 2457, 2459, 5, 5, 0, 0, 2458, 2457, 1, 0, 0, 0, 2459, 2462, 1, 0, 0, 0, 2460, 2458, 1, 0, 0, 0, 2460, 2461, 1, 0, 0, 0, 2461, 2463, 1, 0, 0, 0, 2462, 2460, 1, 0, 0, 0, 2463, 2464, 5, 9, 0, 0, 2464, 2465, 3, 118, 59, 0, 2465, 2469, 5, 10, 0, 0, 2466, 2468, 5, 5, 0, 0, 2467, 2466, 1, 0, 0, 0, 2468, 2471, 1, 0, 0, 0, 2469, 2467, 1, 0, 0, 0, 2469, 2470, 1, 0, 0, 0, 2470, 2473, 1, 0, 0, 0, 2471, 2469, 1, 0, 0, 0, 2472, 2474, 3, 200, 100, 0, 2473, 2472, 1, 0, 0, 0, 2473, 2474, 1, 0, 0, 0, 2474, 223, 1, 0, 0, 0, 2475, 2479, 5, 81, 0, 0, 2476, 2478, 5, 5, 0, 0, 2477, 2476, 1, 0, 0, 0, 2478, 2481, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2479, 2480, 1, 0, 0, 0, 2480, 2483, 1, 0, 0, 0, 2481, 2479, 1, 0, 0, 0, 2482, 2484, 3, 200, 100, 0, 2483, 2482, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2488, 1, 0, 0, 0, 2485, 2487, 5, 5, 0, 0, 2486, 2485, 1, 0, 0, 0, 2487, 2490, 1, 0, 0, 0, 2488, 2486, 1, 0, 0, 0, 2488, 2489, 1, 0, 0, 0, 2489, 2491, 1, 0, 0, 0, 2490, 2488, 1, 0, 0, 0, 2491, 2495, 5, 82, 0, 0, 2492, 2494, 5, 5, 0, 0, 2493, 2492, 1, 0, 0, 0, 2494, 2497, 1, 0, 0, 0, 2495, 2493, 1, 0, 0, 0, 2495, 2496, 1, 0, 0, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2495, 1, 0, 0, 0, 2498, 2499, 5, 9, 0, 0, 2499, 2500, 3, 118, 59, 0, 2500, 2501, 5, 10, 0, 0, 2501, 225, 1, 0, 0, 0, 2502, 2506, 5, 83, 0, 0, 2503, 2505, 5, 5, 0, 0, 2504, 2503, 1, 0, 0, 0, 2505, 2508, 1, 0, 0, 0, 2506, 2504, 1, 0, 0, 0, 2506, 2507, 1, 0, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2506, 1, 0, 0, 0, 2509, 2519, 3, 118, 59, 0, 2510, 2512, 7, 5, 0, 0, 2511, 2513, 3, 118, 59, 0, 2512, 2511, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2519, 1, 0, 0, 0, 2514, 2519, 5, 85, 0, 0, 2515, 2519, 5, 54, 0, 0, 2516, 2519, 5, 86, 0, 0, 2517, 2519, 5, 55, 0, 0, 2518, 2502, 1, 0, 0, 0, 2518, 2510, 1, 0, 0, 0, 2518, 2514, 1, 0, 0, 0, 2518, 2515, 1, 0, 0, 0, 2518, 2516, 1, 0, 0, 0, 2518, 2517, 1, 0, 0, 0, 2519, 227, 1, 0, 0, 0, 2520, 2530, 3, 98, 49, 0, 2521, 2525, 5, 41, 0, 0, 2522, 2524, 5, 5, 0, 0, 2523, 2522, 1, 0, 0, 0, 2524, 2527, 1, 0, 0, 0, 2525, 2523, 1, 0, 0, 0, 2525, 2526, 1, 0, 0, 0, 2526, 2529, 1, 0, 0, 0, 2527, 2525, 1, 0, 0, 0, 2528, 2521, 1, 0, 0, 0, 2529, 2532, 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2534, 1, 0, 0, 0, 2532, 2530, 1, 0, 0, 0, 2533, 2520, 1, 0, 0, 0, 2533, 2534, 1, 0, 0, 0, 2534, 2538, 1, 0, 0, 0, 2535, 2537, 5, 5, 0, 0, 2536, 2535, 1, 0, 0, 0, 2537, 2540, 1, 0, 0, 0, 2538, 2536, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, 2539, 2541, 1, 0, 0, 0, 2540, 2538, 1, 0, 0, 0, 2541, 2545, 7, 6, 0, 0, 2542, 2544, 5, 5, 0, 0, 2543, 2542, 1, 0, 0, 0, 2544, 2547, 1, 0, 0, 0, 2545, 2543, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2550, 1, 0, 0, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2551, 3, 286, 143, 0, 2549, 2551, 5, 59, 0, 0, 2550, 2548, 1, 0, 0, 0, 2550, 2549, 1, 0, 0, 0, 2551, 2568, 1, 0, 0, 0, 2552, 2556, 5, 70, 0, 0, 2553, 2555, 5, 5, 0, 0, 2554, 2553, 1, 0, 0, 0, 2555, 2558, 1, 0, 0, 0, 2556, 2554, 1, 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2559, 1, 0, 0, 0, 2558, 2556, 1, 0, 0, 0, 2559, 2563, 5, 36, 0, 0, 2560, 2562, 5, 5, 0, 0, 2561, 2560, 1, 0, 0, 0, 2562, 2565, 1, 0, 0, 0, 2563, 2561, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2566, 1, 0, 0, 0, 2565, 2563, 1, 0, 0, 0, 2566, 2568, 5, 59, 0, 0, 2567, 2533, 1, 0, 0, 0, 2567, 2552, 1, 0, 0, 0, 2568, 229, 1, 0, 0, 0, 2569, 2570, 7, 7, 0, 0, 2570, 231, 1, 0, 0, 0, 2571, 2572, 7, 8, 0, 0, 2572, 233, 1, 0, 0, 0, 2573, 2574, 7, 9, 0, 0, 2574, 235, 1, 0, 0, 0, 2575, 2576, 7, 10, 0, 0, 2576, 237, 1, 0, 0, 0, 2577, 2578, 7, 11, 0, 0, 2578, 239, 1, 0, 0, 0, 2579, 2580, 7, 12, 0, 0, 2580, 241, 1, 0, 0, 0, 2581, 2582, 7, 13, 0, 0, 2582, 243, 1, 0, 0, 0, 2583, 2584, 7, 14, 0, 0, 2584, 245, 1, 0, 0, 0, 2585, 2593, 5, 20, 0, 0, 2586, 2593, 5, 21, 0, 0, 2587, 2593, 5, 18, 0, 0, 2588, 2593, 5, 19, 0, 0, 2589, 2593, 5, 24, 0, 0, 2590, 2593, 3, 276, 138, 0, 2591, 2593, 3, 274, 137, 0, 2592, 2585, 1, 0, 0, 0, 2592, 2586, 1, 0, 0, 0, 2592, 2587, 1, 0, 0, 0, 2592, 2588, 1, 0, 0, 0, 2592, 2589, 1, 0, 0, 0, 2592, 2590, 1, 0, 0, 0, 2592, 2591, 1, 0, 0, 0, 2593, 247, 1, 0, 0, 0, 2594, 2610, 5, 20, 0, 0, 2595, 2610, 5, 21, 0, 0, 2596, 2597, 5, 24, 0, 0, 2597, 2610, 5, 24, 0, 0, 2598, 2610, 3, 150, 75, 0, 2599, 2610, 3, 154, 77, 0, 2600, 2602, 5, 5, 0, 0, 2601, 2600, 1, 0, 0, 0, 2602, 2605, 1, 0, 0, 0, 2603, 2601, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2603, 1, 0, 0, 0, 2606, 2607, 3, 250, 125, 0, 2607, 2608, 3, 144, 72, 0, 2608, 2610, 1, 0, 0, 0, 2609, 2594, 1, 0, 0, 0, 2609, 2595, 1, 0, 0, 0, 2609, 2596, 1, 0, 0, 0, 2609, 2598, 1, 0, 0, 0, 2609, 2599, 1, 0, 0, 0, 2609, 2603, 1, 0, 0, 0, 2610, 249, 1, 0, 0, 0, 2611, 2615, 5, 7, 0, 0, 2612, 2613, 5, 41, 0, 0, 2613, 2615, 5, 7, 0, 0, 2614, 2611, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2615, 251, 1, 0, 0, 0, 2616, 2619, 3, 276, 138, 0, 2617, 2619, 3, 254, 127, 0, 2618, 2616, 1, 0, 0, 0, 2618, 2617, 1, 0, 0, 0, 2619, 2620, 1, 0, 0, 0, 2620, 2618, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 253, 1, 0, 0, 0, 2622, 2632, 3, 256, 128, 0, 2623, 2632, 3, 258, 129, 0, 2624, 2632, 3, 260, 130, 0, 2625, 2632, 3, 262, 131, 0, 2626, 2632, 3, 264, 132, 0, 2627, 2632, 3, 266, 133, 0, 2628, 2632, 3, 268, 134, 0, 2629, 2632, 3, 270, 135, 0, 2630, 2632, 3, 272, 136, 0, 2631, 2622, 1, 0, 0, 0, 2631, 2623, 1, 0, 0, 0, 2631, 2624, 1, 0, 0, 0, 2631, 2625, 1, 0, 0, 0, 2631, 2626, 1, 0, 0, 0, 2631, 2627, 1, 0, 0, 0, 2631, 2628, 1, 0, 0, 0, 2631, 2629, 1, 0, 0, 0, 2631, 2630, 1, 0, 0, 0, 2632, 2636, 1, 0, 0, 0, 2633, 2635, 5, 5, 0, 0, 2634, 2633, 1, 0, 0, 0, 2635, 2638, 1, 0, 0, 0, 2636, 2634, 1, 0, 0, 0, 2636, 2637, 1, 0, 0, 0, 2637, 255, 1, 0, 0, 0, 2638, 2636, 1, 0, 0, 0, 2639, 2640, 7, 15, 0, 0, 2640, 257, 1, 0, 0, 0, 2641, 2642, 7, 16, 0, 0, 2642, 259, 1, 0, 0, 0, 2643, 2644, 7, 17, 0, 0, 2644, 261, 1, 0, 0, 0, 2645, 2646, 7, 18, 0, 0, 2646, 263, 1, 0, 0, 0, 2647, 2648, 7, 19, 0, 0, 2648, 265, 1, 0, 0, 0, 2649, 2650, 5, 123, 0, 0, 2650, 267, 1, 0, 0, 0, 2651, 2652, 7, 20, 0, 0, 2652, 269, 1, 0, 0, 0, 2653, 2654, 7, 21, 0, 0, 2654, 271, 1, 0, 0, 0, 2655, 2656, 5, 128, 0, 0, 2656, 273, 1, 0, 0, 0, 2657, 2661, 5, 142, 0, 0, 2658, 2660, 5, 5, 0, 0, 2659, 2658, 1, 0, 0, 0, 2660, 2663, 1, 0, 0, 0, 2661, 2659, 1, 0, 0, 0, 2661, 2662, 1, 0, 0, 0, 2662, 275, 1, 0, 0, 0, 2663, 2661, 1, 0, 0, 0, 2664, 2667, 3, 278, 139, 0, 2665, 2667, 3, 280, 140, 0, 2666, 2664, 1, 0, 0, 0, 2666, 2665, 1, 0, 0, 0, 2667, 2671, 1, 0, 0, 0, 2668, 2670, 5, 5, 0, 0, 2669, 2668, 1, 0, 0, 0, 2670, 2673, 1, 0, 0, 0, 2671, 2669, 1, 0, 0, 0, 2671, 2672, 1, 0, 0, 0, 2672, 277, 1, 0, 0, 0, 2673, 2671, 1, 0, 0, 0, 2674, 2678, 3, 282, 141, 0, 2675, 2677, 5, 5, 0, 0, 2676, 2675, 1, 0, 0, 0, 2677, 2680, 1, 0, 0, 0, 2678, 2676, 1, 0, 0, 0, 2678, 2679, 1, 0, 0, 0, 2679, 2681, 1, 0, 0, 0, 2680, 2678, 1, 0, 0, 0, 2681, 2685, 5, 25, 0, 0, 2682, 2684, 5, 5, 0, 0, 2683, 2682, 1, 0, 0, 0, 2684, 2687, 1, 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, 2685, 1, 0, 0, 0, 2688, 2689, 3, 284, 142, 0, 2689, 2729, 1, 0, 0, 0, 2690, 2707, 5, 141, 0, 0, 2691, 2693, 5, 5, 0, 0, 2692, 2691, 1, 0, 0, 0, 2693, 2696, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2694, 2695, 1, 0, 0, 0, 2695, 2697, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2697, 2701, 5, 7, 0, 0, 2698, 2700, 5, 5, 0, 0, 2699, 2698, 1, 0, 0, 0, 2700, 2703, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2704, 1, 0, 0, 0, 2703, 2701, 1, 0, 0, 0, 2704, 2706, 3, 288, 144, 0, 2705, 2694, 1, 0, 0, 0, 2706, 2709, 1, 0, 0, 0, 2707, 2705, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2717, 1, 0, 0, 0, 2709, 2707, 1, 0, 0, 0, 2710, 2712, 5, 5, 0, 0, 2711, 2710, 1, 0, 0, 0, 2712, 2715, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 2716, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2716, 2718, 3, 158, 79, 0, 2717, 2713, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 2726, 1, 0, 0, 0, 2719, 2721, 5, 5, 0, 0, 2720, 2719, 1, 0, 0, 0, 2721, 2724, 1, 0, 0, 0, 2722, 2720, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, 2725, 1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2725, 2727, 3, 156, 78, 0, 2726, 2722, 1, 0, 0, 0, 2726, 2727, 1, 0, 0, 0, 2727, 2729, 1, 0, 0, 0, 2728, 2674, 1, 0, 0, 0, 2728, 2690, 1, 0, 0, 0, 2729, 279, 1, 0, 0, 0, 2730, 2731, 3, 282, 141, 0, 2731, 2732, 5, 25, 0, 0, 2732, 2734, 5, 11, 0, 0, 2733, 2735, 3, 284, 142, 0, 2734, 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 2734, 1, 0, 0, 0, 2736, 2737, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 2739, 5, 12, 0, 0, 2739, 2750, 1, 0, 0, 0, 2740, 2741, 5, 40, 0, 0, 2741, 2743, 5, 11, 0, 0, 2742, 2744, 3, 284, 142, 0, 2743, 2742, 1, 0, 0, 0, 2744, 2745, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2746, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, 2747, 2748, 5, 12, 0, 0, 2748, 2750, 1, 0, 0, 0, 2749, 2730, 1, 0, 0, 0, 2749, 2740, 1, 0, 0, 0, 2750, 281, 1, 0, 0, 0, 2751, 2752, 7, 22, 0, 0, 2752, 283, 1, 0, 0, 0, 2753, 2755, 3, 286, 143, 0, 2754, 2756, 3, 158, 79, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2758, 1, 0, 0, 0, 2757, 2759, 3, 156, 78, 0, 2758, 2757, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 285, 1, 0, 0, 0, 2760, 2771, 3, 288, 144, 0, 2761, 2763, 5, 5, 0, 0, 2762, 2761, 1, 0, 0, 0, 2763, 2766, 1, 0, 0, 0, 2764, 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 2767, 1, 0, 0, 0, 2766, 2764, 1, 0, 0, 0, 2767, 2768, 5, 7, 0, 0, 2768, 2770, 3, 288, 144, 0, 2769, 2764, 1, 0, 0, 0, 2770, 2773, 1, 0, 0, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 287, 1, 0, 0, 0, 2773, 2771, 1, 0, 0, 0, 2774, 2775, 7, 23, 0, 0, 2775, 289, 1, 0, 0, 0, 2776, 2778, 5, 5, 0, 0, 2777, 2776, 1, 0, 0, 0, 2778, 2779, 1, 0, 0, 0, 2779, 2777, 1, 0, 0, 0, 2779, 2780, 1, 0, 0, 0, 2780, 2795, 1, 0, 0, 0, 2781, 2783, 5, 5, 0, 0, 2782, 2781, 1, 0, 0, 0, 2783, 2786, 1, 0, 0, 0, 2784, 2782, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2787, 1, 0, 0, 0, 2786, 2784, 1, 0, 0, 0, 2787, 2791, 5, 26, 0, 0, 2788, 2790, 5, 5, 0, 0, 2789, 2788, 1, 0, 0, 0, 2790, 2793, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 2795, 1, 0, 0, 0, 2793, 2791, 1, 0, 0, 0, 2794, 2777, 1, 0, 0, 0, 2794, 2784, 1, 0, 0, 0, 2795, 291, 1, 0, 0, 0, 2796, 2797, 7, 24, 0, 0, 2797, 293, 1, 0, 0, 0, 429, 297, 304, 311, 314, 318, 321, 328, 335, 342, 345, 349, 352, 357, 365, 373, 378, 381, 385, 388, 393, 395, 400, 408, 411, 421, 424, 430, 437, 441, 446, 450, 455, 462, 466, 471, 475, 480, 487, 491, 494, 500, 503, 513, 517, 519, 524, 527, 534, 539, 546, 553, 559, 565, 571, 580, 587, 596, 602, 608, 621, 626, 632, 638, 644, 651, 658, 662, 667, 671, 677, 685, 689, 695, 699, 704, 711, 717, 720, 725, 734, 739, 742, 747, 754, 758, 763, 767, 772, 776, 779, 785, 792, 797, 802, 806, 811, 818, 823, 828, 832, 837, 844, 851, 855, 860, 864, 869, 873, 881, 885, 887, 892, 897, 904, 909, 916, 920, 923, 929, 936, 940, 945, 952, 956, 961, 965, 968, 974, 978, 984, 988, 993, 1000, 1004, 1009, 1013, 1016, 1022, 1026, 1031, 1038, 1043, 1048, 1053, 1058, 1062, 1067, 1074, 1078, 1083, 1090, 1095, 1102, 1104, 1112, 1120, 1123, 1127, 1133, 1141, 1148, 1152, 1157, 1165, 1169, 1171, 1174, 1178, 1184, 1190, 1192, 1197, 1203, 1208, 1211, 1217, 1224, 1228, 1233, 1240, 1249, 1256, 1263, 1269, 1275, 1279, 1284, 1290, 1295, 1300, 1305, 1312, 1316, 1319, 1325, 1332, 1335, 1337, 1345, 1350, 1356, 1364, 1370, 1377, 1380, 1386, 1393, 1401, 1407, 1414, 1420, 1427, 1431, 1437, 1442, 1447, 1454, 1459, 1463, 1469, 1473, 1478, 1487, 1494, 1501, 1507, 1513, 1520, 1527, 1539, 1546, 1549, 1553, 1556, 1560, 1565, 1571, 1579, 1586, 1594, 1601, 1608, 1614, 1621, 1628, 1634, 1642, 1649, 1657, 1662, 1669, 1676, 1682, 1687, 1693, 1700, 1706, 1714, 1721, 1729, 1735, 1743, 1750, 1758, 1765, 1772, 1780, 1786, 1793, 1798, 1815, 1823, 1828, 1835, 1841, 1843, 1848, 1852, 1857, 1868, 1871, 1881, 1887, 1891, 1893, 1901, 1908, 1915, 1921, 1925, 1930, 1935, 1938, 1942, 1947, 1953, 1960, 1963, 1966, 1971, 1985, 1989, 1994, 1996, 2006, 2008, 2028, 2035, 2042, 2051, 2058, 2065, 2072, 2077, 2080, 2085, 2092, 2098, 2106, 2113, 2117, 2119, 2125, 2132, 2136, 2141, 2145, 2149, 2155, 2162, 2169, 2176, 2181, 2184, 2188, 2194, 2203, 2207, 2210, 2215, 2222, 2226, 2228, 2232, 2238, 2245, 2250, 2257, 2264, 2269, 2275, 2284, 2291, 2297, 2303, 2310, 2315, 2321, 2328, 2332, 2337, 2343, 2352, 2361, 2368, 2374, 2380, 2384, 2390, 2397, 2407, 2416, 2424, 2430, 2437, 2442, 2450, 2454, 2460, 2469, 2473, 2479, 2483, 2488, 2495, 2506, 2512, 2518, 2525, 2530, 2533, 2538, 2545, 2550, 2556, 2563, 2567, 2592, 2603, 2609, 2614, 2618, 2620, 2631, 2636, 2661, 2666, 2671, 2678, 2685, 2694, 2701, 2707, 2713, 2717, 2722, 2726, 2728, 2736, 2745, 2749, 2755, 2758, 2764, 2771, 2779, 2784, 2791, 2794] \ No newline at end of file diff --git a/src/main/java/KotlinParser.java b/src/main/java/KotlinParser.java new file mode 100644 index 0000000..d52ce4a --- /dev/null +++ b/src/main/java/KotlinParser.java @@ -0,0 +1,19417 @@ +// Generated from KotlinParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.Utils; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.TerminalNode; + +import java.util.List; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class KotlinParser extends Parser { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ShebangLine = 1, DelimitedComment = 2, LineComment = 3, WS = 4, NL = 5, RESERVED = 6, + DOT = 7, COMMA = 8, LPAREN = 9, RPAREN = 10, LSQUARE = 11, RSQUARE = 12, LCURL = 13, + RCURL = 14, MULT = 15, MOD = 16, DIV = 17, ADD = 18, SUB = 19, INCR = 20, DECR = 21, CONJ = 22, + DISJ = 23, EXCL = 24, COLON = 25, SEMICOLON = 26, ASSIGNMENT = 27, ADD_ASSIGNMENT = 28, + SUB_ASSIGNMENT = 29, MULT_ASSIGNMENT = 30, DIV_ASSIGNMENT = 31, MOD_ASSIGNMENT = 32, + ARROW = 33, DOUBLE_ARROW = 34, RANGE = 35, COLONCOLON = 36, Q_COLONCOLON = 37, DOUBLE_SEMICOLON = 38, + HASH = 39, AT = 40, QUEST = 41, ELVIS = 42, LANGLE = 43, RANGLE = 44, LE = 45, GE = 46, + EXCL_EQ = 47, EXCL_EQEQ = 48, AS_SAFE = 49, EQEQ = 50, EQEQEQ = 51, SINGLE_QUOTE = 52, + RETURN_AT = 53, CONTINUE_AT = 54, BREAK_AT = 55, FILE = 56, PACKAGE = 57, IMPORT = 58, + CLASS = 59, INTERFACE = 60, FUN = 61, OBJECT = 62, VAL = 63, VAR = 64, TYPE_ALIAS = 65, + CONSTRUCTOR = 66, BY = 67, COMPANION = 68, INIT = 69, THIS = 70, SUPER = 71, TYPEOF = 72, + WHERE = 73, IF = 74, ELSE = 75, WHEN = 76, TRY = 77, CATCH = 78, FINALLY = 79, FOR = 80, + DO = 81, WHILE = 82, THROW = 83, RETURN = 84, CONTINUE = 85, BREAK = 86, AS = 87, IS = 88, + IN = 89, NOT_IS = 90, NOT_IN = 91, OUT = 92, FIELD = 93, PROPERTY = 94, GET = 95, SET = 96, + GETTER = 97, SETTER = 98, RECEIVER = 99, PARAM = 100, SETPARAM = 101, DELEGATE = 102, + DYNAMIC = 103, PUBLIC = 104, PRIVATE = 105, PROTECTED = 106, INTERNAL = 107, ENUM = 108, + SEALED = 109, ANNOTATION = 110, DATA = 111, INNER = 112, TAILREC = 113, OPERATOR = 114, + INLINE = 115, INFIX = 116, EXTERNAL = 117, SUSPEND = 118, OVERRIDE = 119, ABSTRACT = 120, + FINAL = 121, OPEN = 122, CONST = 123, LATEINIT = 124, VARARG = 125, NOINLINE = 126, + CROSSINLINE = 127, REIFIED = 128, QUOTE_OPEN = 129, TRIPLE_QUOTE_OPEN = 130, RealLiteral = 131, + FloatLiteral = 132, DoubleLiteral = 133, LongLiteral = 134, IntegerLiteral = 135, + HexLiteral = 136, BinLiteral = 137, BooleanLiteral = 138, NullLiteral = 139, Identifier = 140, + LabelReference = 141, LabelDefinition = 142, FieldIdentifier = 143, CharacterLiteral = 144, + UNICODE_CLASS_LL = 145, UNICODE_CLASS_LM = 146, UNICODE_CLASS_LO = 147, UNICODE_CLASS_LT = 148, + UNICODE_CLASS_LU = 149, UNICODE_CLASS_ND = 150, UNICODE_CLASS_NL = 151, Inside_Comment = 152, + Inside_WS = 153, Inside_NL = 154, QUOTE_CLOSE = 155, LineStrRef = 156, LineStrText = 157, + LineStrEscapedChar = 158, LineStrExprStart = 159, TRIPLE_QUOTE_CLOSE = 160, + MultiLineStringQuote = 161, MultiLineStrRef = 162, MultiLineStrText = 163, MultiLineStrEscapedChar = 164, + MultiLineStrExprStart = 165, MultiLineNL = 166, StrExpr_IN = 167, StrExpr_Comment = 168, + StrExpr_WS = 169, StrExpr_NL = 170; + public static final int + RULE_kotlinFile = 0, RULE_script = 1, RULE_preamble = 2, RULE_fileAnnotations = 3, + RULE_fileAnnotation = 4, RULE_packageHeader = 5, RULE_importList = 6, + RULE_importHeader = 7, RULE_importAlias = 8, RULE_topLevelObject = 9, + RULE_classDeclaration = 10, RULE_primaryConstructor = 11, RULE_classParameters = 12, + RULE_classParameter = 13, RULE_delegationSpecifiers = 14, RULE_delegationSpecifier = 15, + RULE_constructorInvocation = 16, RULE_explicitDelegation = 17, RULE_classBody = 18, + RULE_classMemberDeclaration = 19, RULE_anonymousInitializer = 20, RULE_secondaryConstructor = 21, + RULE_constructorDelegationCall = 22, RULE_enumClassBody = 23, RULE_enumEntries = 24, + RULE_enumEntry = 25, RULE_functionDeclaration = 26, RULE_functionValueParameters = 27, + RULE_functionValueParameter = 28, RULE_parameter = 29, RULE_receiverType = 30, + RULE_functionBody = 31, RULE_objectDeclaration = 32, RULE_companionObject = 33, + RULE_propertyDeclaration = 34, RULE_multiVariableDeclaration = 35, RULE_variableDeclaration = 36, + RULE_getter = 37, RULE_setter = 38, RULE_typeAlias = 39, RULE_typeParameters = 40, + RULE_typeParameter = 41, RULE_type = 42, RULE_typeModifierList = 43, RULE_parenthesizedType = 44, + RULE_nullableType = 45, RULE_typeReference = 46, RULE_functionType = 47, + RULE_functionTypeReceiver = 48, RULE_userType = 49, RULE_simpleUserType = 50, + RULE_functionTypeParameters = 51, RULE_typeConstraints = 52, RULE_typeConstraint = 53, + RULE_block = 54, RULE_statements = 55, RULE_statement = 56, RULE_blockLevelExpression = 57, + RULE_declaration = 58, RULE_expression = 59, RULE_disjunction = 60, RULE_conjunction = 61, + RULE_equalityComparison = 62, RULE_comparison = 63, RULE_namedInfix = 64, + RULE_elvisExpression = 65, RULE_infixFunctionCall = 66, RULE_rangeExpression = 67, + RULE_additiveExpression = 68, RULE_multiplicativeExpression = 69, RULE_typeRHS = 70, + RULE_prefixUnaryExpression = 71, RULE_postfixUnaryExpression = 72, RULE_atomicExpression = 73, + RULE_parenthesizedExpression = 74, RULE_callSuffix = 75, RULE_annotatedLambda = 76, + RULE_arrayAccess = 77, RULE_valueArguments = 78, RULE_typeArguments = 79, + RULE_typeProjection = 80, RULE_typeProjectionModifierList = 81, RULE_valueArgument = 82, + RULE_literalConstant = 83, RULE_stringLiteral = 84, RULE_lineStringLiteral = 85, + RULE_multiLineStringLiteral = 86, RULE_lineStringContent = 87, RULE_lineStringExpression = 88, + RULE_multiLineStringContent = 89, RULE_multiLineStringExpression = 90, + RULE_functionLiteral = 91, RULE_lambdaParameters = 92, RULE_lambdaParameter = 93, + RULE_objectLiteral = 94, RULE_collectionLiteral = 95, RULE_thisExpression = 96, + RULE_superExpression = 97, RULE_conditionalExpression = 98, RULE_ifExpression = 99, + RULE_controlStructureBody = 100, RULE_whenExpression = 101, RULE_whenEntry = 102, + RULE_whenCondition = 103, RULE_rangeTest = 104, RULE_typeTest = 105, RULE_tryExpression = 106, + RULE_catchBlock = 107, RULE_finallyBlock = 108, RULE_loopExpression = 109, + RULE_forExpression = 110, RULE_whileExpression = 111, RULE_doWhileExpression = 112, + RULE_jumpExpression = 113, RULE_callableReference = 114, RULE_assignmentOperator = 115, + RULE_equalityOperation = 116, RULE_comparisonOperator = 117, RULE_inOperator = 118, + RULE_isOperator = 119, RULE_additiveOperator = 120, RULE_multiplicativeOperation = 121, + RULE_typeOperation = 122, RULE_prefixUnaryOperation = 123, RULE_postfixUnaryOperation = 124, + RULE_memberAccessOperator = 125, RULE_modifierList = 126, RULE_modifier = 127, + RULE_classModifier = 128, RULE_memberModifier = 129, RULE_visibilityModifier = 130, + RULE_varianceAnnotation = 131, RULE_functionModifier = 132, RULE_propertyModifier = 133, + RULE_inheritanceModifier = 134, RULE_parameterModifier = 135, RULE_typeParameterModifier = 136, + RULE_labelDefinition = 137, RULE_annotations = 138, RULE_annotation = 139, + RULE_annotationList = 140, RULE_annotationUseSiteTarget = 141, RULE_unescapedAnnotation = 142, + RULE_identifier = 143, RULE_simpleIdentifier = 144, RULE_semi = 145, RULE_anysemi = 146; + + private static String[] makeRuleNames() { + return new String[]{ + "kotlinFile", "script", "preamble", "fileAnnotations", "fileAnnotation", + "packageHeader", "importList", "importHeader", "importAlias", "topLevelObject", + "classDeclaration", "primaryConstructor", "classParameters", "classParameter", + "delegationSpecifiers", "delegationSpecifier", "constructorInvocation", + "explicitDelegation", "classBody", "classMemberDeclaration", "anonymousInitializer", + "secondaryConstructor", "constructorDelegationCall", "enumClassBody", + "enumEntries", "enumEntry", "functionDeclaration", "functionValueParameters", + "functionValueParameter", "parameter", "receiverType", "functionBody", + "objectDeclaration", "companionObject", "propertyDeclaration", "multiVariableDeclaration", + "variableDeclaration", "getter", "setter", "typeAlias", "typeParameters", + "typeParameter", "type", "typeModifierList", "parenthesizedType", "nullableType", + "typeReference", "functionType", "functionTypeReceiver", "userType", + "simpleUserType", "functionTypeParameters", "typeConstraints", "typeConstraint", + "block", "statements", "statement", "blockLevelExpression", "declaration", + "expression", "disjunction", "conjunction", "equalityComparison", "comparison", + "namedInfix", "elvisExpression", "infixFunctionCall", "rangeExpression", + "additiveExpression", "multiplicativeExpression", "typeRHS", "prefixUnaryExpression", + "postfixUnaryExpression", "atomicExpression", "parenthesizedExpression", + "callSuffix", "annotatedLambda", "arrayAccess", "valueArguments", "typeArguments", + "typeProjection", "typeProjectionModifierList", "valueArgument", "literalConstant", + "stringLiteral", "lineStringLiteral", "multiLineStringLiteral", "lineStringContent", + "lineStringExpression", "multiLineStringContent", "multiLineStringExpression", + "functionLiteral", "lambdaParameters", "lambdaParameter", "objectLiteral", + "collectionLiteral", "thisExpression", "superExpression", "conditionalExpression", + "ifExpression", "controlStructureBody", "whenExpression", "whenEntry", + "whenCondition", "rangeTest", "typeTest", "tryExpression", "catchBlock", + "finallyBlock", "loopExpression", "forExpression", "whileExpression", + "doWhileExpression", "jumpExpression", "callableReference", "assignmentOperator", + "equalityOperation", "comparisonOperator", "inOperator", "isOperator", + "additiveOperator", "multiplicativeOperation", "typeOperation", "prefixUnaryOperation", + "postfixUnaryOperation", "memberAccessOperator", "modifierList", "modifier", + "classModifier", "memberModifier", "visibilityModifier", "varianceAnnotation", + "functionModifier", "propertyModifier", "inheritanceModifier", "parameterModifier", + "typeParameterModifier", "labelDefinition", "annotations", "annotation", + "annotationList", "annotationUseSiteTarget", "unescapedAnnotation", "identifier", + "simpleIdentifier", "semi", "anysemi" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, null, null, null, null, null, "'...'", "'.'", "','", "'('", null, + "'['", null, "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", + "'--'", "'&&'", "'||'", "'!'", "':'", "';'", "'='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "'?::'", "';;'", "'#'", + "'@'", "'?'", "'?:'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", + "'as?'", "'=='", "'==='", "'''", null, null, null, "'@file'", "'package'", + "'import'", "'class'", "'interface'", "'fun'", "'object'", "'val'", "'var'", + "'typealias'", "'constructor'", "'by'", "'companion'", "'init'", "'this'", + "'super'", "'typeof'", "'where'", "'if'", "'else'", "'when'", "'try'", + "'catch'", "'finally'", "'for'", "'do'", "'while'", "'throw'", "'return'", + "'continue'", "'break'", "'as'", "'is'", "'in'", null, null, "'out'", + "'@field'", "'@property'", "'@get'", "'@set'", "'get'", "'set'", "'@receiver'", + "'@param'", "'@setparam'", "'@delegate'", "'dynamic'", "'public'", "'private'", + "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", + "'inner'", "'tailrec'", "'operator'", "'inline'", "'infix'", "'external'", + "'suspend'", "'override'", "'abstract'", "'final'", "'open'", "'const'", + "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", "'reified'", + null, "'\"\"\"'", null, null, null, null, null, null, null, null, "'null'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", + "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", + "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL", + "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", + "RANGE", "COLONCOLON", "Q_COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT", + "QUEST", "ELVIS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "FILE", "PACKAGE", "IMPORT", "CLASS", "INTERFACE", "FUN", + "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", + "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", + "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", "RETURN", "CONTINUE", + "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", "OUT", "FIELD", "PROPERTY", + "GET", "SET", "GETTER", "SETTER", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", + "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", "SEALED", + "ANNOTATION", "DATA", "INNER", "TAILREC", "OPERATOR", "INLINE", "INFIX", + "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", "OPEN", "CONST", + "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "LongLiteral", "IntegerLiteral", "HexLiteral", "BinLiteral", "BooleanLiteral", + "NullLiteral", "Identifier", "LabelReference", "LabelDefinition", "FieldIdentifier", + "CharacterLiteral", "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", + "Inside_Comment", "Inside_WS", "Inside_NL", "QUOTE_CLOSE", "LineStrRef", + "LineStrText", "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", "MultiLineStrEscapedChar", + "MultiLineStrExprStart", "MultiLineNL", "StrExpr_IN", "StrExpr_Comment", + "StrExpr_WS", "StrExpr_NL" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { + return "KotlinParser.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public KotlinParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class KotlinFileContext extends ParserRuleContext { + public PreambleContext preamble() { + return getRuleContext(PreambleContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List anysemi() { + return getRuleContexts(AnysemiContext.class); + } + + public AnysemiContext anysemi(int i) { + return getRuleContext(AnysemiContext.class, i); + } + + public List topLevelObject() { + return getRuleContexts(TopLevelObjectContext.class); + } + + public TopLevelObjectContext topLevelObject(int i) { + return getRuleContext(TopLevelObjectContext.class, i); + } + + public KotlinFileContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kotlinFile; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterKotlinFile(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitKotlinFile(this); + } + } + + public final KotlinFileContext kotlinFile() throws RecognitionException { + KotlinFileContext _localctx = new KotlinFileContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_kotlinFile); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(297); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 0, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(294); + match(NL); + } + } + } + setState(299); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 0, _ctx); + } + setState(300); + preamble(); + setState(304); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL || _la == SEMICOLON) { + { + { + setState(301); + anysemi(); + } + } + setState(306); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(321); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & 8787085823019909121L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 137472507903L) != 0)) { + { + setState(307); + topLevelObject(); + setState(318); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL || _la == SEMICOLON) { + { + { + setState(309); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(308); + anysemi(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(311); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 2, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(314); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & 8787085823019909121L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 137472507903L) != 0)) { + { + setState(313); + topLevelObject(); + } + } + + } + } + setState(320); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(323); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ScriptContext extends ParserRuleContext { + public PreambleContext preamble() { + return getRuleContext(PreambleContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List anysemi() { + return getRuleContexts(AnysemiContext.class); + } + + public AnysemiContext anysemi(int i) { + return getRuleContext(AnysemiContext.class, i); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public ScriptContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_script; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterScript(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitScript(this); + } + } + + public final ScriptContext script() throws RecognitionException { + ScriptContext _localctx = new ScriptContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_script); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(328); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 6, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(325); + match(NL); + } + } + } + setState(330); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 6, _ctx); + } + setState(331); + preamble(); + setState(335); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 7, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(332); + anysemi(); + } + } + } + setState(337); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 7, _ctx); + } + setState(352); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4188346347763783136L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & -65012289L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 24563L) != 0)) { + { + setState(338); + expression(); + setState(349); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL || _la == SEMICOLON) { + { + { + setState(340); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(339); + anysemi(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(342); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 8, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(345); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) { + case 1: { + setState(344); + expression(); + } + break; + } + } + } + setState(351); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(354); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PreambleContext extends ParserRuleContext { + public PackageHeaderContext packageHeader() { + return getRuleContext(PackageHeaderContext.class, 0); + } + + public ImportListContext importList() { + return getRuleContext(ImportListContext.class, 0); + } + + public FileAnnotationsContext fileAnnotations() { + return getRuleContext(FileAnnotationsContext.class, 0); + } + + public PreambleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_preamble; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterPreamble(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitPreamble(this); + } + } + + public final PreambleContext preamble() throws RecognitionException { + PreambleContext _localctx = new PreambleContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_preamble); + try { + enterOuterAlt(_localctx, 1); + { + setState(357); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 12, _ctx)) { + case 1: { + setState(356); + fileAnnotations(); + } + break; + } + setState(359); + packageHeader(); + setState(360); + importList(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FileAnnotationsContext extends ParserRuleContext { + public List fileAnnotation() { + return getRuleContexts(FileAnnotationContext.class); + } + + public FileAnnotationContext fileAnnotation(int i) { + return getRuleContext(FileAnnotationContext.class, i); + } + + public FileAnnotationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fileAnnotations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFileAnnotations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFileAnnotations(this); + } + } + + public final FileAnnotationsContext fileAnnotations() throws RecognitionException { + FileAnnotationsContext _localctx = new FileAnnotationsContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_fileAnnotations); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(363); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(362); + fileAnnotation(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(365); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 13, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FileAnnotationContext extends ParserRuleContext { + public List FILE() { + return getTokens(KotlinParser.FILE); + } + + public TerminalNode FILE(int i) { + return getToken(KotlinParser.FILE, i); + } + + public List COLON() { + return getTokens(KotlinParser.COLON); + } + + public TerminalNode COLON(int i) { + return getToken(KotlinParser.COLON, i); + } + + public List LSQUARE() { + return getTokens(KotlinParser.LSQUARE); + } + + public TerminalNode LSQUARE(int i) { + return getToken(KotlinParser.LSQUARE, i); + } + + public List RSQUARE() { + return getTokens(KotlinParser.RSQUARE); + } + + public TerminalNode RSQUARE(int i) { + return getToken(KotlinParser.RSQUARE, i); + } + + public List unescapedAnnotation() { + return getRuleContexts(UnescapedAnnotationContext.class); + } + + public UnescapedAnnotationContext unescapedAnnotation(int i) { + return getRuleContext(UnescapedAnnotationContext.class, i); + } + + public List semi() { + return getRuleContexts(SemiContext.class); + } + + public SemiContext semi(int i) { + return getRuleContext(SemiContext.class, i); + } + + public FileAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fileAnnotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFileAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFileAnnotation(this); + } + } + + public final FileAnnotationContext fileAnnotation() throws RecognitionException { + FileAnnotationContext _localctx = new FileAnnotationContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_fileAnnotation); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(383); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(367); + match(FILE); + setState(368); + match(COLON); + setState(378); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LSQUARE: { + setState(369); + match(LSQUARE); + setState(371); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(370); + unescapedAnnotation(); + } + } + setState(373); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0)); + setState(375); + match(RSQUARE); + } + break; + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: { + setState(377); + unescapedAnnotation(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(381); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 16, _ctx)) { + case 1: { + setState(380); + semi(); + } + break; + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 17, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PackageHeaderContext extends ParserRuleContext { + public TerminalNode PACKAGE() { + return getToken(KotlinParser.PACKAGE, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + public PackageHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_packageHeader; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterPackageHeader(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitPackageHeader(this); + } + } + + public final PackageHeaderContext packageHeader() throws RecognitionException { + PackageHeaderContext _localctx = new PackageHeaderContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_packageHeader); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(395); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 20, _ctx)) { + case 1: { + setState(388); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(387); + modifierList(); + } + } + + setState(390); + match(PACKAGE); + setState(391); + identifier(); + setState(393); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 19, _ctx)) { + case 1: { + setState(392); + semi(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportListContext extends ParserRuleContext { + public List importHeader() { + return getRuleContexts(ImportHeaderContext.class); + } + + public ImportHeaderContext importHeader(int i) { + return getRuleContext(ImportHeaderContext.class, i); + } + + public ImportListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_importList; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterImportList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitImportList(this); + } + } + + public final ImportListContext importList() throws RecognitionException { + ImportListContext _localctx = new ImportListContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_importList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(400); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 21, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(397); + importHeader(); + } + } + } + setState(402); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 21, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportHeaderContext extends ParserRuleContext { + public TerminalNode IMPORT() { + return getToken(KotlinParser.IMPORT, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public ImportAliasContext importAlias() { + return getRuleContext(ImportAliasContext.class, 0); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + public ImportHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_importHeader; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterImportHeader(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitImportHeader(this); + } + } + + public final ImportHeaderContext importHeader() throws RecognitionException { + ImportHeaderContext _localctx = new ImportHeaderContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_importHeader); + try { + enterOuterAlt(_localctx, 1); + { + setState(403); + match(IMPORT); + setState(404); + identifier(); + setState(408); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: { + setState(405); + match(DOT); + setState(406); + match(MULT); + } + break; + case AS: { + setState(407); + importAlias(); + } + break; + case EOF: + case NL: + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL: + case SEMICOLON: + case COLONCOLON: + case Q_COLONCOLON: + case AT: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case FILE: + case IMPORT: + case CLASS: + case INTERFACE: + case FUN: + case OBJECT: + case VAL: + case VAR: + case TYPE_ALIAS: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case IN: + case OUT: + case FIELD: + case PROPERTY: + case GET: + case SET: + case GETTER: + case SETTER: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + case RealLiteral: + case LongLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case BooleanLiteral: + case NullLiteral: + case Identifier: + case LabelReference: + case LabelDefinition: + case CharacterLiteral: + break; + default: + break; + } + setState(411); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 23, _ctx)) { + case 1: { + setState(410); + semi(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportAliasContext extends ParserRuleContext { + public TerminalNode AS() { + return getToken(KotlinParser.AS, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ImportAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_importAlias; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterImportAlias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitImportAlias(this); + } + } + + public final ImportAliasContext importAlias() throws RecognitionException { + ImportAliasContext _localctx = new ImportAliasContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_importAlias); + try { + enterOuterAlt(_localctx, 1); + { + setState(413); + match(AS); + setState(414); + simpleIdentifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TopLevelObjectContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public ObjectDeclarationContext objectDeclaration() { + return getRuleContext(ObjectDeclarationContext.class, 0); + } + + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class, 0); + } + + public PropertyDeclarationContext propertyDeclaration() { + return getRuleContext(PropertyDeclarationContext.class, 0); + } + + public TypeAliasContext typeAlias() { + return getRuleContext(TypeAliasContext.class, 0); + } + + public TopLevelObjectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_topLevelObject; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTopLevelObject(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTopLevelObject(this); + } + } + + public final TopLevelObjectContext topLevelObject() throws RecognitionException { + TopLevelObjectContext _localctx = new TopLevelObjectContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_topLevelObject); + try { + setState(421); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 24, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(416); + classDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(417); + objectDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(418); + functionDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(419); + propertyDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(420); + typeAlias(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassDeclarationContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(KotlinParser.CLASS, 0); + } + + public TerminalNode INTERFACE() { + return getToken(KotlinParser.INTERFACE, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public PrimaryConstructorContext primaryConstructor() { + return getRuleContext(PrimaryConstructorContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public EnumClassBodyContext enumClassBody() { + return getRuleContext(EnumClassBodyContext.class, 0); + } + + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterClassDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitClassDeclaration(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_classDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(424); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(423); + modifierList(); + } + } + + setState(426); + _la = _input.LA(1); + if (!(_la == CLASS || _la == INTERFACE)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(430); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(427); + match(NL); + } + } + setState(432); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(433); + simpleIdentifier(); + setState(441); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 28, _ctx)) { + case 1: { + setState(437); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(434); + match(NL); + } + } + setState(439); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(440); + typeParameters(); + } + break; + } + setState(450); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 30, _ctx)) { + case 1: { + setState(446); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(443); + match(NL); + } + } + setState(448); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(449); + primaryConstructor(); + } + break; + } + setState(466); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 33, _ctx)) { + case 1: { + setState(455); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(452); + match(NL); + } + } + setState(457); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(458); + match(COLON); + setState(462); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(459); + match(NL); + } + } + setState(464); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(465); + delegationSpecifiers(); + } + break; + } + setState(475); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 35, _ctx)) { + case 1: { + setState(471); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(468); + match(NL); + } + } + setState(473); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(474); + typeConstraints(); + } + break; + } + setState(491); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 38, _ctx)) { + case 1: { + setState(480); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(477); + match(NL); + } + } + setState(482); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(483); + classBody(); + } + break; + case 2: { + setState(487); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(484); + match(NL); + } + } + setState(489); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(490); + enumClassBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrimaryConstructorContext extends ParserRuleContext { + public ClassParametersContext classParameters() { + return getRuleContext(ClassParametersContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public PrimaryConstructorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_primaryConstructor; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrimaryConstructor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrimaryConstructor(this); + } + } + + public final PrimaryConstructorContext primaryConstructor() throws RecognitionException { + PrimaryConstructorContext _localctx = new PrimaryConstructorContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_primaryConstructor); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(494); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(493); + modifierList(); + } + } + + setState(503); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == CONSTRUCTOR) { + { + setState(496); + match(CONSTRUCTOR); + setState(500); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(497); + match(NL); + } + } + setState(502); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(505); + classParameters(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassParametersContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List classParameter() { + return getRuleContexts(ClassParameterContext.class); + } + + public ClassParameterContext classParameter(int i) { + return getRuleContext(ClassParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public ClassParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classParameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterClassParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitClassParameters(this); + } + } + + public final ClassParametersContext classParameters() throws RecognitionException { + ClassParametersContext _localctx = new ClassParametersContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_classParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(507); + match(LPAREN); + setState(519); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & -3939815418167295L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 206191984639L) != 0)) { + { + setState(508); + classParameter(); + setState(513); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 42, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(509); + match(COMMA); + setState(510); + classParameter(); + } + } + } + setState(515); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 42, _ctx); + } + setState(517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(516); + match(COMMA); + } + } + + } + } + + setState(521); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassParameterContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public TerminalNode VAR() { + return getToken(KotlinParser.VAR, 0); + } + + public ClassParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classParameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterClassParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitClassParameter(this); + } + } + + public final ClassParameterContext classParameter() throws RecognitionException { + ClassParameterContext _localctx = new ClassParameterContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_classParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(524); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 45, _ctx)) { + case 1: { + setState(523); + modifierList(); + } + break; + } + setState(527); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == VAL || _la == VAR) { + { + setState(526); + _la = _input.LA(1); + if (!(_la == VAL || _la == VAR)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(529); + simpleIdentifier(); + setState(530); + match(COLON); + setState(531); + type(); + setState(534); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(532); + match(ASSIGNMENT); + setState(533); + expression(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DelegationSpecifiersContext extends ParserRuleContext { + public List delegationSpecifier() { + return getRuleContexts(DelegationSpecifierContext.class); + } + + public DelegationSpecifierContext delegationSpecifier(int i) { + return getRuleContext(DelegationSpecifierContext.class, i); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public DelegationSpecifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_delegationSpecifiers; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDelegationSpecifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDelegationSpecifiers(this); + } + } + + public final DelegationSpecifiersContext delegationSpecifiers() throws RecognitionException { + DelegationSpecifiersContext _localctx = new DelegationSpecifiersContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_delegationSpecifiers); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(539); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(536); + annotations(); + } + } + setState(541); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(542); + delegationSpecifier(); + setState(565); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(546); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(543); + match(NL); + } + } + setState(548); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(549); + match(COMMA); + setState(553); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(550); + match(NL); + } + } + setState(555); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(559); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(556); + annotations(); + } + } + setState(561); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(562); + delegationSpecifier(); + } + } + } + setState(567); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DelegationSpecifierContext extends ParserRuleContext { + public ConstructorInvocationContext constructorInvocation() { + return getRuleContext(ConstructorInvocationContext.class, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public ExplicitDelegationContext explicitDelegation() { + return getRuleContext(ExplicitDelegationContext.class, 0); + } + + public DelegationSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_delegationSpecifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDelegationSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDelegationSpecifier(this); + } + } + + public final DelegationSpecifierContext delegationSpecifier() throws RecognitionException { + DelegationSpecifierContext _localctx = new DelegationSpecifierContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_delegationSpecifier); + try { + setState(571); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 53, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(568); + constructorInvocation(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(569); + userType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(570); + explicitDelegation(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstructorInvocationContext extends ParserRuleContext { + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public CallSuffixContext callSuffix() { + return getRuleContext(CallSuffixContext.class, 0); + } + + public ConstructorInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constructorInvocation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConstructorInvocation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConstructorInvocation(this); + } + } + + public final ConstructorInvocationContext constructorInvocation() throws RecognitionException { + ConstructorInvocationContext _localctx = new ConstructorInvocationContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_constructorInvocation); + try { + enterOuterAlt(_localctx, 1); + { + setState(573); + userType(); + setState(574); + callSuffix(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExplicitDelegationContext extends ParserRuleContext { + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ExplicitDelegationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_explicitDelegation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterExplicitDelegation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitExplicitDelegation(this); + } + } + + public final ExplicitDelegationContext explicitDelegation() throws RecognitionException { + ExplicitDelegationContext _localctx = new ExplicitDelegationContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_explicitDelegation); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(576); + userType(); + setState(580); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(577); + match(NL); + } + } + setState(582); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(583); + match(BY); + setState(587); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 55, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(584); + match(NL); + } + } + } + setState(589); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 55, _ctx); + } + setState(590); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassBodyContext extends ParserRuleContext { + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List classMemberDeclaration() { + return getRuleContexts(ClassMemberDeclarationContext.class); + } + + public ClassMemberDeclarationContext classMemberDeclaration(int i) { + return getRuleContext(ClassMemberDeclarationContext.class, i); + } + + public ClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classBody; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterClassBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitClassBody(this); + } + } + + public final ClassBodyContext classBody() throws RecognitionException { + ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_classBody); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(592); + match(LCURL); + setState(596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 56, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(593); + match(NL); + } + } + } + setState(598); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 56, _ctx); + } + setState(602); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & 8787085823892324353L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 137472507903L) != 0)) { + { + { + setState(599); + classMemberDeclaration(); + } + } + setState(604); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(608); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(605); + match(NL); + } + } + setState(610); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(611); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassMemberDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class, 0); + } + + public ObjectDeclarationContext objectDeclaration() { + return getRuleContext(ObjectDeclarationContext.class, 0); + } + + public CompanionObjectContext companionObject() { + return getRuleContext(CompanionObjectContext.class, 0); + } + + public PropertyDeclarationContext propertyDeclaration() { + return getRuleContext(PropertyDeclarationContext.class, 0); + } + + public AnonymousInitializerContext anonymousInitializer() { + return getRuleContext(AnonymousInitializerContext.class, 0); + } + + public SecondaryConstructorContext secondaryConstructor() { + return getRuleContext(SecondaryConstructorContext.class, 0); + } + + public TypeAliasContext typeAlias() { + return getRuleContext(TypeAliasContext.class, 0); + } + + public List anysemi() { + return getRuleContexts(AnysemiContext.class); + } + + public AnysemiContext anysemi(int i) { + return getRuleContext(AnysemiContext.class, i); + } + + public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classMemberDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassMemberDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassMemberDeclaration(this); + } + } + + public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { + ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_classMemberDeclaration); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(621); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 59, _ctx)) { + case 1: { + setState(613); + classDeclaration(); + } + break; + case 2: { + setState(614); + functionDeclaration(); + } + break; + case 3: { + setState(615); + objectDeclaration(); + } + break; + case 4: { + setState(616); + companionObject(); + } + break; + case 5: { + setState(617); + propertyDeclaration(); + } + break; + case 6: { + setState(618); + anonymousInitializer(); + } + break; + case 7: { + setState(619); + secondaryConstructor(); + } + break; + case 8: { + setState(620); + typeAlias(); + } + break; + } + setState(624); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(623); + anysemi(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(626); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 60, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnonymousInitializerContext extends ParserRuleContext { + public TerminalNode INIT() { + return getToken(KotlinParser.INIT, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public AnonymousInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_anonymousInitializer; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnonymousInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnonymousInitializer(this); + } + } + + public final AnonymousInitializerContext anonymousInitializer() throws RecognitionException { + AnonymousInitializerContext _localctx = new AnonymousInitializerContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_anonymousInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(628); + match(INIT); + setState(632); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(629); + match(NL); + } + } + setState(634); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(635); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SecondaryConstructorContext extends ParserRuleContext { + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public FunctionValueParametersContext functionValueParameters() { + return getRuleContext(FunctionValueParametersContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public ConstructorDelegationCallContext constructorDelegationCall() { + return getRuleContext(ConstructorDelegationCallContext.class, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public SecondaryConstructorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_secondaryConstructor; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSecondaryConstructor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSecondaryConstructor(this); + } + } + + public final SecondaryConstructorContext secondaryConstructor() throws RecognitionException { + SecondaryConstructorContext _localctx = new SecondaryConstructorContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_secondaryConstructor); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(638); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(637); + modifierList(); + } + } + + setState(640); + match(CONSTRUCTOR); + setState(644); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(641); + match(NL); + } + } + setState(646); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(647); + functionValueParameters(); + setState(662); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 66, _ctx)) { + case 1: { + setState(651); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(648); + match(NL); + } + } + setState(653); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(654); + match(COLON); + setState(658); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(655); + match(NL); + } + } + setState(660); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(661); + constructorDelegationCall(); + } + break; + } + setState(667); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 67, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(664); + match(NL); + } + } + } + setState(669); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 67, _ctx); + } + setState(671); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LCURL) { + { + setState(670); + block(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstructorDelegationCallContext extends ParserRuleContext { + public TerminalNode THIS() { + return getToken(KotlinParser.THIS, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode SUPER() { + return getToken(KotlinParser.SUPER, 0); + } + + public ConstructorDelegationCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_constructorDelegationCall; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConstructorDelegationCall(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConstructorDelegationCall(this); + } + } + + public final ConstructorDelegationCallContext constructorDelegationCall() throws RecognitionException { + ConstructorDelegationCallContext _localctx = new ConstructorDelegationCallContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_constructorDelegationCall); + int _la; + try { + setState(689); + _errHandler.sync(this); + switch (_input.LA(1)) { + case THIS: + enterOuterAlt(_localctx, 1); + { + setState(673); + match(THIS); + setState(677); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(674); + match(NL); + } + } + setState(679); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(680); + valueArguments(); + } + break; + case SUPER: + enterOuterAlt(_localctx, 2); + { + setState(681); + match(SUPER); + setState(685); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(682); + match(NL); + } + } + setState(687); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(688); + valueArguments(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumClassBodyContext extends ParserRuleContext { + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public EnumEntriesContext enumEntries() { + return getRuleContext(EnumEntriesContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public List classMemberDeclaration() { + return getRuleContexts(ClassMemberDeclarationContext.class); + } + + public ClassMemberDeclarationContext classMemberDeclaration(int i) { + return getRuleContext(ClassMemberDeclarationContext.class, i); + } + + public EnumClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enumClassBody; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterEnumClassBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitEnumClassBody(this); + } + } + + public final EnumClassBodyContext enumClassBody() throws RecognitionException { + EnumClassBodyContext _localctx = new EnumClassBodyContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_enumClassBody); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(691); + match(LCURL); + setState(695); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 72, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(692); + match(NL); + } + } + } + setState(697); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 72, _ctx); + } + setState(699); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & -4502765396754431L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 206191984639L) != 0)) { + { + setState(698); + enumEntries(); + } + } + + setState(720); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 77, _ctx)) { + case 1: { + setState(704); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(701); + match(NL); + } + } + setState(706); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(707); + match(SEMICOLON); + setState(711); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(708); + match(NL); + } + } + } + setState(713); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); + } + setState(717); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & 8787085823892324353L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 137472507903L) != 0)) { + { + { + setState(714); + classMemberDeclaration(); + } + } + setState(719); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(725); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(722); + match(NL); + } + } + setState(727); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(728); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumEntriesContext extends ParserRuleContext { + public List enumEntry() { + return getRuleContexts(EnumEntryContext.class); + } + + public EnumEntryContext enumEntry(int i) { + return getRuleContext(EnumEntryContext.class, i); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public EnumEntriesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enumEntries; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterEnumEntries(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitEnumEntries(this); + } + } + + public final EnumEntriesContext enumEntries() throws RecognitionException { + EnumEntriesContext _localctx = new EnumEntriesContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_enumEntries); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(737); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(730); + enumEntry(); + setState(734); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 79, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(731); + match(NL); + } + } + } + setState(736); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 79, _ctx); + } + } + } + setState(739); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & -4502765396754431L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 206191984639L) != 0)); + setState(742); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 81, _ctx)) { + case 1: { + setState(741); + match(SEMICOLON); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumEntryContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(KotlinParser.COMMA, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public EnumEntryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_enumEntry; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterEnumEntry(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitEnumEntry(this); + } + } + + public final EnumEntryContext enumEntry() throws RecognitionException { + EnumEntryContext _localctx = new EnumEntryContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_enumEntry); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(747); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(744); + annotations(); + } + } + setState(749); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(750); + simpleIdentifier(); + setState(758); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 84, _ctx)) { + case 1: { + setState(754); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(751); + match(NL); + } + } + setState(756); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(757); + valueArguments(); + } + break; + } + setState(767); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 86, _ctx)) { + case 1: { + setState(763); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(760); + match(NL); + } + } + setState(765); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(766); + classBody(); + } + break; + } + setState(776); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 88, _ctx)) { + case 1: { + setState(772); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(769); + match(NL); + } + } + setState(774); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(775); + match(COMMA); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionDeclarationContext extends ParserRuleContext { + public TerminalNode FUN() { + return getToken(KotlinParser.FUN, 0); + } + + public FunctionValueParametersContext functionValueParameters() { + return getRuleContext(FunctionValueParametersContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public ReceiverTypeContext receiverType() { + return getRuleContext(ReceiverTypeContext.class, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionDeclaration(this); + } + } + + public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { + FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_functionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(779); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(778); + modifierList(); + } + } + + setState(781); + match(FUN); + setState(797); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 92, _ctx)) { + case 1: { + setState(785); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(782); + match(NL); + } + } + setState(787); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(788); + type(); + setState(792); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(789); + match(NL); + } + } + setState(794); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(795); + match(DOT); + } + break; + } + setState(806); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 94, _ctx)) { + case 1: { + setState(802); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(799); + match(NL); + } + } + setState(804); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(805); + typeParameters(); + } + break; + } + setState(823); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 97, _ctx)) { + case 1: { + setState(811); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(808); + match(NL); + } + } + setState(813); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(814); + receiverType(); + setState(818); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(815); + match(NL); + } + } + setState(820); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(821); + match(DOT); + } + break; + } + setState(832); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 99, _ctx)) { + case 1: { + setState(828); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(825); + match(NL); + } + } + setState(830); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(831); + identifier(); + } + break; + } + setState(837); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(834); + match(NL); + } + } + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(840); + functionValueParameters(); + setState(855); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 103, _ctx)) { + case 1: { + setState(844); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(841); + match(NL); + } + } + setState(846); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(847); + match(COLON); + setState(851); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(848); + match(NL); + } + } + setState(853); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(854); + type(); + } + break; + } + setState(864); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 105, _ctx)) { + case 1: { + setState(860); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(857); + match(NL); + } + } + setState(862); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(863); + typeConstraints(); + } + break; + } + setState(873); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 107, _ctx)) { + case 1: { + setState(869); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(866); + match(NL); + } + } + setState(871); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(872); + functionBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionValueParametersContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List functionValueParameter() { + return getRuleContexts(FunctionValueParameterContext.class); + } + + public FunctionValueParameterContext functionValueParameter(int i) { + return getRuleContext(FunctionValueParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public FunctionValueParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionValueParameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionValueParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionValueParameters(this); + } + } + + public final FunctionValueParametersContext functionValueParameters() throws RecognitionException { + FunctionValueParametersContext _localctx = new FunctionValueParametersContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_functionValueParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(875); + match(LPAREN); + setState(887); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & -3939815443333119L) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 206191984639L) != 0)) { + { + setState(876); + functionValueParameter(); + setState(881); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 108, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(877); + match(COMMA); + setState(878); + functionValueParameter(); + } + } + } + setState(883); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 108, _ctx); + } + setState(885); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(884); + match(COMMA); + } + } + + } + } + + setState(889); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionValueParameterContext extends ParserRuleContext { + public ParameterContext parameter() { + return getRuleContext(ParameterContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public FunctionValueParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionValueParameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionValueParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionValueParameter(this); + } + } + + public final FunctionValueParameterContext functionValueParameter() throws RecognitionException { + FunctionValueParameterContext _localctx = new FunctionValueParameterContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_functionValueParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(892); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 111, _ctx)) { + case 1: { + setState(891); + modifierList(); + } + break; + } + setState(894); + parameter(); + setState(897); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASSIGNMENT) { + { + setState(895); + match(ASSIGNMENT); + setState(896); + expression(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitParameter(this); + } + } + + public final ParameterContext parameter() throws RecognitionException { + ParameterContext _localctx = new ParameterContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_parameter); + try { + enterOuterAlt(_localctx, 1); + { + setState(899); + simpleIdentifier(); + setState(900); + match(COLON); + setState(901); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReceiverTypeContext extends ParserRuleContext { + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public NullableTypeContext nullableType() { + return getRuleContext(NullableTypeContext.class, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public TypeModifierListContext typeModifierList() { + return getRuleContext(TypeModifierListContext.class, 0); + } + + public ReceiverTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_receiverType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterReceiverType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitReceiverType(this); + } + } + + public final ReceiverTypeContext receiverType() throws RecognitionException { + ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_receiverType); + try { + enterOuterAlt(_localctx, 1); + { + setState(904); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 113, _ctx)) { + case 1: { + setState(903); + typeModifierList(); + } + break; + } + setState(909); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 114, _ctx)) { + case 1: { + setState(906); + parenthesizedType(); + } + break; + case 2: { + setState(907); + nullableType(); + } + break; + case 3: { + setState(908); + typeReference(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionBodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public FunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionBody; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFunctionBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFunctionBody(this); + } + } + + public final FunctionBodyContext functionBody() throws RecognitionException { + FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_functionBody); + try { + int _alt; + setState(920); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LCURL: + enterOuterAlt(_localctx, 1); + { + setState(911); + block(); + } + break; + case ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(912); + match(ASSIGNMENT); + setState(916); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 115, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(913); + match(NL); + } + } + } + setState(918); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 115, _ctx); + } + setState(919); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ObjectDeclarationContext extends ParserRuleContext { + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public PrimaryConstructorContext primaryConstructor() { + return getRuleContext(PrimaryConstructorContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public ObjectDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_objectDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterObjectDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitObjectDeclaration(this); + } + } + + public final ObjectDeclarationContext objectDeclaration() throws RecognitionException { + ObjectDeclarationContext _localctx = new ObjectDeclarationContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_objectDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(923); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(922); + modifierList(); + } + } + + setState(925); + match(OBJECT); + setState(929); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(926); + match(NL); + } + } + setState(931); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(932); + simpleIdentifier(); + setState(940); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 120, _ctx)) { + case 1: { + setState(936); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(933); + match(NL); + } + } + setState(938); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(939); + primaryConstructor(); + } + break; + } + setState(956); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 123, _ctx)) { + case 1: { + setState(945); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(942); + match(NL); + } + } + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(948); + match(COLON); + setState(952); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(949); + match(NL); + } + } + setState(954); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(955); + delegationSpecifiers(); + } + break; + } + setState(965); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 125, _ctx)) { + case 1: { + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(958); + match(NL); + } + } + setState(963); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(964); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CompanionObjectContext extends ParserRuleContext { + public TerminalNode COMPANION() { + return getToken(KotlinParser.COMPANION, 0); + } + + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public List modifierList() { + return getRuleContexts(ModifierListContext.class); + } + + public ModifierListContext modifierList(int i) { + return getRuleContext(ModifierListContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public CompanionObjectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_companionObject; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterCompanionObject(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitCompanionObject(this); + } + } + + public final CompanionObjectContext companionObject() throws RecognitionException { + CompanionObjectContext _localctx = new CompanionObjectContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_companionObject); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(968); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(967); + modifierList(); + } + } + + setState(970); + match(COMPANION); + setState(974); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(971); + match(NL); + } + } + setState(976); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(978); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(977); + modifierList(); + } + } + + setState(980); + match(OBJECT); + setState(988); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 130, _ctx)) { + case 1: { + setState(984); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(981); + match(NL); + } + } + setState(986); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(987); + simpleIdentifier(); + } + break; + } + setState(1004); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 133, _ctx)) { + case 1: { + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(990); + match(NL); + } + } + setState(995); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(996); + match(COLON); + setState(1000); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(997); + match(NL); + } + } + setState(1002); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1003); + delegationSpecifiers(); + } + break; + } + setState(1013); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 135, _ctx)) { + case 1: { + setState(1009); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1006); + match(NL); + } + } + setState(1011); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1012); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyDeclarationContext extends ParserRuleContext { + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public TerminalNode VAR() { + return getToken(KotlinParser.VAR, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public GetterContext getter() { + return getRuleContext(GetterContext.class, 0); + } + + public SetterContext setter() { + return getRuleContext(SetterContext.class, 0); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + public PropertyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_propertyDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPropertyDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPropertyDeclaration(this); + } + } + + public final PropertyDeclarationContext propertyDeclaration() throws RecognitionException { + PropertyDeclarationContext _localctx = new PropertyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_propertyDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1016); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1015); + modifierList(); + } + } + + setState(1018); + _la = _input.LA(1); + if (!(_la == VAL || _la == VAR)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1026); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 138, _ctx)) { + case 1: { + setState(1022); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1019); + match(NL); + } + } + setState(1024); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1025); + typeParameters(); + } + break; + } + setState(1043); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 141, _ctx)) { + case 1: { + setState(1031); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1028); + match(NL); + } + } + setState(1033); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1034); + type(); + setState(1038); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1035); + match(NL); + } + } + setState(1040); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1041); + match(DOT); + } + break; + } + { + setState(1048); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1045); + match(NL); + } + } + setState(1050); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1053); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: { + setState(1051); + multiVariableDeclaration(); + } + break; + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: { + setState(1052); + variableDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(1062); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 145, _ctx)) { + case 1: { + setState(1058); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1055); + match(NL); + } + } + setState(1060); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1061); + typeConstraints(); + } + break; + } + setState(1078); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { + case 1: { + setState(1067); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1064); + match(NL); + } + } + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1070); + _la = _input.LA(1); + if (!(_la == ASSIGNMENT || _la == BY)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1074); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 147, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1071); + match(NL); + } + } + } + setState(1076); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 147, _ctx); + } + setState(1077); + expression(); + } + break; + } + setState(1104); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 153, _ctx)) { + case 1: { + setState(1083); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1080); + match(NL); + } + } + setState(1085); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1086); + getter(); + setState(1090); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 150, _ctx)) { + case 1: { + setState(1087); + semi(); + setState(1088); + setter(); + } + break; + } + } + break; + case 2: { + setState(1095); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1092); + match(NL); + } + } + setState(1097); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1098); + setter(); + setState(1102); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 152, _ctx)) { + case 1: { + setState(1099); + semi(); + setState(1100); + getter(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiVariableDeclarationContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public List variableDeclaration() { + return getRuleContexts(VariableDeclarationContext.class); + } + + public VariableDeclarationContext variableDeclaration(int i) { + return getRuleContext(VariableDeclarationContext.class, i); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public MultiVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiVariableDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiVariableDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiVariableDeclaration(this); + } + } + + public final MultiVariableDeclarationContext multiVariableDeclaration() throws RecognitionException { + MultiVariableDeclarationContext _localctx = new MultiVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_multiVariableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1106); + match(LPAREN); + setState(1107); + variableDeclaration(); + setState(1112); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1108); + match(COMMA); + setState(1109); + variableDeclaration(); + } + } + setState(1114); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1115); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_variableDeclaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVariableDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVariableDeclaration(this); + } + } + + public final VariableDeclarationContext variableDeclaration() throws RecognitionException { + VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_variableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1117); + simpleIdentifier(); + setState(1120); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(1118); + match(COLON); + setState(1119); + type(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GetterContext extends ParserRuleContext { + public TerminalNode GETTER() { + return getToken(KotlinParser.GETTER, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public GetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_getter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterGetter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitGetter(this); + } + } + + public final GetterContext getter() throws RecognitionException { + GetterContext _localctx = new GetterContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_getter); + int _la; + try { + int _alt; + setState(1171); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 165, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1123); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1122); + modifierList(); + } + } + + setState(1125); + match(GETTER); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1127); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1126); + modifierList(); + } + } + + setState(1129); + match(GETTER); + setState(1133); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1130); + match(NL); + } + } + setState(1135); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1136); + match(LPAREN); + setState(1137); + match(RPAREN); + setState(1152); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 161, _ctx)) { + case 1: { + setState(1141); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1138); + match(NL); + } + } + setState(1143); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1144); + match(COLON); + setState(1148); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1145); + match(NL); + } + } + setState(1150); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1151); + type(); + } + break; + } + setState(1157); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1154); + match(NL); + } + } + setState(1159); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1169); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LCURL: { + setState(1160); + block(); + } + break; + case ASSIGNMENT: { + setState(1161); + match(ASSIGNMENT); + setState(1165); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1162); + match(NL); + } + } + } + setState(1167); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); + } + setState(1168); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetterContext extends ParserRuleContext { + public TerminalNode SETTER() { + return getToken(KotlinParser.SETTER, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ParameterContext parameter() { + return getRuleContext(ParameterContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List parameterModifier() { + return getRuleContexts(ParameterModifierContext.class); + } + + public ParameterModifierContext parameterModifier(int i) { + return getRuleContext(ParameterModifierContext.class, i); + } + + public SetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_setter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterSetter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitSetter(this); + } + } + + public final SetterContext setter() throws RecognitionException { + SetterContext _localctx = new SetterContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_setter); + int _la; + try { + int _alt; + setState(1208); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 173, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1174); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1173); + modifierList(); + } + } + + setState(1176); + match(SETTER); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1178); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1177); + modifierList(); + } + } + + setState(1180); + match(SETTER); + setState(1184); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1181); + match(NL); + } + } + setState(1186); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1187); + match(LPAREN); + setState(1192); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + setState(1190); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case LabelReference: { + setState(1188); + annotations(); + } + break; + case VARARG: + case NOINLINE: + case CROSSINLINE: { + setState(1189); + parameterModifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(1194); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + } + setState(1197); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 171, _ctx)) { + case 1: { + setState(1195); + simpleIdentifier(); + } + break; + case 2: { + setState(1196); + parameter(); + } + break; + } + setState(1199); + match(RPAREN); + setState(1203); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1200); + match(NL); + } + } + setState(1205); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1206); + functionBody(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeAliasContext extends ParserRuleContext { + public TerminalNode TYPE_ALIAS() { + return getToken(KotlinParser.TYPE_ALIAS, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public TypeAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeAlias; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeAlias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeAlias(this); + } + } + + public final TypeAliasContext typeAlias() throws RecognitionException { + TypeAliasContext _localctx = new TypeAliasContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_typeAlias); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1211); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT || _la == FILE || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & 4504699138981113L) != 0)) { + { + setState(1210); + modifierList(); + } + } + + setState(1213); + match(TYPE_ALIAS); + setState(1217); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1214); + match(NL); + } + } + setState(1219); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1220); + simpleIdentifier(); + setState(1228); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 177, _ctx)) { + case 1: { + setState(1224); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1221); + match(NL); + } + } + setState(1226); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1227); + typeParameters(); + } + break; + } + setState(1233); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1230); + match(NL); + } + } + setState(1235); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1236); + match(ASSIGNMENT); + setState(1240); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1237); + match(NL); + } + } + setState(1242); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1243); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParametersContext extends ParserRuleContext { + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public List typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class, i); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeParameters(this); + } + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_typeParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1245); + match(LANGLE); + setState(1249); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 180, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1246); + match(NL); + } + } + } + setState(1251); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 180, _ctx); + } + setState(1252); + typeParameter(); + setState(1269); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 183, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1256); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1253); + match(NL); + } + } + setState(1258); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1259); + match(COMMA); + setState(1263); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 182, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1260); + match(NL); + } + } + } + setState(1265); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 182, _ctx); + } + setState(1266); + typeParameter(); + } + } + } + setState(1271); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 183, _ctx); + } + setState(1279); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 185, _ctx)) { + case 1: { + setState(1275); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1272); + match(NL); + } + } + setState(1277); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1278); + match(COMMA); + } + break; + } + setState(1284); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1281); + match(NL); + } + } + setState(1286); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1287); + match(RANGLE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParameterContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeParameter(this); + } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1290); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 187, _ctx)) { + case 1: { + setState(1289); + modifierList(); + } + break; + } + setState(1295); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1292); + match(NL); + } + } + setState(1297); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1300); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: { + setState(1298); + simpleIdentifier(); + } + break; + case MULT: { + setState(1299); + match(MULT); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1316); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 192, _ctx)) { + case 1: { + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1302); + match(NL); + } + } + setState(1307); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1308); + match(COLON); + setState(1312); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1309); + match(NL); + } + } + setState(1314); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1315); + type(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeContext extends ParserRuleContext { + public FunctionTypeContext functionType() { + return getRuleContext(FunctionTypeContext.class, 0); + } + + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public NullableTypeContext nullableType() { + return getRuleContext(NullableTypeContext.class, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public TypeModifierListContext typeModifierList() { + return getRuleContext(TypeModifierListContext.class, 0); + } + + public TypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitType(this); + } + } + + public final TypeContext type() throws RecognitionException { + TypeContext _localctx = new TypeContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1319); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 193, _ctx)) { + case 1: { + setState(1318); + typeModifierList(); + } + break; + } + setState(1325); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 194, _ctx)) { + case 1: { + setState(1321); + functionType(); + } + break; + case 2: { + setState(1322); + parenthesizedType(); + } + break; + case 3: { + setState(1323); + nullableType(); + } + break; + case 4: { + setState(1324); + typeReference(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeModifierListContext extends ParserRuleContext { + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List SUSPEND() { + return getTokens(KotlinParser.SUSPEND); + } + + public TerminalNode SUSPEND(int i) { + return getToken(KotlinParser.SUSPEND, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeModifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeModifierList; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeModifierList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeModifierList(this); + } + } + + public final TypeModifierListContext typeModifierList() throws RecognitionException { + TypeModifierListContext _localctx = new TypeModifierListContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_typeModifierList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1335); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + setState(1335); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case LabelReference: { + setState(1327); + annotations(); + } + break; + case SUSPEND: { + setState(1328); + match(SUSPEND); + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1329); + match(NL); + } + } + setState(1334); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1337); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 197, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParenthesizedTypeContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public ParenthesizedTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitParenthesizedType(this); + } + } + + public final ParenthesizedTypeContext parenthesizedType() throws RecognitionException { + ParenthesizedTypeContext _localctx = new ParenthesizedTypeContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_parenthesizedType); + try { + enterOuterAlt(_localctx, 1); + { + setState(1339); + match(LPAREN); + setState(1340); + type(); + setState(1341); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NullableTypeContext extends ParserRuleContext { + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List QUEST() { + return getTokens(KotlinParser.QUEST); + } + + public TerminalNode QUEST(int i) { + return getToken(KotlinParser.QUEST, i); + } + + public NullableTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_nullableType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterNullableType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitNullableType(this); + } + } + + public final NullableTypeContext nullableType() throws RecognitionException { + NullableTypeContext _localctx = new NullableTypeContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_nullableType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1345); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 198, _ctx)) { + case 1: { + setState(1343); + typeReference(); + } + break; + case 2: { + setState(1344); + parenthesizedType(); + } + break; + } + setState(1350); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1347); + match(NL); + } + } + setState(1352); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1354); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1353); + match(QUEST); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1356); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 200, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeReferenceContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(KotlinParser.DYNAMIC, 0); + } + + public TypeReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeReference; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeReference(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeReference(this); + } + } + + public final TypeReferenceContext typeReference() throws RecognitionException { + TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_typeReference); + try { + setState(1364); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 201, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1358); + match(LPAREN); + setState(1359); + typeReference(); + setState(1360); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1362); + userType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1363); + match(DYNAMIC); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionTypeContext extends ParserRuleContext { + public FunctionTypeParametersContext functionTypeParameters() { + return getRuleContext(FunctionTypeParametersContext.class, 0); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public FunctionTypeReceiverContext functionTypeReceiver() { + return getRuleContext(FunctionTypeReceiverContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public FunctionTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFunctionType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFunctionType(this); + } + } + + public final FunctionTypeContext functionType() throws RecognitionException { + FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_functionType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1380); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 204, _ctx)) { + case 1: { + setState(1366); + functionTypeReceiver(); + setState(1370); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1367); + match(NL); + } + } + setState(1372); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1373); + match(DOT); + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1374); + match(NL); + } + } + setState(1379); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(1382); + functionTypeParameters(); + setState(1386); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1383); + match(NL); + } + } + setState(1388); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1389); + match(ARROW); + { + setState(1393); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1390); + match(NL); + } + } + setState(1395); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1396); + type(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionTypeReceiverContext extends ParserRuleContext { + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public NullableTypeContext nullableType() { + return getRuleContext(NullableTypeContext.class, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public FunctionTypeReceiverContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionTypeReceiver; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionTypeReceiver(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionTypeReceiver(this); + } + } + + public final FunctionTypeReceiverContext functionTypeReceiver() throws RecognitionException { + FunctionTypeReceiverContext _localctx = new FunctionTypeReceiverContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_functionTypeReceiver); + try { + setState(1401); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 207, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1398); + parenthesizedType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1399); + nullableType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1400); + typeReference(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserTypeContext extends ParserRuleContext { + public List simpleUserType() { + return getRuleContexts(SimpleUserTypeContext.class); + } + + public SimpleUserTypeContext simpleUserType(int i) { + return getRuleContext(SimpleUserTypeContext.class, i); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public UserTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_userType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterUserType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitUserType(this); + } + } + + public final UserTypeContext userType() throws RecognitionException { + UserTypeContext _localctx = new UserTypeContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_userType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1403); + simpleUserType(); + setState(1420); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1407); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1404); + match(NL); + } + } + setState(1409); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1410); + match(DOT); + setState(1414); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1411); + match(NL); + } + } + setState(1416); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1417); + simpleUserType(); + } + } + } + setState(1422); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleUserTypeContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SimpleUserTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simpleUserType; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterSimpleUserType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitSimpleUserType(this); + } + } + + public final SimpleUserTypeContext simpleUserType() throws RecognitionException { + SimpleUserTypeContext _localctx = new SimpleUserTypeContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_simpleUserType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1423); + simpleIdentifier(); + setState(1431); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 212, _ctx)) { + case 1: { + setState(1427); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1424); + match(NL); + } + } + setState(1429); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1430); + typeArguments(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionTypeParametersContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List parameter() { + return getRuleContexts(ParameterContext.class); + } + + public ParameterContext parameter(int i) { + return getRuleContext(ParameterContext.class, i); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public FunctionTypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionTypeParameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionTypeParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionTypeParameters(this); + } + } + + public final FunctionTypeParametersContext functionTypeParameters() throws RecognitionException { + FunctionTypeParametersContext _localctx = new FunctionTypeParametersContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_functionTypeParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1433); + match(LPAREN); + setState(1437); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 213, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1434); + match(NL); + } + } + } + setState(1439); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 213, _ctx); + } + setState(1442); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 214, _ctx)) { + case 1: { + setState(1440); + parameter(); + } + break; + case 2: { + setState(1441); + type(); + } + break; + } + setState(1463); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 218, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1447); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1444); + match(NL); + } + } + setState(1449); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1450); + match(COMMA); + setState(1454); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1451); + match(NL); + } + } + setState(1456); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1459); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 217, _ctx)) { + case 1: { + setState(1457); + parameter(); + } + break; + case 2: { + setState(1458); + type(); + } + break; + } + } + } + } + setState(1465); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 218, _ctx); + } + setState(1473); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 220, _ctx)) { + case 1: { + setState(1469); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1466); + match(NL); + } + } + setState(1471); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1472); + match(COMMA); + } + break; + } + setState(1478); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1475); + match(NL); + } + } + setState(1480); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1481); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeConstraintsContext extends ParserRuleContext { + public TerminalNode WHERE() { + return getToken(KotlinParser.WHERE, 0); + } + + public List typeConstraint() { + return getRuleContexts(TypeConstraintContext.class); + } + + public TypeConstraintContext typeConstraint(int i) { + return getRuleContext(TypeConstraintContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public TypeConstraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeConstraints; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeConstraints(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeConstraints(this); + } + } + + public final TypeConstraintsContext typeConstraints() throws RecognitionException { + TypeConstraintsContext _localctx = new TypeConstraintsContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_typeConstraints); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1483); + match(WHERE); + setState(1487); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1484); + match(NL); + } + } + setState(1489); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1490); + typeConstraint(); + setState(1507); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 225, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1494); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1491); + match(NL); + } + } + setState(1496); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1497); + match(COMMA); + setState(1501); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1498); + match(NL); + } + } + setState(1503); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1504); + typeConstraint(); + } + } + } + setState(1509); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 225, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeConstraintContext extends ParserRuleContext { + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeConstraint; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeConstraint(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeConstraint(this); + } + } + + public final TypeConstraintContext typeConstraint() throws RecognitionException { + TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_typeConstraint); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1513); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(1510); + annotations(); + } + } + setState(1515); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1516); + simpleIdentifier(); + setState(1520); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1517); + match(NL); + } + } + setState(1522); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1523); + match(COLON); + setState(1527); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1524); + match(NL); + } + } + setState(1529); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1530); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockContext extends ParserRuleContext { + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitBlock(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_block); + try { + enterOuterAlt(_localctx, 1); + { + setState(1532); + match(LCURL); + setState(1533); + statements(); + setState(1534); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementsContext extends ParserRuleContext { + public List anysemi() { + return getRuleContexts(AnysemiContext.class); + } + + public AnysemiContext anysemi(int i) { + return getRuleContext(AnysemiContext.class, i); + } + + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public StatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statements; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterStatements(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitStatements(this); + } + } + + public final StatementsContext statements() throws RecognitionException { + StatementsContext _localctx = new StatementsContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_statements); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1539); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 229, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1536); + anysemi(); + } + } + } + setState(1541); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 229, _ctx); + } + setState(1556); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 233, _ctx)) { + case 1: { + setState(1542); + statement(); + setState(1553); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 232, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1544); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1543); + anysemi(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1546); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 230, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1549); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 231, _ctx)) { + case 1: { + setState(1548); + statement(); + } + break; + } + } + } + } + setState(1555); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 232, _ctx); + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementContext extends ParserRuleContext { + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class, 0); + } + + public BlockLevelExpressionContext blockLevelExpression() { + return getRuleContext(BlockLevelExpressionContext.class, 0); + } + + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitStatement(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_statement); + try { + setState(1560); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 234, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1558); + declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1559); + blockLevelExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockLevelExpressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public BlockLevelExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_blockLevelExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterBlockLevelExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitBlockLevelExpression(this); + } + } + + public final BlockLevelExpressionContext blockLevelExpression() throws RecognitionException { + BlockLevelExpressionContext _localctx = new BlockLevelExpressionContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_blockLevelExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1565); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 235, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1562); + annotations(); + } + } + } + setState(1567); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 235, _ctx); + } + setState(1571); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 236, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1568); + match(NL); + } + } + } + setState(1573); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 236, _ctx); + } + setState(1574); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class, 0); + } + + public PropertyDeclarationContext propertyDeclaration() { + return getRuleContext(PropertyDeclarationContext.class, 0); + } + + public TypeAliasContext typeAlias() { + return getRuleContext(TypeAliasContext.class, 0); + } + + public List labelDefinition() { + return getRuleContexts(LabelDefinitionContext.class); + } + + public LabelDefinitionContext labelDefinition(int i) { + return getRuleContext(LabelDefinitionContext.class, i); + } + + public DeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_declaration; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitDeclaration(this); + } + } + + public final DeclarationContext declaration() throws RecognitionException { + DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_declaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1579); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == LabelDefinition) { + { + { + setState(1576); + labelDefinition(); + } + } + setState(1581); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1586); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 238, _ctx)) { + case 1: { + setState(1582); + classDeclaration(); + } + break; + case 2: { + setState(1583); + functionDeclaration(); + } + break; + case 3: { + setState(1584); + propertyDeclaration(); + } + break; + case 4: { + setState(1585); + typeAlias(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionContext extends ParserRuleContext { + public List disjunction() { + return getRuleContexts(DisjunctionContext.class); + } + + public DisjunctionContext disjunction(int i) { + return getRuleContext(DisjunctionContext.class, i); + } + + public List assignmentOperator() { + return getRuleContexts(AssignmentOperatorContext.class); + } + + public AssignmentOperatorContext assignmentOperator(int i) { + return getRuleContext(AssignmentOperatorContext.class, i); + } + + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_expression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1588); + disjunction(); + setState(1594); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 239, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1589); + assignmentOperator(); + setState(1590); + disjunction(); + } + } + } + setState(1596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 239, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DisjunctionContext extends ParserRuleContext { + public List conjunction() { + return getRuleContexts(ConjunctionContext.class); + } + + public ConjunctionContext conjunction(int i) { + return getRuleContext(ConjunctionContext.class, i); + } + + public List DISJ() { + return getTokens(KotlinParser.DISJ); + } + + public TerminalNode DISJ(int i) { + return getToken(KotlinParser.DISJ, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public DisjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_disjunction; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterDisjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitDisjunction(this); + } + } + + public final DisjunctionContext disjunction() throws RecognitionException { + DisjunctionContext _localctx = new DisjunctionContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_disjunction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1597); + conjunction(); + setState(1614); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 242, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1601); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1598); + match(NL); + } + } + setState(1603); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1604); + match(DISJ); + setState(1608); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 241, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1605); + match(NL); + } + } + } + setState(1610); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 241, _ctx); + } + setState(1611); + conjunction(); + } + } + } + setState(1616); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 242, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConjunctionContext extends ParserRuleContext { + public List equalityComparison() { + return getRuleContexts(EqualityComparisonContext.class); + } + + public EqualityComparisonContext equalityComparison(int i) { + return getRuleContext(EqualityComparisonContext.class, i); + } + + public List CONJ() { + return getTokens(KotlinParser.CONJ); + } + + public TerminalNode CONJ(int i) { + return getToken(KotlinParser.CONJ, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ConjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conjunction; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterConjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitConjunction(this); + } + } + + public final ConjunctionContext conjunction() throws RecognitionException { + ConjunctionContext _localctx = new ConjunctionContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_conjunction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1617); + equalityComparison(); + setState(1634); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 245, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1621); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1618); + match(NL); + } + } + setState(1623); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1624); + match(CONJ); + setState(1628); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 244, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1625); + match(NL); + } + } + } + setState(1630); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 244, _ctx); + } + setState(1631); + equalityComparison(); + } + } + } + setState(1636); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 245, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EqualityComparisonContext extends ParserRuleContext { + public List comparison() { + return getRuleContexts(ComparisonContext.class); + } + + public ComparisonContext comparison(int i) { + return getRuleContext(ComparisonContext.class, i); + } + + public List equalityOperation() { + return getRuleContexts(EqualityOperationContext.class); + } + + public EqualityOperationContext equalityOperation(int i) { + return getRuleContext(EqualityOperationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public EqualityComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_equalityComparison; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEqualityComparison(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEqualityComparison(this); + } + } + + public final EqualityComparisonContext equalityComparison() throws RecognitionException { + EqualityComparisonContext _localctx = new EqualityComparisonContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_equalityComparison); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1637); + comparison(); + setState(1649); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 247, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1638); + equalityOperation(); + setState(1642); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1639); + match(NL); + } + } + } + setState(1644); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); + } + setState(1645); + comparison(); + } + } + } + setState(1651); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 247, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ComparisonContext extends ParserRuleContext { + public List namedInfix() { + return getRuleContexts(NamedInfixContext.class); + } + + public NamedInfixContext namedInfix(int i) { + return getRuleContext(NamedInfixContext.class, i); + } + + public ComparisonOperatorContext comparisonOperator() { + return getRuleContext(ComparisonOperatorContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_comparison; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterComparison(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitComparison(this); + } + } + + public final ComparisonContext comparison() throws RecognitionException { + ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_comparison); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1652); + namedInfix(); + setState(1662); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 249, _ctx)) { + case 1: { + setState(1653); + comparisonOperator(); + setState(1657); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 248, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1654); + match(NL); + } + } + } + setState(1659); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 248, _ctx); + } + setState(1660); + namedInfix(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NamedInfixContext extends ParserRuleContext { + public List elvisExpression() { + return getRuleContexts(ElvisExpressionContext.class); + } + + public ElvisExpressionContext elvisExpression(int i) { + return getRuleContext(ElvisExpressionContext.class, i); + } + + public IsOperatorContext isOperator() { + return getRuleContext(IsOperatorContext.class, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List inOperator() { + return getRuleContexts(InOperatorContext.class); + } + + public InOperatorContext inOperator(int i) { + return getRuleContext(InOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public NamedInfixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_namedInfix; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterNamedInfix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitNamedInfix(this); + } + } + + public final NamedInfixContext namedInfix() throws RecognitionException { + NamedInfixContext _localctx = new NamedInfixContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_namedInfix); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1664); + elvisExpression(); + setState(1687); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 253, _ctx)) { + case 1: { + setState(1674); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1665); + inOperator(); + setState(1669); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 250, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1666); + match(NL); + } + } + } + setState(1671); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 250, _ctx); + } + setState(1672); + elvisExpression(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1676); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 251, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + break; + case 2: { + { + setState(1678); + isOperator(); + setState(1682); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1679); + match(NL); + } + } + setState(1684); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1685); + type(); + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ElvisExpressionContext extends ParserRuleContext { + public List infixFunctionCall() { + return getRuleContexts(InfixFunctionCallContext.class); + } + + public InfixFunctionCallContext infixFunctionCall(int i) { + return getRuleContext(InfixFunctionCallContext.class, i); + } + + public List ELVIS() { + return getTokens(KotlinParser.ELVIS); + } + + public TerminalNode ELVIS(int i) { + return getToken(KotlinParser.ELVIS, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ElvisExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_elvisExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterElvisExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitElvisExpression(this); + } + } + + public final ElvisExpressionContext elvisExpression() throws RecognitionException { + ElvisExpressionContext _localctx = new ElvisExpressionContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_elvisExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1689); + infixFunctionCall(); + setState(1706); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 256, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1693); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1690); + match(NL); + } + } + setState(1695); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1696); + match(ELVIS); + setState(1700); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 255, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1697); + match(NL); + } + } + } + setState(1702); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 255, _ctx); + } + setState(1703); + infixFunctionCall(); + } + } + } + setState(1708); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 256, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InfixFunctionCallContext extends ParserRuleContext { + public List rangeExpression() { + return getRuleContexts(RangeExpressionContext.class); + } + + public RangeExpressionContext rangeExpression(int i) { + return getRuleContext(RangeExpressionContext.class, i); + } + + public List simpleIdentifier() { + return getRuleContexts(SimpleIdentifierContext.class); + } + + public SimpleIdentifierContext simpleIdentifier(int i) { + return getRuleContext(SimpleIdentifierContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public InfixFunctionCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_infixFunctionCall; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInfixFunctionCall(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitInfixFunctionCall(this); + } + } + + public final InfixFunctionCallContext infixFunctionCall() throws RecognitionException { + InfixFunctionCallContext _localctx = new InfixFunctionCallContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_infixFunctionCall); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1709); + rangeExpression(); + setState(1721); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 258, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1710); + simpleIdentifier(); + setState(1714); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 257, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1711); + match(NL); + } + } + } + setState(1716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 257, _ctx); + } + setState(1717); + rangeExpression(); + } + } + } + setState(1723); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 258, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RangeExpressionContext extends ParserRuleContext { + public List additiveExpression() { + return getRuleContexts(AdditiveExpressionContext.class); + } + + public AdditiveExpressionContext additiveExpression(int i) { + return getRuleContext(AdditiveExpressionContext.class, i); + } + + public List RANGE() { + return getTokens(KotlinParser.RANGE); + } + + public TerminalNode RANGE(int i) { + return getToken(KotlinParser.RANGE, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public RangeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_rangeExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterRangeExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitRangeExpression(this); + } + } + + public final RangeExpressionContext rangeExpression() throws RecognitionException { + RangeExpressionContext _localctx = new RangeExpressionContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_rangeExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1724); + additiveExpression(); + setState(1735); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 260, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1725); + match(RANGE); + setState(1729); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 259, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1726); + match(NL); + } + } + } + setState(1731); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 259, _ctx); + } + setState(1732); + additiveExpression(); + } + } + } + setState(1737); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 260, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AdditiveExpressionContext extends ParserRuleContext { + public List multiplicativeExpression() { + return getRuleContexts(MultiplicativeExpressionContext.class); + } + + public MultiplicativeExpressionContext multiplicativeExpression(int i) { + return getRuleContext(MultiplicativeExpressionContext.class, i); + } + + public List additiveOperator() { + return getRuleContexts(AdditiveOperatorContext.class); + } + + public AdditiveOperatorContext additiveOperator(int i) { + return getRuleContext(AdditiveOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_additiveExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAdditiveExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAdditiveExpression(this); + } + } + + public final AdditiveExpressionContext additiveExpression() throws RecognitionException { + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_additiveExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1738); + multiplicativeExpression(); + setState(1750); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 262, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1739); + additiveOperator(); + setState(1743); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 261, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1740); + match(NL); + } + } + } + setState(1745); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 261, _ctx); + } + setState(1746); + multiplicativeExpression(); + } + } + } + setState(1752); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 262, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public List typeRHS() { + return getRuleContexts(TypeRHSContext.class); + } + + public TypeRHSContext typeRHS(int i) { + return getRuleContext(TypeRHSContext.class, i); + } + + public List multiplicativeOperation() { + return getRuleContexts(MultiplicativeOperationContext.class); + } + + public MultiplicativeOperationContext multiplicativeOperation(int i) { + return getRuleContext(MultiplicativeOperationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicativeExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiplicativeExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiplicativeExpression(this); + } + } + + public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { + MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_multiplicativeExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1753); + typeRHS(); + setState(1765); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 264, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1754); + multiplicativeOperation(); + setState(1758); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 263, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1755); + match(NL); + } + } + } + setState(1760); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 263, _ctx); + } + setState(1761); + typeRHS(); + } + } + } + setState(1767); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 264, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeRHSContext extends ParserRuleContext { + public List prefixUnaryExpression() { + return getRuleContexts(PrefixUnaryExpressionContext.class); + } + + public PrefixUnaryExpressionContext prefixUnaryExpression(int i) { + return getRuleContext(PrefixUnaryExpressionContext.class, i); + } + + public List typeOperation() { + return getRuleContexts(TypeOperationContext.class); + } + + public TypeOperationContext typeOperation(int i) { + return getRuleContext(TypeOperationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeRHSContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeRHS; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeRHS(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeRHS(this); + } + } + + public final TypeRHSContext typeRHS() throws RecognitionException { + TypeRHSContext _localctx = new TypeRHSContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_typeRHS); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1768); + prefixUnaryExpression(); + setState(1780); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 266, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1772); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1769); + match(NL); + } + } + setState(1774); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1775); + typeOperation(); + setState(1776); + prefixUnaryExpression(); + } + } + } + setState(1782); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 266, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrefixUnaryExpressionContext extends ParserRuleContext { + public PostfixUnaryExpressionContext postfixUnaryExpression() { + return getRuleContext(PostfixUnaryExpressionContext.class, 0); + } + + public List prefixUnaryOperation() { + return getRuleContexts(PrefixUnaryOperationContext.class); + } + + public PrefixUnaryOperationContext prefixUnaryOperation(int i) { + return getRuleContext(PrefixUnaryOperationContext.class, i); + } + + public PrefixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_prefixUnaryExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrefixUnaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrefixUnaryExpression(this); + } + } + + public final PrefixUnaryExpressionContext prefixUnaryExpression() throws RecognitionException { + PrefixUnaryExpressionContext _localctx = new PrefixUnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_prefixUnaryExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1786); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 267, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1783); + prefixUnaryOperation(); + } + } + } + setState(1788); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 267, _ctx); + } + setState(1789); + postfixUnaryExpression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PostfixUnaryExpressionContext extends ParserRuleContext { + public AtomicExpressionContext atomicExpression() { + return getRuleContext(AtomicExpressionContext.class, 0); + } + + public CallableReferenceContext callableReference() { + return getRuleContext(CallableReferenceContext.class, 0); + } + + public List postfixUnaryOperation() { + return getRuleContexts(PostfixUnaryOperationContext.class); + } + + public PostfixUnaryOperationContext postfixUnaryOperation(int i) { + return getRuleContext(PostfixUnaryOperationContext.class, i); + } + + public PostfixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_postfixUnaryExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPostfixUnaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPostfixUnaryExpression(this); + } + } + + public final PostfixUnaryExpressionContext postfixUnaryExpression() throws RecognitionException { + PostfixUnaryExpressionContext _localctx = new PostfixUnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_postfixUnaryExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1793); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 268, _ctx)) { + case 1: { + setState(1791); + atomicExpression(); + } + break; + case 2: { + setState(1792); + callableReference(); + } + break; + } + setState(1798); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 269, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1795); + postfixUnaryOperation(); + } + } + } + setState(1800); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 269, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AtomicExpressionContext extends ParserRuleContext { + public ParenthesizedExpressionContext parenthesizedExpression() { + return getRuleContext(ParenthesizedExpressionContext.class, 0); + } + + public LiteralConstantContext literalConstant() { + return getRuleContext(LiteralConstantContext.class, 0); + } + + public FunctionLiteralContext functionLiteral() { + return getRuleContext(FunctionLiteralContext.class, 0); + } + + public ThisExpressionContext thisExpression() { + return getRuleContext(ThisExpressionContext.class, 0); + } + + public SuperExpressionContext superExpression() { + return getRuleContext(SuperExpressionContext.class, 0); + } + + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class, 0); + } + + public TryExpressionContext tryExpression() { + return getRuleContext(TryExpressionContext.class, 0); + } + + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class, 0); + } + + public JumpExpressionContext jumpExpression() { + return getRuleContext(JumpExpressionContext.class, 0); + } + + public LoopExpressionContext loopExpression() { + return getRuleContext(LoopExpressionContext.class, 0); + } + + public CollectionLiteralContext collectionLiteral() { + return getRuleContext(CollectionLiteralContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public AtomicExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_atomicExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAtomicExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAtomicExpression(this); + } + } + + public final AtomicExpressionContext atomicExpression() throws RecognitionException { + AtomicExpressionContext _localctx = new AtomicExpressionContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_atomicExpression); + try { + setState(1815); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + enterOuterAlt(_localctx, 1); + { + setState(1801); + parenthesizedExpression(); + } + break; + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + case RealLiteral: + case LongLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + enterOuterAlt(_localctx, 2); + { + setState(1802); + literalConstant(); + } + break; + case LCURL: + case AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case LabelReference: + enterOuterAlt(_localctx, 3); + { + setState(1803); + functionLiteral(); + } + break; + case THIS: + enterOuterAlt(_localctx, 4); + { + setState(1804); + thisExpression(); + } + break; + case SUPER: + enterOuterAlt(_localctx, 5); + { + setState(1805); + superExpression(); + } + break; + case IF: + case WHEN: + enterOuterAlt(_localctx, 6); + { + setState(1806); + conditionalExpression(); + } + break; + case TRY: + enterOuterAlt(_localctx, 7); + { + setState(1807); + tryExpression(); + } + break; + case OBJECT: + enterOuterAlt(_localctx, 8); + { + setState(1808); + objectLiteral(); + } + break; + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + enterOuterAlt(_localctx, 9); + { + setState(1809); + jumpExpression(); + } + break; + case FOR: + case DO: + case WHILE: + enterOuterAlt(_localctx, 10); + { + setState(1810); + loopExpression(); + } + break; + case LSQUARE: + enterOuterAlt(_localctx, 11); + { + setState(1811); + collectionLiteral(); + } + break; + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: + enterOuterAlt(_localctx, 12); + { + setState(1812); + simpleIdentifier(); + } + break; + case VAL: + enterOuterAlt(_localctx, 13); + { + setState(1813); + match(VAL); + setState(1814); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParenthesizedExpressionContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedExpression(this); + } + } + + public final ParenthesizedExpressionContext parenthesizedExpression() throws RecognitionException { + ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_parenthesizedExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1817); + match(LPAREN); + setState(1818); + expression(); + setState(1819); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CallSuffixContext extends ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public List annotatedLambda() { + return getRuleContexts(AnnotatedLambdaContext.class); + } + + public AnnotatedLambdaContext annotatedLambda(int i) { + return getRuleContext(AnnotatedLambdaContext.class, i); + } + + public CallSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_callSuffix; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterCallSuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitCallSuffix(this); + } + } + + public final CallSuffixContext callSuffix() throws RecognitionException { + CallSuffixContext _localctx = new CallSuffixContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_callSuffix); + try { + int _alt; + setState(1843); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LANGLE: + enterOuterAlt(_localctx, 1); + { + setState(1821); + typeArguments(); + setState(1823); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 271, _ctx)) { + case 1: { + setState(1822); + valueArguments(); + } + break; + } + setState(1828); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 272, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1825); + annotatedLambda(); + } + } + } + setState(1830); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 272, _ctx); + } + } + break; + case LPAREN: + enterOuterAlt(_localctx, 2); + { + setState(1831); + valueArguments(); + setState(1835); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 273, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1832); + annotatedLambda(); + } + } + } + setState(1837); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 273, _ctx); + } + } + break; + case NL: + case LCURL: + case AT: + case FILE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case FIELD: + case PROPERTY: + case GET: + case SET: + case GETTER: + case SETTER: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: + case LabelReference: + case LabelDefinition: + enterOuterAlt(_localctx, 3); + { + setState(1839); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1838); + annotatedLambda(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1841); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 274, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotatedLambdaContext extends ParserRuleContext { + public FunctionLiteralContext functionLiteral() { + return getRuleContext(FunctionLiteralContext.class, 0); + } + + public List unescapedAnnotation() { + return getRuleContexts(UnescapedAnnotationContext.class); + } + + public UnescapedAnnotationContext unescapedAnnotation(int i) { + return getRuleContext(UnescapedAnnotationContext.class, i); + } + + public TerminalNode LabelDefinition() { + return getToken(KotlinParser.LabelDefinition, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public AnnotatedLambdaContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotatedLambda; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAnnotatedLambda(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAnnotatedLambda(this); + } + } + + public final AnnotatedLambdaContext annotatedLambda() throws RecognitionException { + AnnotatedLambdaContext _localctx = new AnnotatedLambdaContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_annotatedLambda); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1848); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0)) { + { + { + setState(1845); + unescapedAnnotation(); + } + } + setState(1850); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1852); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LabelDefinition) { + { + setState(1851); + match(LabelDefinition); + } + } + + setState(1857); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1854); + match(NL); + } + } + setState(1859); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1860); + functionLiteral(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArrayAccessContext extends ParserRuleContext { + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public ArrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_arrayAccess; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterArrayAccess(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitArrayAccess(this); + } + } + + public final ArrayAccessContext arrayAccess() throws RecognitionException { + ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_arrayAccess); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1862); + match(LSQUARE); + setState(1871); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4188346347763783136L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & -65012289L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 24563L) != 0)) { + { + setState(1863); + expression(); + setState(1868); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1864); + match(COMMA); + setState(1865); + expression(); + } + } + setState(1870); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(1873); + match(RSQUARE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ValueArgumentsContext extends ParserRuleContext { + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List valueArgument() { + return getRuleContexts(ValueArgumentContext.class); + } + + public ValueArgumentContext valueArgument(int i) { + return getRuleContext(ValueArgumentContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ValueArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_valueArguments; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterValueArguments(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitValueArguments(this); + } + } + + public final ValueArgumentsContext valueArguments() throws RecognitionException { + ValueArgumentsContext _localctx = new ValueArgumentsContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_valueArguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1875); + match(LPAREN); + setState(1893); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4188346347763750368L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & -65012289L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 24563L) != 0)) { + { + setState(1876); + valueArgument(); + setState(1881); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 281, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1877); + match(COMMA); + setState(1878); + valueArgument(); + } + } + } + setState(1883); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 281, _ctx); + } + setState(1891); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == NL || _la == COMMA) { + { + setState(1887); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1884); + match(NL); + } + } + setState(1889); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1890); + match(COMMA); + } + } + + } + } + + setState(1895); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeArgumentsContext extends ParserRuleContext { + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public List typeProjection() { + return getRuleContexts(TypeProjectionContext.class); + } + + public TypeProjectionContext typeProjection(int i) { + return getRuleContext(TypeProjectionContext.class, i); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public TerminalNode QUEST() { + return getToken(KotlinParser.QUEST, 0); + } + + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeArguments; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeArguments(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeArguments(this); + } + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_typeArguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1897); + match(LANGLE); + setState(1901); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1898); + match(NL); + } + } + setState(1903); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1904); + typeProjection(); + setState(1915); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 287, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1908); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1905); + match(NL); + } + } + setState(1910); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1911); + match(COMMA); + setState(1912); + typeProjection(); + } + } + } + setState(1917); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 287, _ctx); + } + setState(1925); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 289, _ctx)) { + case 1: { + setState(1921); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1918); + match(NL); + } + } + setState(1923); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1924); + match(COMMA); + } + break; + } + setState(1930); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1927); + match(NL); + } + } + setState(1932); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1933); + match(RANGLE); + setState(1935); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 291, _ctx)) { + case 1: { + setState(1934); + match(QUEST); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeProjectionContext extends ParserRuleContext { + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TypeProjectionModifierListContext typeProjectionModifierList() { + return getRuleContext(TypeProjectionModifierListContext.class, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public TypeProjectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeProjection; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeProjection(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeProjection(this); + } + } + + public final TypeProjectionContext typeProjection() throws RecognitionException { + TypeProjectionContext _localctx = new TypeProjectionContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_typeProjection); + try { + setState(1942); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case AT: + case FILE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case IN: + case OUT: + case FIELD: + case PROPERTY: + case GET: + case SET: + case GETTER: + case SETTER: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: + case LabelReference: + enterOuterAlt(_localctx, 1); + { + setState(1938); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 292, _ctx)) { + case 1: { + setState(1937); + typeProjectionModifierList(); + } + break; + } + setState(1940); + type(); + } + break; + case MULT: + enterOuterAlt(_localctx, 2); + { + setState(1941); + match(MULT); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeProjectionModifierListContext extends ParserRuleContext { + public List varianceAnnotation() { + return getRuleContexts(VarianceAnnotationContext.class); + } + + public VarianceAnnotationContext varianceAnnotation(int i) { + return getRuleContext(VarianceAnnotationContext.class, i); + } + + public TypeProjectionModifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeProjectionModifierList; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeProjectionModifierList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeProjectionModifierList(this); + } + } + + public final TypeProjectionModifierListContext typeProjectionModifierList() throws RecognitionException { + TypeProjectionModifierListContext _localctx = new TypeProjectionModifierListContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_typeProjectionModifierList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1945); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1944); + varianceAnnotation(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1947); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 294, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ValueArgumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ValueArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_valueArgument; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterValueArgument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitValueArgument(this); + } + } + + public final ValueArgumentContext valueArgument() throws RecognitionException { + ValueArgumentContext _localctx = new ValueArgumentContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_valueArgument); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1963); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 297, _ctx)) { + case 1: { + setState(1949); + simpleIdentifier(); + setState(1953); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1950); + match(NL); + } + } + setState(1955); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1956); + match(ASSIGNMENT); + setState(1960); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 296, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1957); + match(NL); + } + } + } + setState(1962); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 296, _ctx); + } + } + break; + } + setState(1966); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == MULT) { + { + setState(1965); + match(MULT); + } + } + + setState(1971); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 299, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1968); + match(NL); + } + } + } + setState(1973); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 299, _ctx); + } + setState(1974); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralConstantContext extends ParserRuleContext { + public TerminalNode BooleanLiteral() { + return getToken(KotlinParser.BooleanLiteral, 0); + } + + public TerminalNode IntegerLiteral() { + return getToken(KotlinParser.IntegerLiteral, 0); + } + + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class, 0); + } + + public TerminalNode HexLiteral() { + return getToken(KotlinParser.HexLiteral, 0); + } + + public TerminalNode BinLiteral() { + return getToken(KotlinParser.BinLiteral, 0); + } + + public TerminalNode CharacterLiteral() { + return getToken(KotlinParser.CharacterLiteral, 0); + } + + public TerminalNode RealLiteral() { + return getToken(KotlinParser.RealLiteral, 0); + } + + public TerminalNode NullLiteral() { + return getToken(KotlinParser.NullLiteral, 0); + } + + public TerminalNode LongLiteral() { + return getToken(KotlinParser.LongLiteral, 0); + } + + public LiteralConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_literalConstant; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterLiteralConstant(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLiteralConstant(this); + } + } + + public final LiteralConstantContext literalConstant() throws RecognitionException { + LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_literalConstant); + try { + setState(1985); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BooleanLiteral: + enterOuterAlt(_localctx, 1); + { + setState(1976); + match(BooleanLiteral); + } + break; + case IntegerLiteral: + enterOuterAlt(_localctx, 2); + { + setState(1977); + match(IntegerLiteral); + } + break; + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + enterOuterAlt(_localctx, 3); + { + setState(1978); + stringLiteral(); + } + break; + case HexLiteral: + enterOuterAlt(_localctx, 4); + { + setState(1979); + match(HexLiteral); + } + break; + case BinLiteral: + enterOuterAlt(_localctx, 5); + { + setState(1980); + match(BinLiteral); + } + break; + case CharacterLiteral: + enterOuterAlt(_localctx, 6); + { + setState(1981); + match(CharacterLiteral); + } + break; + case RealLiteral: + enterOuterAlt(_localctx, 7); + { + setState(1982); + match(RealLiteral); + } + break; + case NullLiteral: + enterOuterAlt(_localctx, 8); + { + setState(1983); + match(NullLiteral); + } + break; + case LongLiteral: + enterOuterAlt(_localctx, 9); + { + setState(1984); + match(LongLiteral); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringLiteralContext extends ParserRuleContext { + public LineStringLiteralContext lineStringLiteral() { + return getRuleContext(LineStringLiteralContext.class, 0); + } + + public MultiLineStringLiteralContext multiLineStringLiteral() { + return getRuleContext(MultiLineStringLiteralContext.class, 0); + } + + public StringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_stringLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitStringLiteral(this); + } + } + + public final StringLiteralContext stringLiteral() throws RecognitionException { + StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_stringLiteral); + try { + setState(1989); + _errHandler.sync(this); + switch (_input.LA(1)) { + case QUOTE_OPEN: + enterOuterAlt(_localctx, 1); + { + setState(1987); + lineStringLiteral(); + } + break; + case TRIPLE_QUOTE_OPEN: + enterOuterAlt(_localctx, 2); + { + setState(1988); + multiLineStringLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LineStringLiteralContext extends ParserRuleContext { + public TerminalNode QUOTE_OPEN() { + return getToken(KotlinParser.QUOTE_OPEN, 0); + } + + public TerminalNode QUOTE_CLOSE() { + return getToken(KotlinParser.QUOTE_CLOSE, 0); + } + + public List lineStringContent() { + return getRuleContexts(LineStringContentContext.class); + } + + public LineStringContentContext lineStringContent(int i) { + return getRuleContext(LineStringContentContext.class, i); + } + + public List lineStringExpression() { + return getRuleContexts(LineStringExpressionContext.class); + } + + public LineStringExpressionContext lineStringExpression(int i) { + return getRuleContext(LineStringExpressionContext.class, i); + } + + public LineStringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLineStringLiteral(this); + } + } + + public final LineStringLiteralContext lineStringLiteral() throws RecognitionException { + LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_lineStringLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1991); + match(QUOTE_OPEN); + setState(1996); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 156)) & ~0x3f) == 0 && ((1L << (_la - 156)) & 15L) != 0)) { + { + setState(1994); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LineStrRef: + case LineStrText: + case LineStrEscapedChar: { + setState(1992); + lineStringContent(); + } + break; + case LineStrExprStart: { + setState(1993); + lineStringExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(1998); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1999); + match(QUOTE_CLOSE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiLineStringLiteralContext extends ParserRuleContext { + public TerminalNode TRIPLE_QUOTE_OPEN() { + return getToken(KotlinParser.TRIPLE_QUOTE_OPEN, 0); + } + + public TerminalNode TRIPLE_QUOTE_CLOSE() { + return getToken(KotlinParser.TRIPLE_QUOTE_CLOSE, 0); + } + + public List multiLineStringContent() { + return getRuleContexts(MultiLineStringContentContext.class); + } + + public MultiLineStringContentContext multiLineStringContent(int i) { + return getRuleContext(MultiLineStringContentContext.class, i); + } + + public List multiLineStringExpression() { + return getRuleContexts(MultiLineStringExpressionContext.class); + } + + public MultiLineStringExpressionContext multiLineStringExpression(int i) { + return getRuleContext(MultiLineStringExpressionContext.class, i); + } + + public List lineStringLiteral() { + return getRuleContexts(LineStringLiteralContext.class); + } + + public LineStringLiteralContext lineStringLiteral(int i) { + return getRuleContext(LineStringLiteralContext.class, i); + } + + public List MultiLineStringQuote() { + return getTokens(KotlinParser.MultiLineStringQuote); + } + + public TerminalNode MultiLineStringQuote(int i) { + return getToken(KotlinParser.MultiLineStringQuote, i); + } + + public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringLiteral(this); + } + } + + public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException { + MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_multiLineStringLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2001); + match(TRIPLE_QUOTE_OPEN); + setState(2008); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 133143986177L) != 0)) { + { + setState(2006); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MultiLineStrRef: + case MultiLineStrText: + case MultiLineStrEscapedChar: { + setState(2002); + multiLineStringContent(); + } + break; + case MultiLineStrExprStart: { + setState(2003); + multiLineStringExpression(); + } + break; + case QUOTE_OPEN: { + setState(2004); + lineStringLiteral(); + } + break; + case MultiLineStringQuote: { + setState(2005); + match(MultiLineStringQuote); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(2010); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2011); + match(TRIPLE_QUOTE_CLOSE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LineStringContentContext extends ParserRuleContext { + public TerminalNode LineStrText() { + return getToken(KotlinParser.LineStrText, 0); + } + + public TerminalNode LineStrEscapedChar() { + return getToken(KotlinParser.LineStrEscapedChar, 0); + } + + public TerminalNode LineStrRef() { + return getToken(KotlinParser.LineStrRef, 0); + } + + public LineStringContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringContent; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLineStringContent(this); + } + } + + public final LineStringContentContext lineStringContent() throws RecognitionException { + LineStringContentContext _localctx = new LineStringContentContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_lineStringContent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2013); + _la = _input.LA(1); + if (!(((((_la - 156)) & ~0x3f) == 0 && ((1L << (_la - 156)) & 7L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LineStringExpressionContext extends ParserRuleContext { + public TerminalNode LineStrExprStart() { + return getToken(KotlinParser.LineStrExprStart, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public LineStringExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLineStringExpression(this); + } + } + + public final LineStringExpressionContext lineStringExpression() throws RecognitionException { + LineStringExpressionContext _localctx = new LineStringExpressionContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_lineStringExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2015); + match(LineStrExprStart); + setState(2016); + expression(); + setState(2017); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiLineStringContentContext extends ParserRuleContext { + public TerminalNode MultiLineStrText() { + return getToken(KotlinParser.MultiLineStrText, 0); + } + + public TerminalNode MultiLineStrEscapedChar() { + return getToken(KotlinParser.MultiLineStrEscapedChar, 0); + } + + public TerminalNode MultiLineStrRef() { + return getToken(KotlinParser.MultiLineStrRef, 0); + } + + public MultiLineStringContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringContent; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringContent(this); + } + } + + public final MultiLineStringContentContext multiLineStringContent() throws RecognitionException { + MultiLineStringContentContext _localctx = new MultiLineStringContentContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_multiLineStringContent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2019); + _la = _input.LA(1); + if (!(((((_la - 162)) & ~0x3f) == 0 && ((1L << (_la - 162)) & 7L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiLineStringExpressionContext extends ParserRuleContext { + public TerminalNode MultiLineStrExprStart() { + return getToken(KotlinParser.MultiLineStrExprStart, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public MultiLineStringExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringExpression(this); + } + } + + public final MultiLineStringExpressionContext multiLineStringExpression() throws RecognitionException { + MultiLineStringExpressionContext _localctx = new MultiLineStringExpressionContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_multiLineStringExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2021); + match(MultiLineStrExprStart); + setState(2022); + expression(); + setState(2023); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionLiteralContext extends ParserRuleContext { + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public LambdaParametersContext lambdaParameters() { + return getRuleContext(LambdaParametersContext.class, 0); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public FunctionLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFunctionLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFunctionLiteral(this); + } + } + + public final FunctionLiteralContext functionLiteral() throws RecognitionException { + FunctionLiteralContext _localctx = new FunctionLiteralContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_functionLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2028); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(2025); + annotations(); + } + } + setState(2030); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2077); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 313, _ctx)) { + case 1: { + setState(2031); + match(LCURL); + setState(2035); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 307, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2032); + match(NL); + } + } + } + setState(2037); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 307, _ctx); + } + setState(2038); + statements(); + setState(2042); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2039); + match(NL); + } + } + setState(2044); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2045); + match(RCURL); + } + break; + case 2: { + setState(2047); + match(LCURL); + setState(2051); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2048); + match(NL); + } + } + } + setState(2053); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); + } + setState(2054); + lambdaParameters(); + setState(2058); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2055); + match(NL); + } + } + setState(2060); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2061); + match(ARROW); + setState(2065); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 311, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2062); + match(NL); + } + } + } + setState(2067); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 311, _ctx); + } + setState(2068); + statements(); + setState(2072); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2069); + match(NL); + } + } + setState(2074); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2075); + match(RCURL); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LambdaParametersContext extends ParserRuleContext { + public List lambdaParameter() { + return getRuleContexts(LambdaParameterContext.class); + } + + public LambdaParameterContext lambdaParameter(int i) { + return getRuleContext(LambdaParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaParameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterLambdaParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLambdaParameters(this); + } + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_lambdaParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2080); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LPAREN || _la == IMPORT || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 9223371905925394575L) != 0) || _la == Identifier) { + { + setState(2079); + lambdaParameter(); + } + } + + setState(2098); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 317, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2085); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2082); + match(NL); + } + } + setState(2087); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2088); + match(COMMA); + setState(2092); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2089); + match(NL); + } + } + setState(2094); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2095); + lambdaParameter(); + } + } + } + setState(2100); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 317, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LambdaParameterContext extends ParserRuleContext { + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public LambdaParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaParameter; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterLambdaParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLambdaParameter(this); + } + } + + public final LambdaParameterContext lambdaParameter() throws RecognitionException { + LambdaParameterContext _localctx = new LambdaParameterContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_lambdaParameter); + int _la; + try { + setState(2119); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(2101); + variableDeclaration(); + } + break; + case LPAREN: + enterOuterAlt(_localctx, 2); + { + setState(2102); + multiVariableDeclaration(); + setState(2117); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 320, _ctx)) { + case 1: { + setState(2106); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2103); + match(NL); + } + } + setState(2108); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2109); + match(COLON); + setState(2113); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2110); + match(NL); + } + } + setState(2115); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2116); + type(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ObjectLiteralContext extends ParserRuleContext { + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public ObjectLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_objectLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterObjectLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitObjectLiteral(this); + } + } + + public final ObjectLiteralContext objectLiteral() throws RecognitionException { + ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_objectLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2121); + match(OBJECT); + setState(2136); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 324, _ctx)) { + case 1: { + setState(2125); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2122); + match(NL); + } + } + setState(2127); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2128); + match(COLON); + setState(2132); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2129); + match(NL); + } + } + setState(2134); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2135); + delegationSpecifiers(); + } + break; + } + setState(2141); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 325, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2138); + match(NL); + } + } + } + setState(2143); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 325, _ctx); + } + setState(2145); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 326, _ctx)) { + case 1: { + setState(2144); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CollectionLiteralContext extends ParserRuleContext { + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public CollectionLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_collectionLiteral; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCollectionLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitCollectionLiteral(this); + } + } + + public final CollectionLiteralContext collectionLiteral() throws RecognitionException { + CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_collectionLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2147); + match(LSQUARE); + setState(2149); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4188346347763783136L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & -65012289L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 24563L) != 0)) { + { + setState(2148); + expression(); + } + } + + setState(2155); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(2151); + match(COMMA); + setState(2152); + expression(); + } + } + setState(2157); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2158); + match(RSQUARE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ThisExpressionContext extends ParserRuleContext { + public TerminalNode THIS() { + return getToken(KotlinParser.THIS, 0); + } + + public TerminalNode LabelReference() { + return getToken(KotlinParser.LabelReference, 0); + } + + public ThisExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_thisExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterThisExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitThisExpression(this); + } + } + + public final ThisExpressionContext thisExpression() throws RecognitionException { + ThisExpressionContext _localctx = new ThisExpressionContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_thisExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2160); + match(THIS); + setState(2162); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 329, _ctx)) { + case 1: { + setState(2161); + match(LabelReference); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SuperExpressionContext extends ParserRuleContext { + public TerminalNode SUPER() { + return getToken(KotlinParser.SUPER, 0); + } + + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public TerminalNode LabelReference() { + return getToken(KotlinParser.LabelReference, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SuperExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_superExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterSuperExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitSuperExpression(this); + } + } + + public final SuperExpressionContext superExpression() throws RecognitionException { + SuperExpressionContext _localctx = new SuperExpressionContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_superExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2164); + match(SUPER); + setState(2181); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 332, _ctx)) { + case 1: { + setState(2165); + match(LANGLE); + setState(2169); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2166); + match(NL); + } + } + setState(2171); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2172); + type(); + setState(2176); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2173); + match(NL); + } + } + setState(2178); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2179); + match(RANGLE); + } + break; + } + setState(2184); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 333, _ctx)) { + case 1: { + setState(2183); + match(LabelReference); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConditionalExpressionContext extends ParserRuleContext { + public IfExpressionContext ifExpression() { + return getRuleContext(IfExpressionContext.class, 0); + } + + public WhenExpressionContext whenExpression() { + return getRuleContext(WhenExpressionContext.class, 0); + } + + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conditionalExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConditionalExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConditionalExpression(this); + } + } + + public final ConditionalExpressionContext conditionalExpression() throws RecognitionException { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_conditionalExpression); + try { + setState(2188); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IF: + enterOuterAlt(_localctx, 1); + { + setState(2186); + ifExpression(); + } + break; + case WHEN: + enterOuterAlt(_localctx, 2); + { + setState(2187); + whenExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfExpressionContext extends ParserRuleContext { + public TerminalNode IF() { + return getToken(KotlinParser.IF, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List controlStructureBody() { + return getRuleContexts(ControlStructureBodyContext.class); + } + + public ControlStructureBodyContext controlStructureBody(int i) { + return getRuleContext(ControlStructureBodyContext.class, i); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public TerminalNode ELSE() { + return getToken(KotlinParser.ELSE, 0); + } + + public IfExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_ifExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterIfExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitIfExpression(this); + } + } + + public final IfExpressionContext ifExpression() throws RecognitionException { + IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_ifExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2190); + match(IF); + setState(2194); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2191); + match(NL); + } + } + setState(2196); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2197); + match(LPAREN); + setState(2198); + expression(); + setState(2199); + match(RPAREN); + setState(2203); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 336, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2200); + match(NL); + } + } + } + setState(2205); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 336, _ctx); + } + setState(2207); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 337, _ctx)) { + case 1: { + setState(2206); + controlStructureBody(); + } + break; + } + setState(2210); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 338, _ctx)) { + case 1: { + setState(2209); + match(SEMICOLON); + } + break; + } + setState(2228); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 342, _ctx)) { + case 1: { + setState(2215); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2212); + match(NL); + } + } + setState(2217); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2218); + match(ELSE); + setState(2222); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 340, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2219); + match(NL); + } + } + } + setState(2224); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 340, _ctx); + } + setState(2226); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 341, _ctx)) { + case 1: { + setState(2225); + controlStructureBody(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ControlStructureBodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public ControlStructureBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_controlStructureBody; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterControlStructureBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitControlStructureBody(this); + } + } + + public final ControlStructureBodyContext controlStructureBody() throws RecognitionException { + ControlStructureBodyContext _localctx = new ControlStructureBodyContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_controlStructureBody); + try { + setState(2232); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 343, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2230); + block(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2231); + expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhenExpressionContext extends ParserRuleContext { + public TerminalNode WHEN() { + return getToken(KotlinParser.WHEN, 0); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List whenEntry() { + return getRuleContexts(WhenEntryContext.class); + } + + public WhenEntryContext whenEntry(int i) { + return getRuleContext(WhenEntryContext.class, i); + } + + public WhenExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_whenExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterWhenExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitWhenExpression(this); + } + } + + public final WhenExpressionContext whenExpression() throws RecognitionException { + WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_whenExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2234); + match(WHEN); + setState(2238); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 344, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2235); + match(NL); + } + } + } + setState(2240); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 344, _ctx); + } + setState(2245); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LPAREN) { + { + setState(2241); + match(LPAREN); + setState(2242); + expression(); + setState(2243); + match(RPAREN); + } + } + + setState(2250); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2247); + match(NL); + } + } + setState(2252); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2253); + match(LCURL); + setState(2257); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 347, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2254); + match(NL); + } + } + } + setState(2259); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 347, _ctx); + } + setState(2269); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 349, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2260); + whenEntry(); + setState(2264); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 348, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2261); + match(NL); + } + } + } + setState(2266); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 348, _ctx); + } + } + } + } + setState(2271); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 349, _ctx); + } + setState(2275); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2272); + match(NL); + } + } + setState(2277); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2278); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhenEntryContext extends ParserRuleContext { + public List whenCondition() { + return getRuleContexts(WhenConditionContext.class); + } + + public WhenConditionContext whenCondition(int i) { + return getRuleContext(WhenConditionContext.class, i); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + public TerminalNode ELSE() { + return getToken(KotlinParser.ELSE, 0); + } + + public WhenEntryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_whenEntry; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterWhenEntry(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitWhenEntry(this); + } + } + + public final WhenEntryContext whenEntry() throws RecognitionException { + WhenEntryContext _localctx = new WhenEntryContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_whenEntry); + int _la; + try { + int _alt; + setState(2332); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL: + case COLONCOLON: + case Q_COLONCOLON: + case AT: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case FILE: + case IMPORT: + case OBJECT: + case VAL: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case IS: + case IN: + case NOT_IS: + case NOT_IN: + case OUT: + case FIELD: + case PROPERTY: + case GET: + case SET: + case GETTER: + case SETTER: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + case RealLiteral: + case LongLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case BooleanLiteral: + case NullLiteral: + case Identifier: + case LabelReference: + case LabelDefinition: + case CharacterLiteral: + enterOuterAlt(_localctx, 1); + { + setState(2280); + whenCondition(); + setState(2297); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 353, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2284); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2281); + match(NL); + } + } + setState(2286); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2287); + match(COMMA); + setState(2291); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 352, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2288); + match(NL); + } + } + } + setState(2293); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 352, _ctx); + } + setState(2294); + whenCondition(); + } + } + } + setState(2299); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 353, _ctx); + } + setState(2303); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2300); + match(NL); + } + } + setState(2305); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2306); + match(ARROW); + setState(2310); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 355, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2307); + match(NL); + } + } + } + setState(2312); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 355, _ctx); + } + setState(2313); + controlStructureBody(); + setState(2315); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 356, _ctx)) { + case 1: { + setState(2314); + semi(); + } + break; + } + } + break; + case ELSE: + enterOuterAlt(_localctx, 2); + { + setState(2317); + match(ELSE); + setState(2321); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2318); + match(NL); + } + } + setState(2323); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2324); + match(ARROW); + setState(2328); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 358, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2325); + match(NL); + } + } + } + setState(2330); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 358, _ctx); + } + setState(2331); + controlStructureBody(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhenConditionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public RangeTestContext rangeTest() { + return getRuleContext(RangeTestContext.class, 0); + } + + public TypeTestContext typeTest() { + return getRuleContext(TypeTestContext.class, 0); + } + + public WhenConditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_whenCondition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterWhenCondition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitWhenCondition(this); + } + } + + public final WhenConditionContext whenCondition() throws RecognitionException { + WhenConditionContext _localctx = new WhenConditionContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_whenCondition); + try { + setState(2337); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL: + case COLONCOLON: + case Q_COLONCOLON: + case AT: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case FILE: + case IMPORT: + case OBJECT: + case VAL: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case OUT: + case FIELD: + case PROPERTY: + case GET: + case SET: + case GETTER: + case SETTER: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + case RealLiteral: + case LongLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case BooleanLiteral: + case NullLiteral: + case Identifier: + case LabelReference: + case LabelDefinition: + case CharacterLiteral: + enterOuterAlt(_localctx, 1); + { + setState(2334); + expression(); + } + break; + case IN: + case NOT_IN: + enterOuterAlt(_localctx, 2); + { + setState(2335); + rangeTest(); + } + break; + case IS: + case NOT_IS: + enterOuterAlt(_localctx, 3); + { + setState(2336); + typeTest(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RangeTestContext extends ParserRuleContext { + public InOperatorContext inOperator() { + return getRuleContext(InOperatorContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public RangeTestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_rangeTest; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterRangeTest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitRangeTest(this); + } + } + + public final RangeTestContext rangeTest() throws RecognitionException { + RangeTestContext _localctx = new RangeTestContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_rangeTest); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2339); + inOperator(); + setState(2343); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 361, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2340); + match(NL); + } + } + } + setState(2345); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 361, _ctx); + } + setState(2346); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeTestContext extends ParserRuleContext { + public IsOperatorContext isOperator() { + return getRuleContext(IsOperatorContext.class, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeTestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeTest; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeTest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeTest(this); + } + } + + public final TypeTestContext typeTest() throws RecognitionException { + TypeTestContext _localctx = new TypeTestContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_typeTest); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2348); + isOperator(); + setState(2352); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2349); + match(NL); + } + } + setState(2354); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2355); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TryExpressionContext extends ParserRuleContext { + public TerminalNode TRY() { + return getToken(KotlinParser.TRY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List catchBlock() { + return getRuleContexts(CatchBlockContext.class); + } + + public CatchBlockContext catchBlock(int i) { + return getRuleContext(CatchBlockContext.class, i); + } + + public FinallyBlockContext finallyBlock() { + return getRuleContext(FinallyBlockContext.class, 0); + } + + public TryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_tryExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTryExpression(this); + } + } + + public final TryExpressionContext tryExpression() throws RecognitionException { + TryExpressionContext _localctx = new TryExpressionContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_tryExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2357); + match(TRY); + setState(2361); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2358); + match(NL); + } + } + setState(2363); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2364); + block(); + setState(2374); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 365, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2368); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2365); + match(NL); + } + } + setState(2370); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2371); + catchBlock(); + } + } + } + setState(2376); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 365, _ctx); + } + setState(2384); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 367, _ctx)) { + case 1: { + setState(2380); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2377); + match(NL); + } + } + setState(2382); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2383); + finallyBlock(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CatchBlockContext extends ParserRuleContext { + public TerminalNode CATCH() { + return getToken(KotlinParser.CATCH, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public CatchBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_catchBlock; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterCatchBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitCatchBlock(this); + } + } + + public final CatchBlockContext catchBlock() throws RecognitionException { + CatchBlockContext _localctx = new CatchBlockContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_catchBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2386); + match(CATCH); + setState(2390); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2387); + match(NL); + } + } + setState(2392); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2393); + match(LPAREN); + setState(2397); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(2394); + annotations(); + } + } + setState(2399); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2400); + simpleIdentifier(); + setState(2401); + match(COLON); + setState(2402); + userType(); + setState(2403); + match(RPAREN); + setState(2407); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2404); + match(NL); + } + } + setState(2409); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2410); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FinallyBlockContext extends ParserRuleContext { + public TerminalNode FINALLY() { + return getToken(KotlinParser.FINALLY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public FinallyBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_finallyBlock; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFinallyBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFinallyBlock(this); + } + } + + public final FinallyBlockContext finallyBlock() throws RecognitionException { + FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_finallyBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2412); + match(FINALLY); + setState(2416); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2413); + match(NL); + } + } + setState(2418); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2419); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoopExpressionContext extends ParserRuleContext { + public ForExpressionContext forExpression() { + return getRuleContext(ForExpressionContext.class, 0); + } + + public WhileExpressionContext whileExpression() { + return getRuleContext(WhileExpressionContext.class, 0); + } + + public DoWhileExpressionContext doWhileExpression() { + return getRuleContext(DoWhileExpressionContext.class, 0); + } + + public LoopExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_loopExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterLoopExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLoopExpression(this); + } + } + + public final LoopExpressionContext loopExpression() throws RecognitionException { + LoopExpressionContext _localctx = new LoopExpressionContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_loopExpression); + try { + setState(2424); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(2421); + forExpression(); + } + break; + case WHILE: + enterOuterAlt(_localctx, 2); + { + setState(2422); + whileExpression(); + } + break; + case DO: + enterOuterAlt(_localctx, 3); + { + setState(2423); + doWhileExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ForExpressionContext extends ParserRuleContext { + public TerminalNode FOR() { + return getToken(KotlinParser.FOR, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public ForExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_forExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterForExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitForExpression(this); + } + } + + public final ForExpressionContext forExpression() throws RecognitionException { + ForExpressionContext _localctx = new ForExpressionContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_forExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2426); + match(FOR); + setState(2430); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2427); + match(NL); + } + } + setState(2432); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2433); + match(LPAREN); + setState(2437); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == FILE || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 281474976711631L) != 0)) { + { + { + setState(2434); + annotations(); + } + } + setState(2439); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2442); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: { + setState(2440); + variableDeclaration(); + } + break; + case LPAREN: { + setState(2441); + multiVariableDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2444); + match(IN); + setState(2445); + expression(); + setState(2446); + match(RPAREN); + setState(2450); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 376, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2447); + match(NL); + } + } + } + setState(2452); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 376, _ctx); + } + setState(2454); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 377, _ctx)) { + case 1: { + setState(2453); + controlStructureBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhileExpressionContext extends ParserRuleContext { + public TerminalNode WHILE() { + return getToken(KotlinParser.WHILE, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public WhileExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_whileExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterWhileExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitWhileExpression(this); + } + } + + public final WhileExpressionContext whileExpression() throws RecognitionException { + WhileExpressionContext _localctx = new WhileExpressionContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_whileExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2456); + match(WHILE); + setState(2460); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2457); + match(NL); + } + } + setState(2462); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2463); + match(LPAREN); + setState(2464); + expression(); + setState(2465); + match(RPAREN); + setState(2469); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 379, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2466); + match(NL); + } + } + } + setState(2471); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 379, _ctx); + } + setState(2473); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 380, _ctx)) { + case 1: { + setState(2472); + controlStructureBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DoWhileExpressionContext extends ParserRuleContext { + public TerminalNode DO() { + return getToken(KotlinParser.DO, 0); + } + + public TerminalNode WHILE() { + return getToken(KotlinParser.WHILE, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public DoWhileExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_doWhileExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDoWhileExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitDoWhileExpression(this); + } + } + + public final DoWhileExpressionContext doWhileExpression() throws RecognitionException { + DoWhileExpressionContext _localctx = new DoWhileExpressionContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_doWhileExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2475); + match(DO); + setState(2479); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 381, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2476); + match(NL); + } + } + } + setState(2481); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 381, _ctx); + } + setState(2483); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 382, _ctx)) { + case 1: { + setState(2482); + controlStructureBody(); + } + break; + } + setState(2488); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2485); + match(NL); + } + } + setState(2490); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2491); + match(WHILE); + setState(2495); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2492); + match(NL); + } + } + setState(2497); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2498); + match(LPAREN); + setState(2499); + expression(); + setState(2500); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JumpExpressionContext extends ParserRuleContext { + public TerminalNode THROW() { + return getToken(KotlinParser.THROW, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode RETURN() { + return getToken(KotlinParser.RETURN, 0); + } + + public TerminalNode RETURN_AT() { + return getToken(KotlinParser.RETURN_AT, 0); + } + + public TerminalNode CONTINUE() { + return getToken(KotlinParser.CONTINUE, 0); + } + + public TerminalNode CONTINUE_AT() { + return getToken(KotlinParser.CONTINUE_AT, 0); + } + + public TerminalNode BREAK() { + return getToken(KotlinParser.BREAK, 0); + } + + public TerminalNode BREAK_AT() { + return getToken(KotlinParser.BREAK_AT, 0); + } + + public JumpExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_jumpExpression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterJumpExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitJumpExpression(this); + } + } + + public final JumpExpressionContext jumpExpression() throws RecognitionException { + JumpExpressionContext _localctx = new JumpExpressionContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_jumpExpression); + int _la; + try { + int _alt; + setState(2518); + _errHandler.sync(this); + switch (_input.LA(1)) { + case THROW: + enterOuterAlt(_localctx, 1); + { + setState(2502); + match(THROW); + setState(2506); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 385, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2503); + match(NL); + } + } + } + setState(2508); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 385, _ctx); + } + setState(2509); + expression(); + } + break; + case RETURN_AT: + case RETURN: + enterOuterAlt(_localctx, 2); + { + setState(2510); + _la = _input.LA(1); + if (!(_la == RETURN_AT || _la == RETURN)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2512); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 386, _ctx)) { + case 1: { + setState(2511); + expression(); + } + break; + } + } + break; + case CONTINUE: + enterOuterAlt(_localctx, 3); + { + setState(2514); + match(CONTINUE); + } + break; + case CONTINUE_AT: + enterOuterAlt(_localctx, 4); + { + setState(2515); + match(CONTINUE_AT); + } + break; + case BREAK: + enterOuterAlt(_localctx, 5); + { + setState(2516); + match(BREAK); + } + break; + case BREAK_AT: + enterOuterAlt(_localctx, 6); + { + setState(2517); + match(BREAK_AT); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CallableReferenceContext extends ParserRuleContext { + public TerminalNode COLONCOLON() { + return getToken(KotlinParser.COLONCOLON, 0); + } + + public TerminalNode Q_COLONCOLON() { + return getToken(KotlinParser.Q_COLONCOLON, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(KotlinParser.CLASS, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List QUEST() { + return getTokens(KotlinParser.QUEST); + } + + public TerminalNode QUEST(int i) { + return getToken(KotlinParser.QUEST, i); + } + + public TerminalNode THIS() { + return getToken(KotlinParser.THIS, 0); + } + + public CallableReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_callableReference; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCallableReference(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitCallableReference(this); + } + } + + public final CallableReferenceContext callableReference() throws RecognitionException { + CallableReferenceContext _localctx = new CallableReferenceContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_callableReference); + int _la; + try { + int _alt; + setState(2567); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case COLONCOLON: + case Q_COLONCOLON: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(2533); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0)) { + { + setState(2520); + userType(); + setState(2530); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == QUEST) { + { + { + setState(2521); + match(QUEST); + setState(2525); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 388, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2522); + match(NL); + } + } + } + setState(2527); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 388, _ctx); + } + } + } + setState(2532); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(2538); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2535); + match(NL); + } + } + setState(2540); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2541); + _la = _input.LA(1); + if (!(_la == COLONCOLON || _la == Q_COLONCOLON)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2545); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2542); + match(NL); + } + } + setState(2547); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2550); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case GETTER: + case SETTER: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case Identifier: { + setState(2548); + identifier(); + } + break; + case CLASS: { + setState(2549); + match(CLASS); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case THIS: + enterOuterAlt(_localctx, 2); + { + setState(2552); + match(THIS); + setState(2556); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2553); + match(NL); + } + } + setState(2558); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2559); + match(COLONCOLON); + setState(2563); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2560); + match(NL); + } + } + setState(2565); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2566); + match(CLASS); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssignmentOperatorContext extends ParserRuleContext { + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public TerminalNode ADD_ASSIGNMENT() { + return getToken(KotlinParser.ADD_ASSIGNMENT, 0); + } + + public TerminalNode SUB_ASSIGNMENT() { + return getToken(KotlinParser.SUB_ASSIGNMENT, 0); + } + + public TerminalNode MULT_ASSIGNMENT() { + return getToken(KotlinParser.MULT_ASSIGNMENT, 0); + } + + public TerminalNode DIV_ASSIGNMENT() { + return getToken(KotlinParser.DIV_ASSIGNMENT, 0); + } + + public TerminalNode MOD_ASSIGNMENT() { + return getToken(KotlinParser.MOD_ASSIGNMENT, 0); + } + + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assignmentOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAssignmentOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAssignmentOperator(this); + } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2569); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 8455716864L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EqualityOperationContext extends ParserRuleContext { + public TerminalNode EXCL_EQ() { + return getToken(KotlinParser.EXCL_EQ, 0); + } + + public TerminalNode EXCL_EQEQ() { + return getToken(KotlinParser.EXCL_EQEQ, 0); + } + + public TerminalNode EQEQ() { + return getToken(KotlinParser.EQEQ, 0); + } + + public TerminalNode EQEQEQ() { + return getToken(KotlinParser.EQEQEQ, 0); + } + + public EqualityOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_equalityOperation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEqualityOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitEqualityOperation(this); + } + } + + public final EqualityOperationContext equalityOperation() throws RecognitionException { + EqualityOperationContext _localctx = new EqualityOperationContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_equalityOperation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2571); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 3799912185593856L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ComparisonOperatorContext extends ParserRuleContext { + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public TerminalNode LE() { + return getToken(KotlinParser.LE, 0); + } + + public TerminalNode GE() { + return getToken(KotlinParser.GE, 0); + } + + public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_comparisonOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterComparisonOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitComparisonOperator(this); + } + } + + public final ComparisonOperatorContext comparisonOperator() throws RecognitionException { + ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_comparisonOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2573); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 131941395333120L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InOperatorContext extends ParserRuleContext { + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public TerminalNode NOT_IN() { + return getToken(KotlinParser.NOT_IN, 0); + } + + public InOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_inOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterInOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitInOperator(this); + } + } + + public final InOperatorContext inOperator() throws RecognitionException { + InOperatorContext _localctx = new InOperatorContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_inOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2575); + _la = _input.LA(1); + if (!(_la == IN || _la == NOT_IN)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IsOperatorContext extends ParserRuleContext { + public TerminalNode IS() { + return getToken(KotlinParser.IS, 0); + } + + public TerminalNode NOT_IS() { + return getToken(KotlinParser.NOT_IS, 0); + } + + public IsOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_isOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterIsOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitIsOperator(this); + } + } + + public final IsOperatorContext isOperator() throws RecognitionException { + IsOperatorContext _localctx = new IsOperatorContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_isOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2577); + _la = _input.LA(1); + if (!(_la == IS || _la == NOT_IS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AdditiveOperatorContext extends ParserRuleContext { + public TerminalNode ADD() { + return getToken(KotlinParser.ADD, 0); + } + + public TerminalNode SUB() { + return getToken(KotlinParser.SUB, 0); + } + + public AdditiveOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_additiveOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAdditiveOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAdditiveOperator(this); + } + } + + public final AdditiveOperatorContext additiveOperator() throws RecognitionException { + AdditiveOperatorContext _localctx = new AdditiveOperatorContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_additiveOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2579); + _la = _input.LA(1); + if (!(_la == ADD || _la == SUB)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultiplicativeOperationContext extends ParserRuleContext { + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public TerminalNode DIV() { + return getToken(KotlinParser.DIV, 0); + } + + public TerminalNode MOD() { + return getToken(KotlinParser.MOD, 0); + } + + public MultiplicativeOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicativeOperation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiplicativeOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiplicativeOperation(this); + } + } + + public final MultiplicativeOperationContext multiplicativeOperation() throws RecognitionException { + MultiplicativeOperationContext _localctx = new MultiplicativeOperationContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_multiplicativeOperation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2581); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & 229376L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeOperationContext extends ParserRuleContext { + public TerminalNode AS() { + return getToken(KotlinParser.AS, 0); + } + + public TerminalNode AS_SAFE() { + return getToken(KotlinParser.AS_SAFE, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeOperation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterTypeOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitTypeOperation(this); + } + } + + public final TypeOperationContext typeOperation() throws RecognitionException { + TypeOperationContext _localctx = new TypeOperationContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_typeOperation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2583); + _la = _input.LA(1); + if (!(((((_la - 25)) & ~0x3f) == 0 && ((1L << (_la - 25)) & 4611686018444165121L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrefixUnaryOperationContext extends ParserRuleContext { + public TerminalNode INCR() { + return getToken(KotlinParser.INCR, 0); + } + + public TerminalNode DECR() { + return getToken(KotlinParser.DECR, 0); + } + + public TerminalNode ADD() { + return getToken(KotlinParser.ADD, 0); + } + + public TerminalNode SUB() { + return getToken(KotlinParser.SUB, 0); + } + + public TerminalNode EXCL() { + return getToken(KotlinParser.EXCL, 0); + } + + public AnnotationsContext annotations() { + return getRuleContext(AnnotationsContext.class, 0); + } + + public LabelDefinitionContext labelDefinition() { + return getRuleContext(LabelDefinitionContext.class, 0); + } + + public PrefixUnaryOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_prefixUnaryOperation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrefixUnaryOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrefixUnaryOperation(this); + } + } + + public final PrefixUnaryOperationContext prefixUnaryOperation() throws RecognitionException { + PrefixUnaryOperationContext _localctx = new PrefixUnaryOperationContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_prefixUnaryOperation); + try { + setState(2592); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INCR: + enterOuterAlt(_localctx, 1); + { + setState(2585); + match(INCR); + } + break; + case DECR: + enterOuterAlt(_localctx, 2); + { + setState(2586); + match(DECR); + } + break; + case ADD: + enterOuterAlt(_localctx, 3); + { + setState(2587); + match(ADD); + } + break; + case SUB: + enterOuterAlt(_localctx, 4); + { + setState(2588); + match(SUB); + } + break; + case EXCL: + enterOuterAlt(_localctx, 5); + { + setState(2589); + match(EXCL); + } + break; + case AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case LabelReference: + enterOuterAlt(_localctx, 6); + { + setState(2590); + annotations(); + } + break; + case LabelDefinition: + enterOuterAlt(_localctx, 7); + { + setState(2591); + labelDefinition(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PostfixUnaryOperationContext extends ParserRuleContext { + public TerminalNode INCR() { + return getToken(KotlinParser.INCR, 0); + } + + public TerminalNode DECR() { + return getToken(KotlinParser.DECR, 0); + } + + public List EXCL() { + return getTokens(KotlinParser.EXCL); + } + + public TerminalNode EXCL(int i) { + return getToken(KotlinParser.EXCL, i); + } + + public CallSuffixContext callSuffix() { + return getRuleContext(CallSuffixContext.class, 0); + } + + public ArrayAccessContext arrayAccess() { + return getRuleContext(ArrayAccessContext.class, 0); + } + + public MemberAccessOperatorContext memberAccessOperator() { + return getRuleContext(MemberAccessOperatorContext.class, 0); + } + + public PostfixUnaryExpressionContext postfixUnaryExpression() { + return getRuleContext(PostfixUnaryExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public PostfixUnaryOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_postfixUnaryOperation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPostfixUnaryOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPostfixUnaryOperation(this); + } + } + + public final PostfixUnaryOperationContext postfixUnaryOperation() throws RecognitionException { + PostfixUnaryOperationContext _localctx = new PostfixUnaryOperationContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_postfixUnaryOperation); + int _la; + try { + setState(2609); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 399, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2594); + match(INCR); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2595); + match(DECR); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2596); + match(EXCL); + setState(2597); + match(EXCL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2598); + callSuffix(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2599); + arrayAccess(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2603); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2600); + match(NL); + } + } + setState(2605); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2606); + memberAccessOperator(); + setState(2607); + postfixUnaryExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MemberAccessOperatorContext extends ParserRuleContext { + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public TerminalNode QUEST() { + return getToken(KotlinParser.QUEST, 0); + } + + public MemberAccessOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_memberAccessOperator; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMemberAccessOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMemberAccessOperator(this); + } + } + + public final MemberAccessOperatorContext memberAccessOperator() throws RecognitionException { + MemberAccessOperatorContext _localctx = new MemberAccessOperatorContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_memberAccessOperator); + try { + setState(2614); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + enterOuterAlt(_localctx, 1); + { + setState(2611); + match(DOT); + } + break; + case QUEST: + enterOuterAlt(_localctx, 2); + { + setState(2612); + match(QUEST); + setState(2613); + match(DOT); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ModifierListContext extends ParserRuleContext { + public List annotations() { + return getRuleContexts(AnnotationsContext.class); + } + + public AnnotationsContext annotations(int i) { + return getRuleContext(AnnotationsContext.class, i); + } + + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class, i); + } + + public ModifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_modifierList; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterModifierList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitModifierList(this); + } + } + + public final ModifierListContext modifierList() throws RecognitionException { + ModifierListContext _localctx = new ModifierListContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_modifierList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2618); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + setState(2618); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case LabelReference: { + setState(2616); + annotations(); + } + break; + case IN: + case OUT: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: { + setState(2617); + modifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(2620); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 402, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ModifierContext extends ParserRuleContext { + public ClassModifierContext classModifier() { + return getRuleContext(ClassModifierContext.class, 0); + } + + public MemberModifierContext memberModifier() { + return getRuleContext(MemberModifierContext.class, 0); + } + + public VisibilityModifierContext visibilityModifier() { + return getRuleContext(VisibilityModifierContext.class, 0); + } + + public VarianceAnnotationContext varianceAnnotation() { + return getRuleContext(VarianceAnnotationContext.class, 0); + } + + public FunctionModifierContext functionModifier() { + return getRuleContext(FunctionModifierContext.class, 0); + } + + public PropertyModifierContext propertyModifier() { + return getRuleContext(PropertyModifierContext.class, 0); + } + + public InheritanceModifierContext inheritanceModifier() { + return getRuleContext(InheritanceModifierContext.class, 0); + } + + public ParameterModifierContext parameterModifier() { + return getRuleContext(ParameterModifierContext.class, 0); + } + + public TypeParameterModifierContext typeParameterModifier() { + return getRuleContext(TypeParameterModifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_modifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitModifier(this); + } + } + + public final ModifierContext modifier() throws RecognitionException { + ModifierContext _localctx = new ModifierContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_modifier); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2631); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: { + setState(2622); + classModifier(); + } + break; + case OVERRIDE: + case LATEINIT: { + setState(2623); + memberModifier(); + } + break; + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: { + setState(2624); + visibilityModifier(); + } + break; + case IN: + case OUT: { + setState(2625); + varianceAnnotation(); + } + break; + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: { + setState(2626); + functionModifier(); + } + break; + case CONST: { + setState(2627); + propertyModifier(); + } + break; + case ABSTRACT: + case FINAL: + case OPEN: { + setState(2628); + inheritanceModifier(); + } + break; + case VARARG: + case NOINLINE: + case CROSSINLINE: { + setState(2629); + parameterModifier(); + } + break; + case REIFIED: { + setState(2630); + typeParameterModifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2636); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 404, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2633); + match(NL); + } + } + } + setState(2638); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 404, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClassModifierContext extends ParserRuleContext { + public TerminalNode ENUM() { + return getToken(KotlinParser.ENUM, 0); + } + + public TerminalNode SEALED() { + return getToken(KotlinParser.SEALED, 0); + } + + public TerminalNode ANNOTATION() { + return getToken(KotlinParser.ANNOTATION, 0); + } + + public TerminalNode DATA() { + return getToken(KotlinParser.DATA, 0); + } + + public TerminalNode INNER() { + return getToken(KotlinParser.INNER, 0); + } + + public ClassModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_classModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterClassModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitClassModifier(this); + } + } + + public final ClassModifierContext classModifier() throws RecognitionException { + ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_classModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2639); + _la = _input.LA(1); + if (!(((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & 31L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MemberModifierContext extends ParserRuleContext { + public TerminalNode OVERRIDE() { + return getToken(KotlinParser.OVERRIDE, 0); + } + + public TerminalNode LATEINIT() { + return getToken(KotlinParser.LATEINIT, 0); + } + + public MemberModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_memberModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterMemberModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitMemberModifier(this); + } + } + + public final MemberModifierContext memberModifier() throws RecognitionException { + MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_memberModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2641); + _la = _input.LA(1); + if (!(_la == OVERRIDE || _la == LATEINIT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VisibilityModifierContext extends ParserRuleContext { + public TerminalNode PUBLIC() { + return getToken(KotlinParser.PUBLIC, 0); + } + + public TerminalNode PRIVATE() { + return getToken(KotlinParser.PRIVATE, 0); + } + + public TerminalNode INTERNAL() { + return getToken(KotlinParser.INTERNAL, 0); + } + + public TerminalNode PROTECTED() { + return getToken(KotlinParser.PROTECTED, 0); + } + + public VisibilityModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_visibilityModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVisibilityModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVisibilityModifier(this); + } + } + + public final VisibilityModifierContext visibilityModifier() throws RecognitionException { + VisibilityModifierContext _localctx = new VisibilityModifierContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_visibilityModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2643); + _la = _input.LA(1); + if (!(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 15L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VarianceAnnotationContext extends ParserRuleContext { + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public TerminalNode OUT() { + return getToken(KotlinParser.OUT, 0); + } + + public VarianceAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_varianceAnnotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVarianceAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVarianceAnnotation(this); + } + } + + public final VarianceAnnotationContext varianceAnnotation() throws RecognitionException { + VarianceAnnotationContext _localctx = new VarianceAnnotationContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_varianceAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2645); + _la = _input.LA(1); + if (!(_la == IN || _la == OUT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionModifierContext extends ParserRuleContext { + public TerminalNode TAILREC() { + return getToken(KotlinParser.TAILREC, 0); + } + + public TerminalNode OPERATOR() { + return getToken(KotlinParser.OPERATOR, 0); + } + + public TerminalNode INFIX() { + return getToken(KotlinParser.INFIX, 0); + } + + public TerminalNode INLINE() { + return getToken(KotlinParser.INLINE, 0); + } + + public TerminalNode EXTERNAL() { + return getToken(KotlinParser.EXTERNAL, 0); + } + + public TerminalNode SUSPEND() { + return getToken(KotlinParser.SUSPEND, 0); + } + + public FunctionModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_functionModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterFunctionModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitFunctionModifier(this); + } + } + + public final FunctionModifierContext functionModifier() throws RecognitionException { + FunctionModifierContext _localctx = new FunctionModifierContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_functionModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2647); + _la = _input.LA(1); + if (!(((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 63L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PropertyModifierContext extends ParserRuleContext { + public TerminalNode CONST() { + return getToken(KotlinParser.CONST, 0); + } + + public PropertyModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_propertyModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterPropertyModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitPropertyModifier(this); + } + } + + public final PropertyModifierContext propertyModifier() throws RecognitionException { + PropertyModifierContext _localctx = new PropertyModifierContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_propertyModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(2649); + match(CONST); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InheritanceModifierContext extends ParserRuleContext { + public TerminalNode ABSTRACT() { + return getToken(KotlinParser.ABSTRACT, 0); + } + + public TerminalNode FINAL() { + return getToken(KotlinParser.FINAL, 0); + } + + public TerminalNode OPEN() { + return getToken(KotlinParser.OPEN, 0); + } + + public InheritanceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_inheritanceModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInheritanceModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitInheritanceModifier(this); + } + } + + public final InheritanceModifierContext inheritanceModifier() throws RecognitionException { + InheritanceModifierContext _localctx = new InheritanceModifierContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_inheritanceModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2651); + _la = _input.LA(1); + if (!(((((_la - 120)) & ~0x3f) == 0 && ((1L << (_la - 120)) & 7L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterModifierContext extends ParserRuleContext { + public TerminalNode VARARG() { + return getToken(KotlinParser.VARARG, 0); + } + + public TerminalNode NOINLINE() { + return getToken(KotlinParser.NOINLINE, 0); + } + + public TerminalNode CROSSINLINE() { + return getToken(KotlinParser.CROSSINLINE, 0); + } + + public ParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parameterModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParameterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitParameterModifier(this); + } + } + + public final ParameterModifierContext parameterModifier() throws RecognitionException { + ParameterModifierContext _localctx = new ParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_parameterModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2653); + _la = _input.LA(1); + if (!(((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & 7L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeParameterModifierContext extends ParserRuleContext { + public TerminalNode REIFIED() { + return getToken(KotlinParser.REIFIED, 0); + } + + public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameterModifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeParameterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeParameterModifier(this); + } + } + + public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { + TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_typeParameterModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(2655); + match(REIFIED); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LabelDefinitionContext extends ParserRuleContext { + public TerminalNode LabelDefinition() { + return getToken(KotlinParser.LabelDefinition, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public LabelDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_labelDefinition; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterLabelDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitLabelDefinition(this); + } + } + + public final LabelDefinitionContext labelDefinition() throws RecognitionException { + LabelDefinitionContext _localctx = new LabelDefinitionContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_labelDefinition); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2657); + match(LabelDefinition); + setState(2661); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 405, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2658); + match(NL); + } + } + } + setState(2663); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 405, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotationsContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public AnnotationListContext annotationList() { + return getRuleContext(AnnotationListContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public AnnotationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotations; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAnnotations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAnnotations(this); + } + } + + public final AnnotationsContext annotations() throws RecognitionException { + AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_annotations); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2666); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 406, _ctx)) { + case 1: { + setState(2664); + annotation(); + } + break; + case 2: { + setState(2665); + annotationList(); + } + break; + } + setState(2671); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 407, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2668); + match(NL); + } + } + } + setState(2673); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 407, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotationContext extends ParserRuleContext { + public AnnotationUseSiteTargetContext annotationUseSiteTarget() { + return getRuleContext(AnnotationUseSiteTargetContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public UnescapedAnnotationContext unescapedAnnotation() { + return getRuleContext(UnescapedAnnotationContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode LabelReference() { + return getToken(KotlinParser.LabelReference, 0); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public List simpleIdentifier() { + return getRuleContexts(SimpleIdentifierContext.class); + } + + public SimpleIdentifierContext simpleIdentifier(int i) { + return getRuleContext(SimpleIdentifierContext.class, i); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAnnotation(this); + } + } + + public final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_annotation); + int _la; + try { + int _alt; + setState(2728); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + enterOuterAlt(_localctx, 1); + { + setState(2674); + annotationUseSiteTarget(); + setState(2678); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2675); + match(NL); + } + } + setState(2680); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2681); + match(COLON); + setState(2685); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2682); + match(NL); + } + } + setState(2687); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2688); + unescapedAnnotation(); + } + break; + case LabelReference: + enterOuterAlt(_localctx, 2); + { + setState(2690); + match(LabelReference); + setState(2707); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 412, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2694); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2691); + match(NL); + } + } + setState(2696); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2697); + match(DOT); + setState(2701); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2698); + match(NL); + } + } + setState(2703); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2704); + simpleIdentifier(); + } + } + } + setState(2709); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 412, _ctx); + } + setState(2717); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 414, _ctx)) { + case 1: { + setState(2713); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2710); + match(NL); + } + } + setState(2715); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2716); + typeArguments(); + } + break; + } + setState(2726); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 416, _ctx)) { + case 1: { + setState(2722); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2719); + match(NL); + } + } + setState(2724); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2725); + valueArguments(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotationListContext extends ParserRuleContext { + public AnnotationUseSiteTargetContext annotationUseSiteTarget() { + return getRuleContext(AnnotationUseSiteTargetContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List unescapedAnnotation() { + return getRuleContexts(UnescapedAnnotationContext.class); + } + + public UnescapedAnnotationContext unescapedAnnotation(int i) { + return getRuleContext(UnescapedAnnotationContext.class, i); + } + + public TerminalNode AT() { + return getToken(KotlinParser.AT, 0); + } + + public AnnotationListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotationList; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAnnotationList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAnnotationList(this); + } + } + + public final AnnotationListContext annotationList() throws RecognitionException { + AnnotationListContext _localctx = new AnnotationListContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_annotationList); + int _la; + try { + setState(2749); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + enterOuterAlt(_localctx, 1); + { + setState(2730); + annotationUseSiteTarget(); + setState(2731); + match(COLON); + setState(2732); + match(LSQUARE); + setState(2734); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2733); + unescapedAnnotation(); + } + } + setState(2736); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0)); + setState(2738); + match(RSQUARE); + } + break; + case AT: + enterOuterAlt(_localctx, 2); + { + setState(2740); + match(AT); + setState(2741); + match(LSQUARE); + setState(2743); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2742); + unescapedAnnotation(); + } + } + setState(2745); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0)); + setState(2747); + match(RSQUARE); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotationUseSiteTargetContext extends ParserRuleContext { + public TerminalNode FIELD() { + return getToken(KotlinParser.FIELD, 0); + } + + public TerminalNode FILE() { + return getToken(KotlinParser.FILE, 0); + } + + public TerminalNode PROPERTY() { + return getToken(KotlinParser.PROPERTY, 0); + } + + public TerminalNode GET() { + return getToken(KotlinParser.GET, 0); + } + + public TerminalNode SET() { + return getToken(KotlinParser.SET, 0); + } + + public TerminalNode RECEIVER() { + return getToken(KotlinParser.RECEIVER, 0); + } + + public TerminalNode PARAM() { + return getToken(KotlinParser.PARAM, 0); + } + + public TerminalNode SETPARAM() { + return getToken(KotlinParser.SETPARAM, 0); + } + + public TerminalNode DELEGATE() { + return getToken(KotlinParser.DELEGATE, 0); + } + + public AnnotationUseSiteTargetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotationUseSiteTarget; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnnotationUseSiteTarget(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnnotationUseSiteTarget(this); + } + } + + public final AnnotationUseSiteTargetContext annotationUseSiteTarget() throws RecognitionException { + AnnotationUseSiteTargetContext _localctx = new AnnotationUseSiteTargetContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_annotationUseSiteTarget); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2751); + _la = _input.LA(1); + if (!(((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & 134002979635201L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnescapedAnnotationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public UnescapedAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_unescapedAnnotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterUnescapedAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitUnescapedAnnotation(this); + } + } + + public final UnescapedAnnotationContext unescapedAnnotation() throws RecognitionException { + UnescapedAnnotationContext _localctx = new UnescapedAnnotationContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_unescapedAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2753); + identifier(); + setState(2755); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LANGLE) { + { + setState(2754); + typeArguments(); + } + } + + setState(2758); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 422, _ctx)) { + case 1: { + setState(2757); + valueArguments(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierContext extends ParserRuleContext { + public List simpleIdentifier() { + return getRuleContexts(SimpleIdentifierContext.class); + } + + public SimpleIdentifierContext simpleIdentifier(int i) { + return getRuleContext(SimpleIdentifierContext.class, i); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_identifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterIdentifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitIdentifier(this); + } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_identifier); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2760); + simpleIdentifier(); + setState(2771); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 424, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2764); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2761); + match(NL); + } + } + setState(2766); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2767); + match(DOT); + setState(2768); + simpleIdentifier(); + } + } + } + setState(2773); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 424, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleIdentifierContext extends ParserRuleContext { + public TerminalNode Identifier() { + return getToken(KotlinParser.Identifier, 0); + } + + public TerminalNode ABSTRACT() { + return getToken(KotlinParser.ABSTRACT, 0); + } + + public TerminalNode ANNOTATION() { + return getToken(KotlinParser.ANNOTATION, 0); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public TerminalNode CATCH() { + return getToken(KotlinParser.CATCH, 0); + } + + public TerminalNode COMPANION() { + return getToken(KotlinParser.COMPANION, 0); + } + + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public TerminalNode CROSSINLINE() { + return getToken(KotlinParser.CROSSINLINE, 0); + } + + public TerminalNode DATA() { + return getToken(KotlinParser.DATA, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(KotlinParser.DYNAMIC, 0); + } + + public TerminalNode ENUM() { + return getToken(KotlinParser.ENUM, 0); + } + + public TerminalNode EXTERNAL() { + return getToken(KotlinParser.EXTERNAL, 0); + } + + public TerminalNode FINAL() { + return getToken(KotlinParser.FINAL, 0); + } + + public TerminalNode FINALLY() { + return getToken(KotlinParser.FINALLY, 0); + } + + public TerminalNode GETTER() { + return getToken(KotlinParser.GETTER, 0); + } + + public TerminalNode IMPORT() { + return getToken(KotlinParser.IMPORT, 0); + } + + public TerminalNode INFIX() { + return getToken(KotlinParser.INFIX, 0); + } + + public TerminalNode INIT() { + return getToken(KotlinParser.INIT, 0); + } + + public TerminalNode INLINE() { + return getToken(KotlinParser.INLINE, 0); + } + + public TerminalNode INNER() { + return getToken(KotlinParser.INNER, 0); + } + + public TerminalNode INTERNAL() { + return getToken(KotlinParser.INTERNAL, 0); + } + + public TerminalNode LATEINIT() { + return getToken(KotlinParser.LATEINIT, 0); + } + + public TerminalNode NOINLINE() { + return getToken(KotlinParser.NOINLINE, 0); + } + + public TerminalNode OPEN() { + return getToken(KotlinParser.OPEN, 0); + } + + public TerminalNode OPERATOR() { + return getToken(KotlinParser.OPERATOR, 0); + } + + public TerminalNode OUT() { + return getToken(KotlinParser.OUT, 0); + } + + public TerminalNode OVERRIDE() { + return getToken(KotlinParser.OVERRIDE, 0); + } + + public TerminalNode PRIVATE() { + return getToken(KotlinParser.PRIVATE, 0); + } + + public TerminalNode PROTECTED() { + return getToken(KotlinParser.PROTECTED, 0); + } + + public TerminalNode PUBLIC() { + return getToken(KotlinParser.PUBLIC, 0); + } + + public TerminalNode REIFIED() { + return getToken(KotlinParser.REIFIED, 0); + } + + public TerminalNode SEALED() { + return getToken(KotlinParser.SEALED, 0); + } + + public TerminalNode TAILREC() { + return getToken(KotlinParser.TAILREC, 0); + } + + public TerminalNode SETTER() { + return getToken(KotlinParser.SETTER, 0); + } + + public TerminalNode VARARG() { + return getToken(KotlinParser.VARARG, 0); + } + + public TerminalNode WHERE() { + return getToken(KotlinParser.WHERE, 0); + } + + public TerminalNode CONST() { + return getToken(KotlinParser.CONST, 0); + } + + public TerminalNode SUSPEND() { + return getToken(KotlinParser.SUSPEND, 0); + } + + public SimpleIdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simpleIdentifier; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterSimpleIdentifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitSimpleIdentifier(this); + } + } + + public final SimpleIdentifierContext simpleIdentifier() throws RecognitionException { + SimpleIdentifierContext _localctx = new SimpleIdentifierContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_simpleIdentifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2774); + _la = _input.LA(1); + if (!(((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & -33517921595647L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 262271L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SemiContext extends ParserRuleContext { + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public SemiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_semi; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterSemi(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitSemi(this); + } + } + + public final SemiContext semi() throws RecognitionException { + SemiContext _localctx = new SemiContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_semi); + int _la; + try { + int _alt; + setState(2794); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 428, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2777); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(2776); + match(NL); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(2779); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 425, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2784); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2781); + match(NL); + } + } + setState(2786); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2787); + match(SEMICOLON); + setState(2791); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 427, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2788); + match(NL); + } + } + } + setState(2793); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 427, _ctx); + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnysemiContext extends ParserRuleContext { + public TerminalNode NL() { + return getToken(KotlinParser.NL, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public AnysemiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_anysemi; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).enterAnysemi(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) ((KotlinParserListener) listener).exitAnysemi(this); + } + } + + public final AnysemiContext anysemi() throws RecognitionException { + AnysemiContext _localctx = new AnysemiContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_anysemi); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2796); + _la = _input.LA(1); + if (!(_la == NL || _la == SEMICOLON)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + private static final String _serializedATNSegment0 = + "\u0004\u0001\u00aa\u0aef\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001" + + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004" + + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007" + + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b" + + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007" + + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007" + + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007" + + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007" + + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007" + + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007" + + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007" + + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007" + + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007" + + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007" + + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007" + + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007" + + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007" + + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007" + + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007" + + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007" + + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007" + + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007" + + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007" + + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007" + + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007" + + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007" + + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007" + + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007" + + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007" + + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007" + + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007" + + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007" + + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007" + + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007" + + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007" + + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007" + + "\u0092\u0001\u0000\u0005\u0000\u0128\b\u0000\n\u0000\f\u0000\u012b\t\u0000" + + "\u0001\u0000\u0001\u0000\u0005\u0000\u012f\b\u0000\n\u0000\f\u0000\u0132" + + "\t\u0000\u0001\u0000\u0001\u0000\u0004\u0000\u0136\b\u0000\u000b\u0000" + + "\f\u0000\u0137\u0001\u0000\u0003\u0000\u013b\b\u0000\u0005\u0000\u013d" + + "\b\u0000\n\u0000\f\u0000\u0140\t\u0000\u0003\u0000\u0142\b\u0000\u0001" + + "\u0000\u0001\u0000\u0001\u0001\u0005\u0001\u0147\b\u0001\n\u0001\f\u0001" + + "\u014a\t\u0001\u0001\u0001\u0001\u0001\u0005\u0001\u014e\b\u0001\n\u0001" + + "\f\u0001\u0151\t\u0001\u0001\u0001\u0001\u0001\u0004\u0001\u0155\b\u0001" + + "\u000b\u0001\f\u0001\u0156\u0001\u0001\u0003\u0001\u015a\b\u0001\u0005" + + "\u0001\u015c\b\u0001\n\u0001\f\u0001\u015f\t\u0001\u0003\u0001\u0161\b" + + "\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0003\u0002\u0166\b\u0002\u0001" + + "\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0004\u0003\u016c\b\u0003\u000b" + + "\u0003\f\u0003\u016d\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0004" + + "\u0004\u0174\b\u0004\u000b\u0004\f\u0004\u0175\u0001\u0004\u0001\u0004" + + "\u0001\u0004\u0003\u0004\u017b\b\u0004\u0001\u0004\u0003\u0004\u017e\b" + + "\u0004\u0004\u0004\u0180\b\u0004\u000b\u0004\f\u0004\u0181\u0001\u0005" + + "\u0003\u0005\u0185\b\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005" + + "\u018a\b\u0005\u0003\u0005\u018c\b\u0005\u0001\u0006\u0005\u0006\u018f" + + "\b\u0006\n\u0006\f\u0006\u0192\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007" + + "\u0001\u0007\u0001\u0007\u0003\u0007\u0199\b\u0007\u0001\u0007\u0003\u0007" + + "\u019c\b\u0007\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t" + + "\u0001\t\u0003\t\u01a6\b\t\u0001\n\u0003\n\u01a9\b\n\u0001\n\u0001\n\u0005" + + "\n\u01ad\b\n\n\n\f\n\u01b0\t\n\u0001\n\u0001\n\u0005\n\u01b4\b\n\n\n\f" + + "\n\u01b7\t\n\u0001\n\u0003\n\u01ba\b\n\u0001\n\u0005\n\u01bd\b\n\n\n\f" + + "\n\u01c0\t\n\u0001\n\u0003\n\u01c3\b\n\u0001\n\u0005\n\u01c6\b\n\n\n\f" + + "\n\u01c9\t\n\u0001\n\u0001\n\u0005\n\u01cd\b\n\n\n\f\n\u01d0\t\n\u0001" + + "\n\u0003\n\u01d3\b\n\u0001\n\u0005\n\u01d6\b\n\n\n\f\n\u01d9\t\n\u0001" + + "\n\u0003\n\u01dc\b\n\u0001\n\u0005\n\u01df\b\n\n\n\f\n\u01e2\t\n\u0001" + + "\n\u0001\n\u0005\n\u01e6\b\n\n\n\f\n\u01e9\t\n\u0001\n\u0003\n\u01ec\b" + + "\n\u0001\u000b\u0003\u000b\u01ef\b\u000b\u0001\u000b\u0001\u000b\u0005" + + "\u000b\u01f3\b\u000b\n\u000b\f\u000b\u01f6\t\u000b\u0003\u000b\u01f8\b" + + "\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0005\f" + + "\u0200\b\f\n\f\f\f\u0203\t\f\u0001\f\u0003\f\u0206\b\f\u0003\f\u0208\b" + + "\f\u0001\f\u0001\f\u0001\r\u0003\r\u020d\b\r\u0001\r\u0003\r\u0210\b\r" + + "\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0217\b\r\u0001\u000e" + + "\u0005\u000e\u021a\b\u000e\n\u000e\f\u000e\u021d\t\u000e\u0001\u000e\u0001" + + "\u000e\u0005\u000e\u0221\b\u000e\n\u000e\f\u000e\u0224\t\u000e\u0001\u000e" + + "\u0001\u000e\u0005\u000e\u0228\b\u000e\n\u000e\f\u000e\u022b\t\u000e\u0001" + + "\u000e\u0005\u000e\u022e\b\u000e\n\u000e\f\u000e\u0231\t\u000e\u0001\u000e" + + "\u0005\u000e\u0234\b\u000e\n\u000e\f\u000e\u0237\t\u000e\u0001\u000f\u0001" + + "\u000f\u0001\u000f\u0003\u000f\u023c\b\u000f\u0001\u0010\u0001\u0010\u0001" + + "\u0010\u0001\u0011\u0001\u0011\u0005\u0011\u0243\b\u0011\n\u0011\f\u0011" + + "\u0246\t\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u024a\b\u0011\n\u0011" + + "\f\u0011\u024d\t\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012" + + "\u0005\u0012\u0253\b\u0012\n\u0012\f\u0012\u0256\t\u0012\u0001\u0012\u0005" + + "\u0012\u0259\b\u0012\n\u0012\f\u0012\u025c\t\u0012\u0001\u0012\u0005\u0012" + + "\u025f\b\u0012\n\u0012\f\u0012\u0262\t\u0012\u0001\u0012\u0001\u0012\u0001" + + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0001\u0013\u0003\u0013\u026e\b\u0013\u0001\u0013\u0004\u0013\u0271" + + "\b\u0013\u000b\u0013\f\u0013\u0272\u0001\u0014\u0001\u0014\u0005\u0014" + + "\u0277\b\u0014\n\u0014\f\u0014\u027a\t\u0014\u0001\u0014\u0001\u0014\u0001" + + "\u0015\u0003\u0015\u027f\b\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u0283" + + "\b\u0015\n\u0015\f\u0015\u0286\t\u0015\u0001\u0015\u0001\u0015\u0005\u0015" + + "\u028a\b\u0015\n\u0015\f\u0015\u028d\t\u0015\u0001\u0015\u0001\u0015\u0005" + + "\u0015\u0291\b\u0015\n\u0015\f\u0015\u0294\t\u0015\u0001\u0015\u0003\u0015" + + "\u0297\b\u0015\u0001\u0015\u0005\u0015\u029a\b\u0015\n\u0015\f\u0015\u029d" + + "\t\u0015\u0001\u0015\u0003\u0015\u02a0\b\u0015\u0001\u0016\u0001\u0016" + + "\u0005\u0016\u02a4\b\u0016\n\u0016\f\u0016\u02a7\t\u0016\u0001\u0016\u0001" + + "\u0016\u0001\u0016\u0005\u0016\u02ac\b\u0016\n\u0016\f\u0016\u02af\t\u0016" + + "\u0001\u0016\u0003\u0016\u02b2\b\u0016\u0001\u0017\u0001\u0017\u0005\u0017" + + "\u02b6\b\u0017\n\u0017\f\u0017\u02b9\t\u0017\u0001\u0017\u0003\u0017\u02bc" + + "\b\u0017\u0001\u0017\u0005\u0017\u02bf\b\u0017\n\u0017\f\u0017\u02c2\t" + + "\u0017\u0001\u0017\u0001\u0017\u0005\u0017\u02c6\b\u0017\n\u0017\f\u0017" + + "\u02c9\t\u0017\u0001\u0017\u0005\u0017\u02cc\b\u0017\n\u0017\f\u0017\u02cf" + + "\t\u0017\u0003\u0017\u02d1\b\u0017\u0001\u0017\u0005\u0017\u02d4\b\u0017" + + "\n\u0017\f\u0017\u02d7\t\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001" + + "\u0018\u0005\u0018\u02dd\b\u0018\n\u0018\f\u0018\u02e0\t\u0018\u0004\u0018" + + "\u02e2\b\u0018\u000b\u0018\f\u0018\u02e3\u0001\u0018\u0003\u0018\u02e7" + + "\b\u0018\u0001\u0019\u0005\u0019\u02ea\b\u0019\n\u0019\f\u0019\u02ed\t" + + "\u0019\u0001\u0019\u0001\u0019\u0005\u0019\u02f1\b\u0019\n\u0019\f\u0019" + + "\u02f4\t\u0019\u0001\u0019\u0003\u0019\u02f7\b\u0019\u0001\u0019\u0005" + + "\u0019\u02fa\b\u0019\n\u0019\f\u0019\u02fd\t\u0019\u0001\u0019\u0003\u0019" + + "\u0300\b\u0019\u0001\u0019\u0005\u0019\u0303\b\u0019\n\u0019\f\u0019\u0306" + + "\t\u0019\u0001\u0019\u0003\u0019\u0309\b\u0019\u0001\u001a\u0003\u001a" + + "\u030c\b\u001a\u0001\u001a\u0001\u001a\u0005\u001a\u0310\b\u001a\n\u001a" + + "\f\u001a\u0313\t\u001a\u0001\u001a\u0001\u001a\u0005\u001a\u0317\b\u001a" + + "\n\u001a\f\u001a\u031a\t\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u031e" + + "\b\u001a\u0001\u001a\u0005\u001a\u0321\b\u001a\n\u001a\f\u001a\u0324\t" + + "\u001a\u0001\u001a\u0003\u001a\u0327\b\u001a\u0001\u001a\u0005\u001a\u032a" + + "\b\u001a\n\u001a\f\u001a\u032d\t\u001a\u0001\u001a\u0001\u001a\u0005\u001a" + + "\u0331\b\u001a\n\u001a\f\u001a\u0334\t\u001a\u0001\u001a\u0001\u001a\u0003" + + "\u001a\u0338\b\u001a\u0001\u001a\u0005\u001a\u033b\b\u001a\n\u001a\f\u001a" + + "\u033e\t\u001a\u0001\u001a\u0003\u001a\u0341\b\u001a\u0001\u001a\u0005" + + "\u001a\u0344\b\u001a\n\u001a\f\u001a\u0347\t\u001a\u0001\u001a\u0001\u001a" + + "\u0005\u001a\u034b\b\u001a\n\u001a\f\u001a\u034e\t\u001a\u0001\u001a\u0001" + + "\u001a\u0005\u001a\u0352\b\u001a\n\u001a\f\u001a\u0355\t\u001a\u0001\u001a" + + "\u0003\u001a\u0358\b\u001a\u0001\u001a\u0005\u001a\u035b\b\u001a\n\u001a" + + "\f\u001a\u035e\t\u001a\u0001\u001a\u0003\u001a\u0361\b\u001a\u0001\u001a" + + "\u0005\u001a\u0364\b\u001a\n\u001a\f\u001a\u0367\t\u001a\u0001\u001a\u0003" + + "\u001a\u036a\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0005" + + "\u001b\u0370\b\u001b\n\u001b\f\u001b\u0373\t\u001b\u0001\u001b\u0003\u001b" + + "\u0376\b\u001b\u0003\u001b\u0378\b\u001b\u0001\u001b\u0001\u001b\u0001" + + "\u001c\u0003\u001c\u037d\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003" + + "\u001c\u0382\b\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001" + + "\u001e\u0003\u001e\u0389\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003" + + "\u001e\u038e\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u0393" + + "\b\u001f\n\u001f\f\u001f\u0396\t\u001f\u0001\u001f\u0003\u001f\u0399\b" + + "\u001f\u0001 \u0003 \u039c\b \u0001 \u0001 \u0005 \u03a0\b \n \f \u03a3" + + "\t \u0001 \u0001 \u0005 \u03a7\b \n \f \u03aa\t \u0001 \u0003 \u03ad\b" + + " \u0001 \u0005 \u03b0\b \n \f \u03b3\t \u0001 \u0001 \u0005 \u03b7\b " + + "\n \f \u03ba\t \u0001 \u0003 \u03bd\b \u0001 \u0005 \u03c0\b \n \f \u03c3" + + "\t \u0001 \u0003 \u03c6\b \u0001!\u0003!\u03c9\b!\u0001!\u0001!\u0005" + + "!\u03cd\b!\n!\f!\u03d0\t!\u0001!\u0003!\u03d3\b!\u0001!\u0001!\u0005!" + + "\u03d7\b!\n!\f!\u03da\t!\u0001!\u0003!\u03dd\b!\u0001!\u0005!\u03e0\b" + + "!\n!\f!\u03e3\t!\u0001!\u0001!\u0005!\u03e7\b!\n!\f!\u03ea\t!\u0001!\u0003" + + "!\u03ed\b!\u0001!\u0005!\u03f0\b!\n!\f!\u03f3\t!\u0001!\u0003!\u03f6\b" + + "!\u0001\"\u0003\"\u03f9\b\"\u0001\"\u0001\"\u0005\"\u03fd\b\"\n\"\f\"" + + "\u0400\t\"\u0001\"\u0003\"\u0403\b\"\u0001\"\u0005\"\u0406\b\"\n\"\f\"" + + "\u0409\t\"\u0001\"\u0001\"\u0005\"\u040d\b\"\n\"\f\"\u0410\t\"\u0001\"" + + "\u0001\"\u0003\"\u0414\b\"\u0001\"\u0005\"\u0417\b\"\n\"\f\"\u041a\t\"" + + "\u0001\"\u0001\"\u0003\"\u041e\b\"\u0001\"\u0005\"\u0421\b\"\n\"\f\"\u0424" + + "\t\"\u0001\"\u0003\"\u0427\b\"\u0001\"\u0005\"\u042a\b\"\n\"\f\"\u042d" + + "\t\"\u0001\"\u0001\"\u0005\"\u0431\b\"\n\"\f\"\u0434\t\"\u0001\"\u0003" + + "\"\u0437\b\"\u0001\"\u0005\"\u043a\b\"\n\"\f\"\u043d\t\"\u0001\"\u0001" + + "\"\u0001\"\u0001\"\u0003\"\u0443\b\"\u0001\"\u0005\"\u0446\b\"\n\"\f\"" + + "\u0449\t\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u044f\b\"\u0003\"\u0451" + + "\b\"\u0001#\u0001#\u0001#\u0001#\u0005#\u0457\b#\n#\f#\u045a\t#\u0001" + + "#\u0001#\u0001$\u0001$\u0001$\u0003$\u0461\b$\u0001%\u0003%\u0464\b%\u0001" + + "%\u0001%\u0003%\u0468\b%\u0001%\u0001%\u0005%\u046c\b%\n%\f%\u046f\t%" + + "\u0001%\u0001%\u0001%\u0005%\u0474\b%\n%\f%\u0477\t%\u0001%\u0001%\u0005" + + "%\u047b\b%\n%\f%\u047e\t%\u0001%\u0003%\u0481\b%\u0001%\u0005%\u0484\b" + + "%\n%\f%\u0487\t%\u0001%\u0001%\u0001%\u0005%\u048c\b%\n%\f%\u048f\t%\u0001" + + "%\u0003%\u0492\b%\u0003%\u0494\b%\u0001&\u0003&\u0497\b&\u0001&\u0001" + + "&\u0003&\u049b\b&\u0001&\u0001&\u0005&\u049f\b&\n&\f&\u04a2\t&\u0001&" + + "\u0001&\u0001&\u0005&\u04a7\b&\n&\f&\u04aa\t&\u0001&\u0001&\u0003&\u04ae" + + "\b&\u0001&\u0001&\u0005&\u04b2\b&\n&\f&\u04b5\t&\u0001&\u0001&\u0003&" + + "\u04b9\b&\u0001\'\u0003\'\u04bc\b\'\u0001\'\u0001\'\u0005\'\u04c0\b\'" + + "\n\'\f\'\u04c3\t\'\u0001\'\u0001\'\u0005\'\u04c7\b\'\n\'\f\'\u04ca\t\'" + + "\u0001\'\u0003\'\u04cd\b\'\u0001\'\u0005\'\u04d0\b\'\n\'\f\'\u04d3\t\'" + + "\u0001\'\u0001\'\u0005\'\u04d7\b\'\n\'\f\'\u04da\t\'\u0001\'\u0001\'\u0001" + + "(\u0001(\u0005(\u04e0\b(\n(\f(\u04e3\t(\u0001(\u0001(\u0005(\u04e7\b(" + + "\n(\f(\u04ea\t(\u0001(\u0001(\u0005(\u04ee\b(\n(\f(\u04f1\t(\u0001(\u0005" + + "(\u04f4\b(\n(\f(\u04f7\t(\u0001(\u0005(\u04fa\b(\n(\f(\u04fd\t(\u0001" + + "(\u0003(\u0500\b(\u0001(\u0005(\u0503\b(\n(\f(\u0506\t(\u0001(\u0001(" + + "\u0001)\u0003)\u050b\b)\u0001)\u0005)\u050e\b)\n)\f)\u0511\t)\u0001)\u0001" + + ")\u0003)\u0515\b)\u0001)\u0005)\u0518\b)\n)\f)\u051b\t)\u0001)\u0001)" + + "\u0005)\u051f\b)\n)\f)\u0522\t)\u0001)\u0003)\u0525\b)\u0001*\u0003*\u0528" + + "\b*\u0001*\u0001*\u0001*\u0001*\u0003*\u052e\b*\u0001+\u0001+\u0001+\u0005" + + "+\u0533\b+\n+\f+\u0536\t+\u0004+\u0538\b+\u000b+\f+\u0539\u0001,\u0001" + + ",\u0001,\u0001,\u0001-\u0001-\u0003-\u0542\b-\u0001-\u0005-\u0545\b-\n" + + "-\f-\u0548\t-\u0001-\u0004-\u054b\b-\u000b-\f-\u054c\u0001.\u0001.\u0001" + + ".\u0001.\u0001.\u0001.\u0003.\u0555\b.\u0001/\u0001/\u0005/\u0559\b/\n" + + "/\f/\u055c\t/\u0001/\u0001/\u0005/\u0560\b/\n/\f/\u0563\t/\u0003/\u0565" + + "\b/\u0001/\u0001/\u0005/\u0569\b/\n/\f/\u056c\t/\u0001/\u0001/\u0005/" + + "\u0570\b/\n/\f/\u0573\t/\u0001/\u0001/\u00010\u00010\u00010\u00030\u057a" + + "\b0\u00011\u00011\u00051\u057e\b1\n1\f1\u0581\t1\u00011\u00011\u00051" + + "\u0585\b1\n1\f1\u0588\t1\u00011\u00051\u058b\b1\n1\f1\u058e\t1\u00012" + + "\u00012\u00052\u0592\b2\n2\f2\u0595\t2\u00012\u00032\u0598\b2\u00013\u0001" + + "3\u00053\u059c\b3\n3\f3\u059f\t3\u00013\u00013\u00033\u05a3\b3\u00013" + + "\u00053\u05a6\b3\n3\f3\u05a9\t3\u00013\u00013\u00053\u05ad\b3\n3\f3\u05b0" + + "\t3\u00013\u00013\u00033\u05b4\b3\u00053\u05b6\b3\n3\f3\u05b9\t3\u0001" + + "3\u00053\u05bc\b3\n3\f3\u05bf\t3\u00013\u00033\u05c2\b3\u00013\u00053" + + "\u05c5\b3\n3\f3\u05c8\t3\u00013\u00013\u00014\u00014\u00054\u05ce\b4\n" + + "4\f4\u05d1\t4\u00014\u00014\u00054\u05d5\b4\n4\f4\u05d8\t4\u00014\u0001" + + "4\u00054\u05dc\b4\n4\f4\u05df\t4\u00014\u00054\u05e2\b4\n4\f4\u05e5\t" + + "4\u00015\u00055\u05e8\b5\n5\f5\u05eb\t5\u00015\u00015\u00055\u05ef\b5" + + "\n5\f5\u05f2\t5\u00015\u00015\u00055\u05f6\b5\n5\f5\u05f9\t5\u00015\u0001" + + "5\u00016\u00016\u00016\u00016\u00017\u00057\u0602\b7\n7\f7\u0605\t7\u0001" + + "7\u00017\u00047\u0609\b7\u000b7\f7\u060a\u00017\u00037\u060e\b7\u0005" + + "7\u0610\b7\n7\f7\u0613\t7\u00037\u0615\b7\u00018\u00018\u00038\u0619\b" + + "8\u00019\u00059\u061c\b9\n9\f9\u061f\t9\u00019\u00059\u0622\b9\n9\f9\u0625" + + "\t9\u00019\u00019\u0001:\u0005:\u062a\b:\n:\f:\u062d\t:\u0001:\u0001:" + + "\u0001:\u0001:\u0003:\u0633\b:\u0001;\u0001;\u0001;\u0001;\u0005;\u0639" + + "\b;\n;\f;\u063c\t;\u0001<\u0001<\u0005<\u0640\b<\n<\f<\u0643\t<\u0001" + + "<\u0001<\u0005<\u0647\b<\n<\f<\u064a\t<\u0001<\u0005<\u064d\b<\n<\f<\u0650" + + "\t<\u0001=\u0001=\u0005=\u0654\b=\n=\f=\u0657\t=\u0001=\u0001=\u0005=" + + "\u065b\b=\n=\f=\u065e\t=\u0001=\u0005=\u0661\b=\n=\f=\u0664\t=\u0001>" + + "\u0001>\u0001>\u0005>\u0669\b>\n>\f>\u066c\t>\u0001>\u0001>\u0005>\u0670" + + "\b>\n>\f>\u0673\t>\u0001?\u0001?\u0001?\u0005?\u0678\b?\n?\f?\u067b\t" + + "?\u0001?\u0001?\u0003?\u067f\b?\u0001@\u0001@\u0001@\u0005@\u0684\b@\n" + + "@\f@\u0687\t@\u0001@\u0001@\u0004@\u068b\b@\u000b@\f@\u068c\u0001@\u0001" + + "@\u0005@\u0691\b@\n@\f@\u0694\t@\u0001@\u0001@\u0003@\u0698\b@\u0001A" + + "\u0001A\u0005A\u069c\bA\nA\fA\u069f\tA\u0001A\u0001A\u0005A\u06a3\bA\n" + + "A\fA\u06a6\tA\u0001A\u0005A\u06a9\bA\nA\fA\u06ac\tA\u0001B\u0001B\u0001" + + "B\u0005B\u06b1\bB\nB\fB\u06b4\tB\u0001B\u0001B\u0005B\u06b8\bB\nB\fB\u06bb" + + "\tB\u0001C\u0001C\u0001C\u0005C\u06c0\bC\nC\fC\u06c3\tC\u0001C\u0005C" + + "\u06c6\bC\nC\fC\u06c9\tC\u0001D\u0001D\u0001D\u0005D\u06ce\bD\nD\fD\u06d1" + + "\tD\u0001D\u0001D\u0005D\u06d5\bD\nD\fD\u06d8\tD\u0001E\u0001E\u0001E" + + "\u0005E\u06dd\bE\nE\fE\u06e0\tE\u0001E\u0001E\u0005E\u06e4\bE\nE\fE\u06e7" + + "\tE\u0001F\u0001F\u0005F\u06eb\bF\nF\fF\u06ee\tF\u0001F\u0001F\u0001F" + + "\u0005F\u06f3\bF\nF\fF\u06f6\tF\u0001G\u0005G\u06f9\bG\nG\fG\u06fc\tG" + + "\u0001G\u0001G\u0001H\u0001H\u0003H\u0702\bH\u0001H\u0005H\u0705\bH\n" + + "H\fH\u0708\tH\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I" + + "\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0003I\u0718\bI\u0001J\u0001" + + "J\u0001J\u0001J\u0001K\u0001K\u0003K\u0720\bK\u0001K\u0005K\u0723\bK\n" + + "K\fK\u0726\tK\u0001K\u0001K\u0005K\u072a\bK\nK\fK\u072d\tK\u0001K\u0004" + + "K\u0730\bK\u000bK\fK\u0731\u0003K\u0734\bK\u0001L\u0005L\u0737\bL\nL\f" + + "L\u073a\tL\u0001L\u0003L\u073d\bL\u0001L\u0005L\u0740\bL\nL\fL\u0743\t" + + "L\u0001L\u0001L\u0001M\u0001M\u0001M\u0001M\u0005M\u074b\bM\nM\fM\u074e" + + "\tM\u0003M\u0750\bM\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0005N\u0758" + + "\bN\nN\fN\u075b\tN\u0001N\u0005N\u075e\bN\nN\fN\u0761\tN\u0001N\u0003" + + "N\u0764\bN\u0003N\u0766\bN\u0001N\u0001N\u0001O\u0001O\u0005O\u076c\b" + + "O\nO\fO\u076f\tO\u0001O\u0001O\u0005O\u0773\bO\nO\fO\u0776\tO\u0001O\u0001" + + "O\u0005O\u077a\bO\nO\fO\u077d\tO\u0001O\u0005O\u0780\bO\nO\fO\u0783\t" + + "O\u0001O\u0003O\u0786\bO\u0001O\u0005O\u0789\bO\nO\fO\u078c\tO\u0001O" + + "\u0001O\u0003O\u0790\bO\u0001P\u0003P\u0793\bP\u0001P\u0001P\u0003P\u0797" + + "\bP\u0001Q\u0004Q\u079a\bQ\u000bQ\fQ\u079b\u0001R\u0001R\u0005R\u07a0" + + "\bR\nR\fR\u07a3\tR\u0001R\u0001R\u0005R\u07a7\bR\nR\fR\u07aa\tR\u0003" + + "R\u07ac\bR\u0001R\u0003R\u07af\bR\u0001R\u0005R\u07b2\bR\nR\fR\u07b5\t" + + "R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001" + + "S\u0001S\u0003S\u07c2\bS\u0001T\u0001T\u0003T\u07c6\bT\u0001U\u0001U\u0001" + + "U\u0005U\u07cb\bU\nU\fU\u07ce\tU\u0001U\u0001U\u0001V\u0001V\u0001V\u0001" + + "V\u0001V\u0005V\u07d7\bV\nV\fV\u07da\tV\u0001V\u0001V\u0001W\u0001W\u0001" + + "X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001" + + "[\u0005[\u07eb\b[\n[\f[\u07ee\t[\u0001[\u0001[\u0005[\u07f2\b[\n[\f[\u07f5" + + "\t[\u0001[\u0001[\u0005[\u07f9\b[\n[\f[\u07fc\t[\u0001[\u0001[\u0001[" + + "\u0001[\u0005[\u0802\b[\n[\f[\u0805\t[\u0001[\u0001[\u0005[\u0809\b[\n" + + "[\f[\u080c\t[\u0001[\u0001[\u0005[\u0810\b[\n[\f[\u0813\t[\u0001[\u0001" + + "[\u0005[\u0817\b[\n[\f[\u081a\t[\u0001[\u0001[\u0003[\u081e\b[\u0001\\" + + "\u0003\\\u0821\b\\\u0001\\\u0005\\\u0824\b\\\n\\\f\\\u0827\t\\\u0001\\" + + "\u0001\\\u0005\\\u082b\b\\\n\\\f\\\u082e\t\\\u0001\\\u0005\\\u0831\b\\" + + "\n\\\f\\\u0834\t\\\u0001]\u0001]\u0001]\u0005]\u0839\b]\n]\f]\u083c\t" + + "]\u0001]\u0001]\u0005]\u0840\b]\n]\f]\u0843\t]\u0001]\u0003]\u0846\b]" + + "\u0003]\u0848\b]\u0001^\u0001^\u0005^\u084c\b^\n^\f^\u084f\t^\u0001^\u0001" + + "^\u0005^\u0853\b^\n^\f^\u0856\t^\u0001^\u0003^\u0859\b^\u0001^\u0005^" + + "\u085c\b^\n^\f^\u085f\t^\u0001^\u0003^\u0862\b^\u0001_\u0001_\u0003_\u0866" + + "\b_\u0001_\u0001_\u0005_\u086a\b_\n_\f_\u086d\t_\u0001_\u0001_\u0001`" + + "\u0001`\u0003`\u0873\b`\u0001a\u0001a\u0001a\u0005a\u0878\ba\na\fa\u087b" + + "\ta\u0001a\u0001a\u0005a\u087f\ba\na\fa\u0882\ta\u0001a\u0001a\u0003a" + + "\u0886\ba\u0001a\u0003a\u0889\ba\u0001b\u0001b\u0003b\u088d\bb\u0001c" + + "\u0001c\u0005c\u0891\bc\nc\fc\u0894\tc\u0001c\u0001c\u0001c\u0001c\u0005" + + "c\u089a\bc\nc\fc\u089d\tc\u0001c\u0003c\u08a0\bc\u0001c\u0003c\u08a3\b" + + "c\u0001c\u0005c\u08a6\bc\nc\fc\u08a9\tc\u0001c\u0001c\u0005c\u08ad\bc" + + "\nc\fc\u08b0\tc\u0001c\u0003c\u08b3\bc\u0003c\u08b5\bc\u0001d\u0001d\u0003" + + "d\u08b9\bd\u0001e\u0001e\u0005e\u08bd\be\ne\fe\u08c0\te\u0001e\u0001e" + + "\u0001e\u0001e\u0003e\u08c6\be\u0001e\u0005e\u08c9\be\ne\fe\u08cc\te\u0001" + + "e\u0001e\u0005e\u08d0\be\ne\fe\u08d3\te\u0001e\u0001e\u0005e\u08d7\be" + + "\ne\fe\u08da\te\u0005e\u08dc\be\ne\fe\u08df\te\u0001e\u0005e\u08e2\be" + + "\ne\fe\u08e5\te\u0001e\u0001e\u0001f\u0001f\u0005f\u08eb\bf\nf\ff\u08ee" + + "\tf\u0001f\u0001f\u0005f\u08f2\bf\nf\ff\u08f5\tf\u0001f\u0005f\u08f8\b" + + "f\nf\ff\u08fb\tf\u0001f\u0005f\u08fe\bf\nf\ff\u0901\tf\u0001f\u0001f\u0005" + + "f\u0905\bf\nf\ff\u0908\tf\u0001f\u0001f\u0003f\u090c\bf\u0001f\u0001f" + + "\u0005f\u0910\bf\nf\ff\u0913\tf\u0001f\u0001f\u0005f\u0917\bf\nf\ff\u091a" + + "\tf\u0001f\u0003f\u091d\bf\u0001g\u0001g\u0001g\u0003g\u0922\bg\u0001" + + "h\u0001h\u0005h\u0926\bh\nh\fh\u0929\th\u0001h\u0001h\u0001i\u0001i\u0005" + + "i\u092f\bi\ni\fi\u0932\ti\u0001i\u0001i\u0001j\u0001j\u0005j\u0938\bj" + + "\nj\fj\u093b\tj\u0001j\u0001j\u0005j\u093f\bj\nj\fj\u0942\tj\u0001j\u0005" + + "j\u0945\bj\nj\fj\u0948\tj\u0001j\u0005j\u094b\bj\nj\fj\u094e\tj\u0001" + + "j\u0003j\u0951\bj\u0001k\u0001k\u0005k\u0955\bk\nk\fk\u0958\tk\u0001k" + + "\u0001k\u0005k\u095c\bk\nk\fk\u095f\tk\u0001k\u0001k\u0001k\u0001k\u0001" + + "k\u0005k\u0966\bk\nk\fk\u0969\tk\u0001k\u0001k\u0001l\u0001l\u0005l\u096f" + + "\bl\nl\fl\u0972\tl\u0001l\u0001l\u0001m\u0001m\u0001m\u0003m\u0979\bm" + + "\u0001n\u0001n\u0005n\u097d\bn\nn\fn\u0980\tn\u0001n\u0001n\u0005n\u0984" + + "\bn\nn\fn\u0987\tn\u0001n\u0001n\u0003n\u098b\bn\u0001n\u0001n\u0001n" + + "\u0001n\u0005n\u0991\bn\nn\fn\u0994\tn\u0001n\u0003n\u0997\bn\u0001o\u0001" + + "o\u0005o\u099b\bo\no\fo\u099e\to\u0001o\u0001o\u0001o\u0001o\u0005o\u09a4" + + "\bo\no\fo\u09a7\to\u0001o\u0003o\u09aa\bo\u0001p\u0001p\u0005p\u09ae\b" + + "p\np\fp\u09b1\tp\u0001p\u0003p\u09b4\bp\u0001p\u0005p\u09b7\bp\np\fp\u09ba" + + "\tp\u0001p\u0001p\u0005p\u09be\bp\np\fp\u09c1\tp\u0001p\u0001p\u0001p" + + "\u0001p\u0001q\u0001q\u0005q\u09c9\bq\nq\fq\u09cc\tq\u0001q\u0001q\u0001" + + "q\u0003q\u09d1\bq\u0001q\u0001q\u0001q\u0001q\u0003q\u09d7\bq\u0001r\u0001" + + "r\u0001r\u0005r\u09dc\br\nr\fr\u09df\tr\u0005r\u09e1\br\nr\fr\u09e4\t" + + "r\u0003r\u09e6\br\u0001r\u0005r\u09e9\br\nr\fr\u09ec\tr\u0001r\u0001r" + + "\u0005r\u09f0\br\nr\fr\u09f3\tr\u0001r\u0001r\u0003r\u09f7\br\u0001r\u0001" + + "r\u0005r\u09fb\br\nr\fr\u09fe\tr\u0001r\u0001r\u0005r\u0a02\br\nr\fr\u0a05" + + "\tr\u0001r\u0003r\u0a08\br\u0001s\u0001s\u0001t\u0001t\u0001u\u0001u\u0001" + + "v\u0001v\u0001w\u0001w\u0001x\u0001x\u0001y\u0001y\u0001z\u0001z\u0001" + + "{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0003{\u0a21\b{\u0001|\u0001" + + "|\u0001|\u0001|\u0001|\u0001|\u0001|\u0005|\u0a2a\b|\n|\f|\u0a2d\t|\u0001" + + "|\u0001|\u0001|\u0003|\u0a32\b|\u0001}\u0001}\u0001}\u0003}\u0a37\b}\u0001" + + "~\u0001~\u0004~\u0a3b\b~\u000b~\f~\u0a3c\u0001\u007f\u0001\u007f\u0001" + + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001" + + "\u007f\u0003\u007f\u0a48\b\u007f\u0001\u007f\u0005\u007f\u0a4b\b\u007f" + + "\n\u007f\f\u007f\u0a4e\t\u007f\u0001\u0080\u0001\u0080\u0001\u0081\u0001" + + "\u0081\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083\u0001\u0084\u0001" + + "\u0084\u0001\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0087\u0001" + + "\u0087\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089\u0005\u0089\u0a64" + + "\b\u0089\n\u0089\f\u0089\u0a67\t\u0089\u0001\u008a\u0001\u008a\u0003\u008a" + + "\u0a6b\b\u008a\u0001\u008a\u0005\u008a\u0a6e\b\u008a\n\u008a\f\u008a\u0a71" + + "\t\u008a\u0001\u008b\u0001\u008b\u0005\u008b\u0a75\b\u008b\n\u008b\f\u008b" + + "\u0a78\t\u008b\u0001\u008b\u0001\u008b\u0005\u008b\u0a7c\b\u008b\n\u008b" + + "\f\u008b\u0a7f\t\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b" + + "\u0005\u008b\u0a85\b\u008b\n\u008b\f\u008b\u0a88\t\u008b\u0001\u008b\u0001" + + "\u008b\u0005\u008b\u0a8c\b\u008b\n\u008b\f\u008b\u0a8f\t\u008b\u0001\u008b" + + "\u0005\u008b\u0a92\b\u008b\n\u008b\f\u008b\u0a95\t\u008b\u0001\u008b\u0005" + + "\u008b\u0a98\b\u008b\n\u008b\f\u008b\u0a9b\t\u008b\u0001\u008b\u0003\u008b" + + "\u0a9e\b\u008b\u0001\u008b\u0005\u008b\u0aa1\b\u008b\n\u008b\f\u008b\u0aa4" + + "\t\u008b\u0001\u008b\u0003\u008b\u0aa7\b\u008b\u0003\u008b\u0aa9\b\u008b" + + "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0004\u008c\u0aaf\b\u008c" + + "\u000b\u008c\f\u008c\u0ab0\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c" + + "\u0001\u008c\u0004\u008c\u0ab8\b\u008c\u000b\u008c\f\u008c\u0ab9\u0001" + + "\u008c\u0001\u008c\u0003\u008c\u0abe\b\u008c\u0001\u008d\u0001\u008d\u0001" + + "\u008e\u0001\u008e\u0003\u008e\u0ac4\b\u008e\u0001\u008e\u0003\u008e\u0ac7" + + "\b\u008e\u0001\u008f\u0001\u008f\u0005\u008f\u0acb\b\u008f\n\u008f\f\u008f" + + "\u0ace\t\u008f\u0001\u008f\u0001\u008f\u0005\u008f\u0ad2\b\u008f\n\u008f" + + "\f\u008f\u0ad5\t\u008f\u0001\u0090\u0001\u0090\u0001\u0091\u0004\u0091" + + "\u0ada\b\u0091\u000b\u0091\f\u0091\u0adb\u0001\u0091\u0005\u0091\u0adf" + + "\b\u0091\n\u0091\f\u0091\u0ae2\t\u0091\u0001\u0091\u0001\u0091\u0005\u0091" + + "\u0ae6\b\u0091\n\u0091\f\u0091\u0ae9\t\u0091\u0003\u0091\u0aeb\b\u0091" + + "\u0001\u0092\u0001\u0092\u0001\u0092\u0000\u0000\u0093\u0000\u0002\u0004" + + "\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"" + + "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086" + + "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e" + + "\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6" + + "\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce" + + "\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6" + + "\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe" + + "\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116" + + "\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0000\u0019\u0001\u0000;<\u0001" + + "\u0000?@\u0002\u0000\u001b\u001bCC\u0001\u0000\u009c\u009e\u0001\u0000" + + "\u00a2\u00a4\u0002\u000055TT\u0001\u0000$%\u0001\u0000\u001b \u0002\u0000" + + "/023\u0001\u0000+.\u0002\u0000YY[[\u0002\u0000XXZZ\u0001\u0000\u0012\u0013" + + "\u0001\u0000\u000f\u0011\u0003\u0000\u0019\u001911WW\u0001\u0000lp\u0002" + + "\u0000ww||\u0001\u0000hk\u0002\u0000YY\\\\\u0001\u0000qv\u0001\u0000x" + + "z\u0001\u0000}\u007f\u0003\u000088]`cf\b\u0000::BEIINO\\\\abg\u0080\u008c" + + "\u008c\u0002\u0000\u0005\u0005\u001a\u001a\u0c49\u0000\u0129\u0001\u0000" + + "\u0000\u0000\u0002\u0148\u0001\u0000\u0000\u0000\u0004\u0165\u0001\u0000" + + "\u0000\u0000\u0006\u016b\u0001\u0000\u0000\u0000\b\u017f\u0001\u0000\u0000" + + "\u0000\n\u018b\u0001\u0000\u0000\u0000\f\u0190\u0001\u0000\u0000\u0000" + + "\u000e\u0193\u0001\u0000\u0000\u0000\u0010\u019d\u0001\u0000\u0000\u0000" + + "\u0012\u01a5\u0001\u0000\u0000\u0000\u0014\u01a8\u0001\u0000\u0000\u0000" + + "\u0016\u01ee\u0001\u0000\u0000\u0000\u0018\u01fb\u0001\u0000\u0000\u0000" + + "\u001a\u020c\u0001\u0000\u0000\u0000\u001c\u021b\u0001\u0000\u0000\u0000" + + "\u001e\u023b\u0001\u0000\u0000\u0000 \u023d\u0001\u0000\u0000\u0000\"" + + "\u0240\u0001\u0000\u0000\u0000$\u0250\u0001\u0000\u0000\u0000&\u026d\u0001" + + "\u0000\u0000\u0000(\u0274\u0001\u0000\u0000\u0000*\u027e\u0001\u0000\u0000" + + "\u0000,\u02b1\u0001\u0000\u0000\u0000.\u02b3\u0001\u0000\u0000\u00000" + + "\u02e1\u0001\u0000\u0000\u00002\u02eb\u0001\u0000\u0000\u00004\u030b\u0001" + + "\u0000\u0000\u00006\u036b\u0001\u0000\u0000\u00008\u037c\u0001\u0000\u0000" + + "\u0000:\u0383\u0001\u0000\u0000\u0000<\u0388\u0001\u0000\u0000\u0000>" + + "\u0398\u0001\u0000\u0000\u0000@\u039b\u0001\u0000\u0000\u0000B\u03c8\u0001" + + "\u0000\u0000\u0000D\u03f8\u0001\u0000\u0000\u0000F\u0452\u0001\u0000\u0000" + + "\u0000H\u045d\u0001\u0000\u0000\u0000J\u0493\u0001\u0000\u0000\u0000L" + + "\u04b8\u0001\u0000\u0000\u0000N\u04bb\u0001\u0000\u0000\u0000P\u04dd\u0001" + + "\u0000\u0000\u0000R\u050a\u0001\u0000\u0000\u0000T\u0527\u0001\u0000\u0000" + + "\u0000V\u0537\u0001\u0000\u0000\u0000X\u053b\u0001\u0000\u0000\u0000Z" + + "\u0541\u0001\u0000\u0000\u0000\\\u0554\u0001\u0000\u0000\u0000^\u0564" + + "\u0001\u0000\u0000\u0000`\u0579\u0001\u0000\u0000\u0000b\u057b\u0001\u0000" + + "\u0000\u0000d\u058f\u0001\u0000\u0000\u0000f\u0599\u0001\u0000\u0000\u0000" + + "h\u05cb\u0001\u0000\u0000\u0000j\u05e9\u0001\u0000\u0000\u0000l\u05fc" + + "\u0001\u0000\u0000\u0000n\u0603\u0001\u0000\u0000\u0000p\u0618\u0001\u0000" + + "\u0000\u0000r\u061d\u0001\u0000\u0000\u0000t\u062b\u0001\u0000\u0000\u0000" + + "v\u0634\u0001\u0000\u0000\u0000x\u063d\u0001\u0000\u0000\u0000z\u0651" + + "\u0001\u0000\u0000\u0000|\u0665\u0001\u0000\u0000\u0000~\u0674\u0001\u0000" + + "\u0000\u0000\u0080\u0680\u0001\u0000\u0000\u0000\u0082\u0699\u0001\u0000" + + "\u0000\u0000\u0084\u06ad\u0001\u0000\u0000\u0000\u0086\u06bc\u0001\u0000" + + "\u0000\u0000\u0088\u06ca\u0001\u0000\u0000\u0000\u008a\u06d9\u0001\u0000" + + "\u0000\u0000\u008c\u06e8\u0001\u0000\u0000\u0000\u008e\u06fa\u0001\u0000" + + "\u0000\u0000\u0090\u0701\u0001\u0000\u0000\u0000\u0092\u0717\u0001\u0000" + + "\u0000\u0000\u0094\u0719\u0001\u0000\u0000\u0000\u0096\u0733\u0001\u0000" + + "\u0000\u0000\u0098\u0738\u0001\u0000\u0000\u0000\u009a\u0746\u0001\u0000" + + "\u0000\u0000\u009c\u0753\u0001\u0000\u0000\u0000\u009e\u0769\u0001\u0000" + + "\u0000\u0000\u00a0\u0796\u0001\u0000\u0000\u0000\u00a2\u0799\u0001\u0000" + + "\u0000\u0000\u00a4\u07ab\u0001\u0000\u0000\u0000\u00a6\u07c1\u0001\u0000" + + "\u0000\u0000\u00a8\u07c5\u0001\u0000\u0000\u0000\u00aa\u07c7\u0001\u0000" + + "\u0000\u0000\u00ac\u07d1\u0001\u0000\u0000\u0000\u00ae\u07dd\u0001\u0000" + + "\u0000\u0000\u00b0\u07df\u0001\u0000\u0000\u0000\u00b2\u07e3\u0001\u0000" + + "\u0000\u0000\u00b4\u07e5\u0001\u0000\u0000\u0000\u00b6\u07ec\u0001\u0000" + + "\u0000\u0000\u00b8\u0820\u0001\u0000\u0000\u0000\u00ba\u0847\u0001\u0000" + + "\u0000\u0000\u00bc\u0849\u0001\u0000\u0000\u0000\u00be\u0863\u0001\u0000" + + "\u0000\u0000\u00c0\u0870\u0001\u0000\u0000\u0000\u00c2\u0874\u0001\u0000" + + "\u0000\u0000\u00c4\u088c\u0001\u0000\u0000\u0000\u00c6\u088e\u0001\u0000" + + "\u0000\u0000\u00c8\u08b8\u0001\u0000\u0000\u0000\u00ca\u08ba\u0001\u0000" + + "\u0000\u0000\u00cc\u091c\u0001\u0000\u0000\u0000\u00ce\u0921\u0001\u0000" + + "\u0000\u0000\u00d0\u0923\u0001\u0000\u0000\u0000\u00d2\u092c\u0001\u0000" + + "\u0000\u0000\u00d4\u0935\u0001\u0000\u0000\u0000\u00d6\u0952\u0001\u0000" + + "\u0000\u0000\u00d8\u096c\u0001\u0000\u0000\u0000\u00da\u0978\u0001\u0000" + + "\u0000\u0000\u00dc\u097a\u0001\u0000\u0000\u0000\u00de\u0998\u0001\u0000" + + "\u0000\u0000\u00e0\u09ab\u0001\u0000\u0000\u0000\u00e2\u09d6\u0001\u0000" + + "\u0000\u0000\u00e4\u0a07\u0001\u0000\u0000\u0000\u00e6\u0a09\u0001\u0000" + + "\u0000\u0000\u00e8\u0a0b\u0001\u0000\u0000\u0000\u00ea\u0a0d\u0001\u0000" + + "\u0000\u0000\u00ec\u0a0f\u0001\u0000\u0000\u0000\u00ee\u0a11\u0001\u0000" + + "\u0000\u0000\u00f0\u0a13\u0001\u0000\u0000\u0000\u00f2\u0a15\u0001\u0000" + + "\u0000\u0000\u00f4\u0a17\u0001\u0000\u0000\u0000\u00f6\u0a20\u0001\u0000" + + "\u0000\u0000\u00f8\u0a31\u0001\u0000\u0000\u0000\u00fa\u0a36\u0001\u0000" + + "\u0000\u0000\u00fc\u0a3a\u0001\u0000\u0000\u0000\u00fe\u0a47\u0001\u0000" + + "\u0000\u0000\u0100\u0a4f\u0001\u0000\u0000\u0000\u0102\u0a51\u0001\u0000" + + "\u0000\u0000\u0104\u0a53\u0001\u0000\u0000\u0000\u0106\u0a55\u0001\u0000" + + "\u0000\u0000\u0108\u0a57\u0001\u0000\u0000\u0000\u010a\u0a59\u0001\u0000" + + "\u0000\u0000\u010c\u0a5b\u0001\u0000\u0000\u0000\u010e\u0a5d\u0001\u0000" + + "\u0000\u0000\u0110\u0a5f\u0001\u0000\u0000\u0000\u0112\u0a61\u0001\u0000" + + "\u0000\u0000\u0114\u0a6a\u0001\u0000\u0000\u0000\u0116\u0aa8\u0001\u0000" + + "\u0000\u0000\u0118\u0abd\u0001\u0000\u0000\u0000\u011a\u0abf\u0001\u0000" + + "\u0000\u0000\u011c\u0ac1\u0001\u0000\u0000\u0000\u011e\u0ac8\u0001\u0000" + + "\u0000\u0000\u0120\u0ad6\u0001\u0000\u0000\u0000\u0122\u0aea\u0001\u0000" + + "\u0000\u0000\u0124\u0aec\u0001\u0000\u0000\u0000\u0126\u0128\u0005\u0005" + + "\u0000\u0000\u0127\u0126\u0001\u0000\u0000\u0000\u0128\u012b\u0001\u0000" + + "\u0000\u0000\u0129\u0127\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000" + + "\u0000\u0000\u012a\u012c\u0001\u0000\u0000\u0000\u012b\u0129\u0001\u0000" + + "\u0000\u0000\u012c\u0130\u0003\u0004\u0002\u0000\u012d\u012f\u0003\u0124" + + "\u0092\u0000\u012e\u012d\u0001\u0000\u0000\u0000\u012f\u0132\u0001\u0000" + + "\u0000\u0000\u0130\u012e\u0001\u0000\u0000\u0000\u0130\u0131\u0001\u0000" + + "\u0000\u0000\u0131\u0141\u0001\u0000\u0000\u0000\u0132\u0130\u0001\u0000" + + "\u0000\u0000\u0133\u013e\u0003\u0012\t\u0000\u0134\u0136\u0003\u0124\u0092" + + "\u0000\u0135\u0134\u0001\u0000\u0000\u0000\u0136\u0137\u0001\u0000\u0000" + + "\u0000\u0137\u0135\u0001\u0000\u0000\u0000\u0137\u0138\u0001\u0000\u0000" + + "\u0000\u0138\u013a\u0001\u0000\u0000\u0000\u0139\u013b\u0003\u0012\t\u0000" + + "\u013a\u0139\u0001\u0000\u0000\u0000\u013a\u013b\u0001\u0000\u0000\u0000" + + "\u013b\u013d\u0001\u0000\u0000\u0000\u013c\u0135\u0001\u0000\u0000\u0000" + + "\u013d\u0140\u0001\u0000\u0000\u0000\u013e\u013c\u0001\u0000\u0000\u0000" + + "\u013e\u013f\u0001\u0000\u0000\u0000\u013f\u0142\u0001\u0000\u0000\u0000" + + "\u0140\u013e\u0001\u0000\u0000\u0000\u0141\u0133\u0001\u0000\u0000\u0000" + + "\u0141\u0142\u0001\u0000\u0000\u0000\u0142\u0143\u0001\u0000\u0000\u0000" + + "\u0143\u0144\u0005\u0000\u0000\u0001\u0144\u0001\u0001\u0000\u0000\u0000" + + "\u0145\u0147\u0005\u0005\u0000\u0000\u0146\u0145\u0001\u0000\u0000\u0000" + + "\u0147\u014a\u0001\u0000\u0000\u0000\u0148\u0146\u0001\u0000\u0000\u0000" + + "\u0148\u0149\u0001\u0000\u0000\u0000\u0149\u014b\u0001\u0000\u0000\u0000" + + "\u014a\u0148\u0001\u0000\u0000\u0000\u014b\u014f\u0003\u0004\u0002\u0000" + + "\u014c\u014e\u0003\u0124\u0092\u0000\u014d\u014c\u0001\u0000\u0000\u0000" + + "\u014e\u0151\u0001\u0000\u0000\u0000\u014f\u014d\u0001\u0000\u0000\u0000" + + "\u014f\u0150\u0001\u0000\u0000\u0000\u0150\u0160\u0001\u0000\u0000\u0000" + + "\u0151\u014f\u0001\u0000\u0000\u0000\u0152\u015d\u0003v;\u0000\u0153\u0155" + + "\u0003\u0124\u0092\u0000\u0154\u0153\u0001\u0000\u0000\u0000\u0155\u0156" + + "\u0001\u0000\u0000\u0000\u0156\u0154\u0001\u0000\u0000\u0000\u0156\u0157" + + "\u0001\u0000\u0000\u0000\u0157\u0159\u0001\u0000\u0000\u0000\u0158\u015a" + + "\u0003v;\u0000\u0159\u0158\u0001\u0000\u0000\u0000\u0159\u015a\u0001\u0000" + + "\u0000\u0000\u015a\u015c\u0001\u0000\u0000\u0000\u015b\u0154\u0001\u0000" + + "\u0000\u0000\u015c\u015f\u0001\u0000\u0000\u0000\u015d\u015b\u0001\u0000" + + "\u0000\u0000\u015d\u015e\u0001\u0000\u0000\u0000\u015e\u0161\u0001\u0000" + + "\u0000\u0000\u015f\u015d\u0001\u0000\u0000\u0000\u0160\u0152\u0001\u0000" + + "\u0000\u0000\u0160\u0161\u0001\u0000\u0000\u0000\u0161\u0162\u0001\u0000" + + "\u0000\u0000\u0162\u0163\u0005\u0000\u0000\u0001\u0163\u0003\u0001\u0000" + + "\u0000\u0000\u0164\u0166\u0003\u0006\u0003\u0000\u0165\u0164\u0001\u0000" + + "\u0000\u0000\u0165\u0166\u0001\u0000\u0000\u0000\u0166\u0167\u0001\u0000" + + "\u0000\u0000\u0167\u0168\u0003\n\u0005\u0000\u0168\u0169\u0003\f\u0006" + + "\u0000\u0169\u0005\u0001\u0000\u0000\u0000\u016a\u016c\u0003\b\u0004\u0000" + + "\u016b\u016a\u0001\u0000\u0000\u0000\u016c\u016d\u0001\u0000\u0000\u0000" + + "\u016d\u016b\u0001\u0000\u0000\u0000\u016d\u016e\u0001\u0000\u0000\u0000" + + "\u016e\u0007\u0001\u0000\u0000\u0000\u016f\u0170\u00058\u0000\u0000\u0170" + + "\u017a\u0005\u0019\u0000\u0000\u0171\u0173\u0005\u000b\u0000\u0000\u0172" + + "\u0174\u0003\u011c\u008e\u0000\u0173\u0172\u0001\u0000\u0000\u0000\u0174" + + "\u0175\u0001\u0000\u0000\u0000\u0175\u0173\u0001\u0000\u0000\u0000\u0175" + + "\u0176\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000\u0177" + + "\u0178\u0005\f\u0000\u0000\u0178\u017b\u0001\u0000\u0000\u0000\u0179\u017b" + + "\u0003\u011c\u008e\u0000\u017a\u0171\u0001\u0000\u0000\u0000\u017a\u0179" + + "\u0001\u0000\u0000\u0000\u017b\u017d\u0001\u0000\u0000\u0000\u017c\u017e" + + "\u0003\u0122\u0091\u0000\u017d\u017c\u0001\u0000\u0000\u0000\u017d\u017e" + + "\u0001\u0000\u0000\u0000\u017e\u0180\u0001\u0000\u0000\u0000\u017f\u016f" + + "\u0001\u0000\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181\u017f" + + "\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000\u0000\u0000\u0182\t\u0001" + + "\u0000\u0000\u0000\u0183\u0185\u0003\u00fc~\u0000\u0184\u0183\u0001\u0000" + + "\u0000\u0000\u0184\u0185\u0001\u0000\u0000\u0000\u0185\u0186\u0001\u0000" + + "\u0000\u0000\u0186\u0187\u00059\u0000\u0000\u0187\u0189\u0003\u011e\u008f" + + "\u0000\u0188\u018a\u0003\u0122\u0091\u0000\u0189\u0188\u0001\u0000\u0000" + + "\u0000\u0189\u018a\u0001\u0000\u0000\u0000\u018a\u018c\u0001\u0000\u0000" + + "\u0000\u018b\u0184\u0001\u0000\u0000\u0000\u018b\u018c\u0001\u0000\u0000" + + "\u0000\u018c\u000b\u0001\u0000\u0000\u0000\u018d\u018f\u0003\u000e\u0007" + + "\u0000\u018e\u018d\u0001\u0000\u0000\u0000\u018f\u0192\u0001\u0000\u0000" + + "\u0000\u0190\u018e\u0001\u0000\u0000\u0000\u0190\u0191\u0001\u0000\u0000" + + "\u0000\u0191\r\u0001\u0000\u0000\u0000\u0192\u0190\u0001\u0000\u0000\u0000" + + "\u0193\u0194\u0005:\u0000\u0000\u0194\u0198\u0003\u011e\u008f\u0000\u0195" + + "\u0196\u0005\u0007\u0000\u0000\u0196\u0199\u0005\u000f\u0000\u0000\u0197" + + "\u0199\u0003\u0010\b\u0000\u0198\u0195\u0001\u0000\u0000\u0000\u0198\u0197" + + "\u0001\u0000\u0000\u0000\u0198\u0199\u0001\u0000\u0000\u0000\u0199\u019b" + + "\u0001\u0000\u0000\u0000\u019a\u019c\u0003\u0122\u0091\u0000\u019b\u019a" + + "\u0001\u0000\u0000\u0000\u019b\u019c\u0001\u0000\u0000\u0000\u019c\u000f" + + "\u0001\u0000\u0000\u0000\u019d\u019e\u0005W\u0000\u0000\u019e\u019f\u0003" + + "\u0120\u0090\u0000\u019f\u0011\u0001\u0000\u0000\u0000\u01a0\u01a6\u0003" + + "\u0014\n\u0000\u01a1\u01a6\u0003@ \u0000\u01a2\u01a6\u00034\u001a\u0000" + + "\u01a3\u01a6\u0003D\"\u0000\u01a4\u01a6\u0003N\'\u0000\u01a5\u01a0\u0001" + + "\u0000\u0000\u0000\u01a5\u01a1\u0001\u0000\u0000\u0000\u01a5\u01a2\u0001" + + "\u0000\u0000\u0000\u01a5\u01a3\u0001\u0000\u0000\u0000\u01a5\u01a4\u0001" + + "\u0000\u0000\u0000\u01a6\u0013\u0001\u0000\u0000\u0000\u01a7\u01a9\u0003" + + "\u00fc~\u0000\u01a8\u01a7\u0001\u0000\u0000\u0000\u01a8\u01a9\u0001\u0000" + + "\u0000\u0000\u01a9\u01aa\u0001\u0000\u0000\u0000\u01aa\u01ae\u0007\u0000" + + "\u0000\u0000\u01ab\u01ad\u0005\u0005\u0000\u0000\u01ac\u01ab\u0001\u0000" + + "\u0000\u0000\u01ad\u01b0\u0001\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000" + + "\u0000\u0000\u01ae\u01af\u0001\u0000\u0000\u0000\u01af\u01b1\u0001\u0000" + + "\u0000\u0000\u01b0\u01ae\u0001\u0000\u0000\u0000\u01b1\u01b9\u0003\u0120" + + "\u0090\u0000\u01b2\u01b4\u0005\u0005\u0000\u0000\u01b3\u01b2\u0001\u0000" + + "\u0000\u0000\u01b4\u01b7\u0001\u0000\u0000\u0000\u01b5\u01b3\u0001\u0000" + + "\u0000\u0000\u01b5\u01b6\u0001\u0000\u0000\u0000\u01b6\u01b8\u0001\u0000" + + "\u0000\u0000\u01b7\u01b5\u0001\u0000\u0000\u0000\u01b8\u01ba\u0003P(\u0000" + + "\u01b9\u01b5\u0001\u0000\u0000\u0000\u01b9\u01ba\u0001\u0000\u0000\u0000" + + "\u01ba\u01c2\u0001\u0000\u0000\u0000\u01bb\u01bd\u0005\u0005\u0000\u0000" + + "\u01bc\u01bb\u0001\u0000\u0000\u0000\u01bd\u01c0\u0001\u0000\u0000\u0000" + + "\u01be\u01bc\u0001\u0000\u0000\u0000\u01be\u01bf\u0001\u0000\u0000\u0000" + + "\u01bf\u01c1\u0001\u0000\u0000\u0000\u01c0\u01be\u0001\u0000\u0000\u0000" + + "\u01c1\u01c3\u0003\u0016\u000b\u0000\u01c2\u01be\u0001\u0000\u0000\u0000" + + "\u01c2\u01c3\u0001\u0000\u0000\u0000\u01c3\u01d2\u0001\u0000\u0000\u0000" + + "\u01c4\u01c6\u0005\u0005\u0000\u0000\u01c5\u01c4\u0001\u0000\u0000\u0000" + + "\u01c6\u01c9\u0001\u0000\u0000\u0000\u01c7\u01c5\u0001\u0000\u0000\u0000" + + "\u01c7\u01c8\u0001\u0000\u0000\u0000\u01c8\u01ca\u0001\u0000\u0000\u0000" + + "\u01c9\u01c7\u0001\u0000\u0000\u0000\u01ca\u01ce\u0005\u0019\u0000\u0000" + + "\u01cb\u01cd\u0005\u0005\u0000\u0000\u01cc\u01cb\u0001\u0000\u0000\u0000" + + "\u01cd\u01d0\u0001\u0000\u0000\u0000\u01ce\u01cc\u0001\u0000\u0000\u0000" + + "\u01ce\u01cf\u0001\u0000\u0000\u0000\u01cf\u01d1\u0001\u0000\u0000\u0000" + + "\u01d0\u01ce\u0001\u0000\u0000\u0000\u01d1\u01d3\u0003\u001c\u000e\u0000" + + "\u01d2\u01c7\u0001\u0000\u0000\u0000\u01d2\u01d3\u0001\u0000\u0000\u0000" + + "\u01d3\u01db\u0001\u0000\u0000\u0000\u01d4\u01d6\u0005\u0005\u0000\u0000" + + "\u01d5\u01d4\u0001\u0000\u0000\u0000\u01d6\u01d9\u0001\u0000\u0000\u0000" + + "\u01d7\u01d5\u0001\u0000\u0000\u0000\u01d7\u01d8\u0001\u0000\u0000\u0000" + + "\u01d8\u01da\u0001\u0000\u0000\u0000\u01d9\u01d7\u0001\u0000\u0000\u0000" + + "\u01da\u01dc\u0003h4\u0000\u01db\u01d7\u0001\u0000\u0000\u0000\u01db\u01dc" + + "\u0001\u0000\u0000\u0000\u01dc\u01eb\u0001\u0000\u0000\u0000\u01dd\u01df" + + "\u0005\u0005\u0000\u0000\u01de\u01dd\u0001\u0000\u0000\u0000\u01df\u01e2" + + "\u0001\u0000\u0000\u0000\u01e0\u01de\u0001\u0000\u0000\u0000\u01e0\u01e1" + + "\u0001\u0000\u0000\u0000\u01e1\u01e3\u0001\u0000\u0000\u0000\u01e2\u01e0" + + "\u0001\u0000\u0000\u0000\u01e3\u01ec\u0003$\u0012\u0000\u01e4\u01e6\u0005" + + "\u0005\u0000\u0000\u01e5\u01e4\u0001\u0000\u0000\u0000\u01e6\u01e9\u0001" + + "\u0000\u0000\u0000\u01e7\u01e5\u0001\u0000\u0000\u0000\u01e7\u01e8\u0001" + + "\u0000\u0000\u0000\u01e8\u01ea\u0001\u0000\u0000\u0000\u01e9\u01e7\u0001" + + "\u0000\u0000\u0000\u01ea\u01ec\u0003.\u0017\u0000\u01eb\u01e0\u0001\u0000" + + "\u0000\u0000\u01eb\u01e7\u0001\u0000\u0000\u0000\u01eb\u01ec\u0001\u0000" + + "\u0000\u0000\u01ec\u0015\u0001\u0000\u0000\u0000\u01ed\u01ef\u0003\u00fc" + + "~\u0000\u01ee\u01ed\u0001\u0000\u0000\u0000\u01ee\u01ef\u0001\u0000\u0000" + + "\u0000\u01ef\u01f7\u0001\u0000\u0000\u0000\u01f0\u01f4\u0005B\u0000\u0000" + + "\u01f1\u01f3\u0005\u0005\u0000\u0000\u01f2\u01f1\u0001\u0000\u0000\u0000" + + "\u01f3\u01f6\u0001\u0000\u0000\u0000\u01f4\u01f2\u0001\u0000\u0000\u0000" + + "\u01f4\u01f5\u0001\u0000\u0000\u0000\u01f5\u01f8\u0001\u0000\u0000\u0000" + + "\u01f6\u01f4\u0001\u0000\u0000\u0000\u01f7\u01f0\u0001\u0000\u0000\u0000" + + "\u01f7\u01f8\u0001\u0000\u0000\u0000\u01f8\u01f9\u0001\u0000\u0000\u0000" + + "\u01f9\u01fa\u0003\u0018\f\u0000\u01fa\u0017\u0001\u0000\u0000\u0000\u01fb" + + "\u0207\u0005\t\u0000\u0000\u01fc\u0201\u0003\u001a\r\u0000\u01fd\u01fe" + + "\u0005\b\u0000\u0000\u01fe\u0200\u0003\u001a\r\u0000\u01ff\u01fd\u0001" + + "\u0000\u0000\u0000\u0200\u0203\u0001\u0000\u0000\u0000\u0201\u01ff\u0001" + + "\u0000\u0000\u0000\u0201\u0202\u0001\u0000\u0000\u0000\u0202\u0205\u0001" + + "\u0000\u0000\u0000\u0203\u0201\u0001\u0000\u0000\u0000\u0204\u0206\u0005" + + "\b\u0000\u0000\u0205\u0204\u0001\u0000\u0000\u0000\u0205\u0206\u0001\u0000" + + "\u0000\u0000\u0206\u0208\u0001\u0000\u0000\u0000\u0207\u01fc\u0001\u0000" + + "\u0000\u0000\u0207\u0208\u0001\u0000\u0000\u0000\u0208\u0209\u0001\u0000" + + "\u0000\u0000\u0209\u020a\u0005\n\u0000\u0000\u020a\u0019\u0001\u0000\u0000" + + "\u0000\u020b\u020d\u0003\u00fc~\u0000\u020c\u020b\u0001\u0000\u0000\u0000" + + "\u020c\u020d\u0001\u0000\u0000\u0000\u020d\u020f\u0001\u0000\u0000\u0000" + + "\u020e\u0210\u0007\u0001\u0000\u0000\u020f\u020e\u0001\u0000\u0000\u0000" + + "\u020f\u0210\u0001\u0000\u0000\u0000\u0210\u0211\u0001\u0000\u0000\u0000" + + "\u0211\u0212\u0003\u0120\u0090\u0000\u0212\u0213\u0005\u0019\u0000\u0000" + + "\u0213\u0216\u0003T*\u0000\u0214\u0215\u0005\u001b\u0000\u0000\u0215\u0217" + + "\u0003v;\u0000\u0216\u0214\u0001\u0000\u0000\u0000\u0216\u0217\u0001\u0000" + + "\u0000\u0000\u0217\u001b\u0001\u0000\u0000\u0000\u0218\u021a\u0003\u0114" + + "\u008a\u0000\u0219\u0218\u0001\u0000\u0000\u0000\u021a\u021d\u0001\u0000" + + "\u0000\u0000\u021b\u0219\u0001\u0000\u0000\u0000\u021b\u021c\u0001\u0000" + + "\u0000\u0000\u021c\u021e\u0001\u0000\u0000\u0000\u021d\u021b\u0001\u0000" + + "\u0000\u0000\u021e\u0235\u0003\u001e\u000f\u0000\u021f\u0221\u0005\u0005" + + "\u0000\u0000\u0220\u021f\u0001\u0000\u0000\u0000\u0221\u0224\u0001\u0000" + + "\u0000\u0000\u0222\u0220\u0001\u0000\u0000\u0000\u0222\u0223\u0001\u0000" + + "\u0000\u0000\u0223\u0225\u0001\u0000\u0000\u0000\u0224\u0222\u0001\u0000" + + "\u0000\u0000\u0225\u0229\u0005\b\u0000\u0000\u0226\u0228\u0005\u0005\u0000" + + "\u0000\u0227\u0226\u0001\u0000\u0000\u0000\u0228\u022b\u0001\u0000\u0000" + + "\u0000\u0229\u0227\u0001\u0000\u0000\u0000\u0229\u022a\u0001\u0000\u0000" + + "\u0000\u022a\u022f\u0001\u0000\u0000\u0000\u022b\u0229\u0001\u0000\u0000" + + "\u0000\u022c\u022e\u0003\u0114\u008a\u0000\u022d\u022c\u0001\u0000\u0000" + + "\u0000\u022e\u0231\u0001\u0000\u0000\u0000\u022f\u022d\u0001\u0000\u0000" + + "\u0000\u022f\u0230\u0001\u0000\u0000\u0000\u0230\u0232\u0001\u0000\u0000" + + "\u0000\u0231\u022f\u0001\u0000\u0000\u0000\u0232\u0234\u0003\u001e\u000f" + + "\u0000\u0233\u0222\u0001\u0000\u0000\u0000\u0234\u0237\u0001\u0000\u0000" + + "\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000\u0000" + + "\u0000\u0236\u001d\u0001\u0000\u0000\u0000\u0237\u0235\u0001\u0000\u0000" + + "\u0000\u0238\u023c\u0003 \u0010\u0000\u0239\u023c\u0003b1\u0000\u023a" + + "\u023c\u0003\"\u0011\u0000\u023b\u0238\u0001\u0000\u0000\u0000\u023b\u0239" + + "\u0001\u0000\u0000\u0000\u023b\u023a\u0001\u0000\u0000\u0000\u023c\u001f" + + "\u0001\u0000\u0000\u0000\u023d\u023e\u0003b1\u0000\u023e\u023f\u0003\u0096" + + "K\u0000\u023f!\u0001\u0000\u0000\u0000\u0240\u0244\u0003b1\u0000\u0241" + + "\u0243\u0005\u0005\u0000\u0000\u0242\u0241\u0001\u0000\u0000\u0000\u0243" + + "\u0246\u0001\u0000\u0000\u0000\u0244\u0242\u0001\u0000\u0000\u0000\u0244" + + "\u0245\u0001\u0000\u0000\u0000\u0245\u0247\u0001\u0000\u0000\u0000\u0246" + + "\u0244\u0001\u0000\u0000\u0000\u0247\u024b\u0005C\u0000\u0000\u0248\u024a" + + "\u0005\u0005\u0000\u0000\u0249\u0248\u0001\u0000\u0000\u0000\u024a\u024d" + + "\u0001\u0000\u0000\u0000\u024b\u0249\u0001\u0000\u0000\u0000\u024b\u024c" + + "\u0001\u0000\u0000\u0000\u024c\u024e\u0001\u0000\u0000\u0000\u024d\u024b" + + "\u0001\u0000\u0000\u0000\u024e\u024f\u0003v;\u0000\u024f#\u0001\u0000" + + "\u0000\u0000\u0250\u0254\u0005\r\u0000\u0000\u0251\u0253\u0005\u0005\u0000" + + "\u0000\u0252\u0251\u0001\u0000\u0000\u0000\u0253\u0256\u0001\u0000\u0000" + + "\u0000\u0254\u0252\u0001\u0000\u0000\u0000\u0254\u0255\u0001\u0000\u0000" + + "\u0000\u0255\u025a\u0001\u0000\u0000\u0000\u0256\u0254\u0001\u0000\u0000" + + "\u0000\u0257\u0259\u0003&\u0013\u0000\u0258\u0257\u0001\u0000\u0000\u0000" + + "\u0259\u025c\u0001\u0000\u0000\u0000\u025a\u0258\u0001\u0000\u0000\u0000" + + "\u025a\u025b\u0001\u0000\u0000\u0000\u025b\u0260\u0001\u0000\u0000\u0000" + + "\u025c\u025a\u0001\u0000\u0000\u0000\u025d\u025f\u0005\u0005\u0000\u0000" + + "\u025e\u025d\u0001\u0000\u0000\u0000\u025f\u0262\u0001\u0000\u0000\u0000" + + "\u0260\u025e\u0001\u0000\u0000\u0000\u0260\u0261\u0001\u0000\u0000\u0000" + + "\u0261\u0263\u0001\u0000\u0000\u0000\u0262\u0260\u0001\u0000\u0000\u0000" + + "\u0263\u0264\u0005\u000e\u0000\u0000\u0264%\u0001\u0000\u0000\u0000\u0265" + + "\u026e\u0003\u0014\n\u0000\u0266\u026e\u00034\u001a\u0000\u0267\u026e" + + "\u0003@ \u0000\u0268\u026e\u0003B!\u0000\u0269\u026e\u0003D\"\u0000\u026a" + + "\u026e\u0003(\u0014\u0000\u026b\u026e\u0003*\u0015\u0000\u026c\u026e\u0003" + + "N\'\u0000\u026d\u0265\u0001\u0000\u0000\u0000\u026d\u0266\u0001\u0000" + + "\u0000\u0000\u026d\u0267\u0001\u0000\u0000\u0000\u026d\u0268\u0001\u0000" + + "\u0000\u0000\u026d\u0269\u0001\u0000\u0000\u0000\u026d\u026a\u0001\u0000" + + "\u0000\u0000\u026d\u026b\u0001\u0000\u0000\u0000\u026d\u026c\u0001\u0000" + + "\u0000\u0000\u026e\u0270\u0001\u0000\u0000\u0000\u026f\u0271\u0003\u0124" + + "\u0092\u0000\u0270\u026f\u0001\u0000\u0000\u0000\u0271\u0272\u0001\u0000" + + "\u0000\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000" + + "\u0000\u0000\u0273\'\u0001\u0000\u0000\u0000\u0274\u0278\u0005E\u0000" + + "\u0000\u0275\u0277\u0005\u0005\u0000\u0000\u0276\u0275\u0001\u0000\u0000" + + "\u0000\u0277\u027a\u0001\u0000\u0000\u0000\u0278\u0276\u0001\u0000\u0000" + + "\u0000\u0278\u0279\u0001\u0000\u0000\u0000\u0279\u027b\u0001\u0000\u0000" + + "\u0000\u027a\u0278\u0001\u0000\u0000\u0000\u027b\u027c\u0003l6\u0000\u027c" + + ")\u0001\u0000\u0000\u0000\u027d\u027f\u0003\u00fc~\u0000\u027e\u027d\u0001" + + "\u0000\u0000\u0000\u027e\u027f\u0001\u0000\u0000\u0000\u027f\u0280\u0001" + + "\u0000\u0000\u0000\u0280\u0284\u0005B\u0000\u0000\u0281\u0283\u0005\u0005" + + "\u0000\u0000\u0282\u0281\u0001\u0000\u0000\u0000\u0283\u0286\u0001\u0000" + + "\u0000\u0000\u0284\u0282\u0001\u0000\u0000\u0000\u0284\u0285\u0001\u0000" + + "\u0000\u0000\u0285\u0287\u0001\u0000\u0000\u0000\u0286\u0284\u0001\u0000" + + "\u0000\u0000\u0287\u0296\u00036\u001b\u0000\u0288\u028a\u0005\u0005\u0000" + + "\u0000\u0289\u0288\u0001\u0000\u0000\u0000\u028a\u028d\u0001\u0000\u0000" + + "\u0000\u028b\u0289\u0001\u0000\u0000\u0000\u028b\u028c\u0001\u0000\u0000" + + "\u0000\u028c\u028e\u0001\u0000\u0000\u0000\u028d\u028b\u0001\u0000\u0000" + + "\u0000\u028e\u0292\u0005\u0019\u0000\u0000\u028f\u0291\u0005\u0005\u0000" + + "\u0000\u0290\u028f\u0001\u0000\u0000\u0000\u0291\u0294\u0001\u0000\u0000" + + "\u0000\u0292\u0290\u0001\u0000\u0000\u0000\u0292\u0293\u0001\u0000\u0000" + + "\u0000\u0293\u0295\u0001\u0000\u0000\u0000\u0294\u0292\u0001\u0000\u0000" + + "\u0000\u0295\u0297\u0003,\u0016\u0000\u0296\u028b\u0001\u0000\u0000\u0000" + + "\u0296\u0297\u0001\u0000\u0000\u0000\u0297\u029b\u0001\u0000\u0000\u0000" + + "\u0298\u029a\u0005\u0005\u0000\u0000\u0299\u0298\u0001\u0000\u0000\u0000" + + "\u029a\u029d\u0001\u0000\u0000\u0000\u029b\u0299\u0001\u0000\u0000\u0000" + + "\u029b\u029c\u0001\u0000\u0000\u0000\u029c\u029f\u0001\u0000\u0000\u0000" + + "\u029d\u029b\u0001\u0000\u0000\u0000\u029e\u02a0\u0003l6\u0000\u029f\u029e" + + "\u0001\u0000\u0000\u0000\u029f\u02a0\u0001\u0000\u0000\u0000\u02a0+\u0001" + + "\u0000\u0000\u0000\u02a1\u02a5\u0005F\u0000\u0000\u02a2\u02a4\u0005\u0005" + + "\u0000\u0000\u02a3\u02a2\u0001\u0000\u0000\u0000\u02a4\u02a7\u0001\u0000" + + "\u0000\u0000\u02a5\u02a3\u0001\u0000\u0000\u0000\u02a5\u02a6\u0001\u0000" + + "\u0000\u0000\u02a6\u02a8\u0001\u0000\u0000\u0000\u02a7\u02a5\u0001\u0000" + + "\u0000\u0000\u02a8\u02b2\u0003\u009cN\u0000\u02a9\u02ad\u0005G\u0000\u0000" + + "\u02aa\u02ac\u0005\u0005\u0000\u0000\u02ab\u02aa\u0001\u0000\u0000\u0000" + + "\u02ac\u02af\u0001\u0000\u0000\u0000\u02ad\u02ab\u0001\u0000\u0000\u0000" + + "\u02ad\u02ae\u0001\u0000\u0000\u0000\u02ae\u02b0\u0001\u0000\u0000\u0000" + + "\u02af\u02ad\u0001\u0000\u0000\u0000\u02b0\u02b2\u0003\u009cN\u0000\u02b1" + + "\u02a1\u0001\u0000\u0000\u0000\u02b1\u02a9\u0001\u0000\u0000\u0000\u02b2" + + "-\u0001\u0000\u0000\u0000\u02b3\u02b7\u0005\r\u0000\u0000\u02b4\u02b6" + + "\u0005\u0005\u0000\u0000\u02b5\u02b4\u0001\u0000\u0000\u0000\u02b6\u02b9" + + "\u0001\u0000\u0000\u0000\u02b7\u02b5\u0001\u0000\u0000\u0000\u02b7\u02b8" + + "\u0001\u0000\u0000\u0000\u02b8\u02bb\u0001\u0000\u0000\u0000\u02b9\u02b7" + + "\u0001\u0000\u0000\u0000\u02ba\u02bc\u00030\u0018\u0000\u02bb\u02ba\u0001" + + "\u0000\u0000\u0000\u02bb\u02bc\u0001\u0000\u0000\u0000\u02bc\u02d0\u0001" + + "\u0000\u0000\u0000\u02bd\u02bf\u0005\u0005\u0000\u0000\u02be\u02bd\u0001" + + "\u0000\u0000\u0000\u02bf\u02c2\u0001\u0000\u0000\u0000\u02c0\u02be\u0001" + + "\u0000\u0000\u0000\u02c0\u02c1\u0001\u0000\u0000\u0000\u02c1\u02c3\u0001" + + "\u0000\u0000\u0000\u02c2\u02c0\u0001\u0000\u0000\u0000\u02c3\u02c7\u0005" + + "\u001a\u0000\u0000\u02c4\u02c6\u0005\u0005\u0000\u0000\u02c5\u02c4\u0001" + + "\u0000\u0000\u0000\u02c6\u02c9\u0001\u0000\u0000\u0000\u02c7\u02c5\u0001" + + "\u0000\u0000\u0000\u02c7\u02c8\u0001\u0000\u0000\u0000\u02c8\u02cd\u0001" + + "\u0000\u0000\u0000\u02c9\u02c7\u0001\u0000\u0000\u0000\u02ca\u02cc\u0003" + + "&\u0013\u0000\u02cb\u02ca\u0001\u0000\u0000\u0000\u02cc\u02cf\u0001\u0000" + + "\u0000\u0000\u02cd\u02cb\u0001\u0000\u0000\u0000\u02cd\u02ce\u0001\u0000" + + "\u0000\u0000\u02ce\u02d1\u0001\u0000\u0000\u0000\u02cf\u02cd\u0001\u0000" + + "\u0000\u0000\u02d0\u02c0\u0001\u0000\u0000\u0000\u02d0\u02d1\u0001\u0000" + + "\u0000\u0000\u02d1\u02d5\u0001\u0000\u0000\u0000\u02d2\u02d4\u0005\u0005" + + "\u0000\u0000\u02d3\u02d2\u0001\u0000\u0000\u0000\u02d4\u02d7\u0001\u0000" + + "\u0000\u0000\u02d5\u02d3\u0001\u0000\u0000\u0000\u02d5\u02d6\u0001\u0000" + + "\u0000\u0000\u02d6\u02d8\u0001\u0000\u0000\u0000\u02d7\u02d5\u0001\u0000" + + "\u0000\u0000\u02d8\u02d9\u0005\u000e\u0000\u0000\u02d9/\u0001\u0000\u0000" + + "\u0000\u02da\u02de\u00032\u0019\u0000\u02db\u02dd\u0005\u0005\u0000\u0000" + + "\u02dc\u02db\u0001\u0000\u0000\u0000\u02dd\u02e0\u0001\u0000\u0000\u0000" + + "\u02de\u02dc\u0001\u0000\u0000\u0000\u02de\u02df\u0001\u0000\u0000\u0000" + + "\u02df\u02e2\u0001\u0000\u0000\u0000\u02e0\u02de\u0001\u0000\u0000\u0000" + + "\u02e1\u02da\u0001\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000\u0000" + + "\u02e3\u02e1\u0001\u0000\u0000\u0000\u02e3\u02e4\u0001\u0000\u0000\u0000" + + "\u02e4\u02e6\u0001\u0000\u0000\u0000\u02e5\u02e7\u0005\u001a\u0000\u0000" + + "\u02e6\u02e5\u0001\u0000\u0000\u0000\u02e6\u02e7\u0001\u0000\u0000\u0000" + + "\u02e71\u0001\u0000\u0000\u0000\u02e8\u02ea\u0003\u0114\u008a\u0000\u02e9" + + "\u02e8\u0001\u0000\u0000\u0000\u02ea\u02ed\u0001\u0000\u0000\u0000\u02eb" + + "\u02e9\u0001\u0000\u0000\u0000\u02eb\u02ec\u0001\u0000\u0000\u0000\u02ec" + + "\u02ee\u0001\u0000\u0000\u0000\u02ed\u02eb\u0001\u0000\u0000\u0000\u02ee" + + "\u02f6\u0003\u0120\u0090\u0000\u02ef\u02f1\u0005\u0005\u0000\u0000\u02f0" + + "\u02ef\u0001\u0000\u0000\u0000\u02f1\u02f4\u0001\u0000\u0000\u0000\u02f2" + + "\u02f0\u0001\u0000\u0000\u0000\u02f2\u02f3\u0001\u0000\u0000\u0000\u02f3" + + "\u02f5\u0001\u0000\u0000\u0000\u02f4\u02f2\u0001\u0000\u0000\u0000\u02f5" + + "\u02f7\u0003\u009cN\u0000\u02f6\u02f2\u0001\u0000\u0000\u0000\u02f6\u02f7" + + "\u0001\u0000\u0000\u0000\u02f7\u02ff\u0001\u0000\u0000\u0000\u02f8\u02fa" + + "\u0005\u0005\u0000\u0000\u02f9\u02f8\u0001\u0000\u0000\u0000\u02fa\u02fd" + + "\u0001\u0000\u0000\u0000\u02fb\u02f9\u0001\u0000\u0000\u0000\u02fb\u02fc" + + "\u0001\u0000\u0000\u0000\u02fc\u02fe\u0001\u0000\u0000\u0000\u02fd\u02fb" + + "\u0001\u0000\u0000\u0000\u02fe\u0300\u0003$\u0012\u0000\u02ff\u02fb\u0001" + + "\u0000\u0000\u0000\u02ff\u0300\u0001\u0000\u0000\u0000\u0300\u0308\u0001" + + "\u0000\u0000\u0000\u0301\u0303\u0005\u0005\u0000\u0000\u0302\u0301\u0001" + + "\u0000\u0000\u0000\u0303\u0306\u0001\u0000\u0000\u0000\u0304\u0302\u0001" + + "\u0000\u0000\u0000\u0304\u0305\u0001\u0000\u0000\u0000\u0305\u0307\u0001" + + "\u0000\u0000\u0000\u0306\u0304\u0001\u0000\u0000\u0000\u0307\u0309\u0005" + + "\b\u0000\u0000\u0308\u0304\u0001\u0000\u0000\u0000\u0308\u0309\u0001\u0000" + + "\u0000\u0000\u03093\u0001\u0000\u0000\u0000\u030a\u030c\u0003\u00fc~\u0000" + + "\u030b\u030a\u0001\u0000\u0000\u0000\u030b\u030c\u0001\u0000\u0000\u0000" + + "\u030c\u030d\u0001\u0000\u0000\u0000\u030d\u031d\u0005=\u0000\u0000\u030e" + + "\u0310\u0005\u0005\u0000\u0000\u030f\u030e\u0001\u0000\u0000\u0000\u0310" + + "\u0313\u0001\u0000\u0000\u0000\u0311\u030f\u0001\u0000\u0000\u0000\u0311" + + "\u0312\u0001\u0000\u0000\u0000\u0312\u0314\u0001\u0000\u0000\u0000\u0313" + + "\u0311\u0001\u0000\u0000\u0000\u0314\u0318\u0003T*\u0000\u0315\u0317\u0005" + + "\u0005\u0000\u0000\u0316\u0315\u0001\u0000\u0000\u0000\u0317\u031a\u0001" + + "\u0000\u0000\u0000\u0318\u0316\u0001\u0000\u0000\u0000\u0318\u0319\u0001" + + "\u0000\u0000\u0000\u0319\u031b\u0001\u0000\u0000\u0000\u031a\u0318\u0001" + + "\u0000\u0000\u0000\u031b\u031c\u0005\u0007\u0000\u0000\u031c\u031e\u0001" + + "\u0000\u0000\u0000\u031d\u0311\u0001\u0000\u0000\u0000\u031d\u031e\u0001" + + "\u0000\u0000\u0000\u031e\u0326\u0001\u0000\u0000\u0000\u031f\u0321\u0005" + + "\u0005\u0000\u0000\u0320\u031f\u0001\u0000\u0000\u0000\u0321\u0324\u0001" + + "\u0000\u0000\u0000\u0322\u0320\u0001\u0000\u0000\u0000\u0322\u0323\u0001" + + "\u0000\u0000\u0000\u0323\u0325\u0001\u0000\u0000\u0000\u0324\u0322\u0001" + + "\u0000\u0000\u0000\u0325\u0327\u0003P(\u0000\u0326\u0322\u0001\u0000\u0000" + + "\u0000\u0326\u0327\u0001\u0000\u0000\u0000\u0327\u0337\u0001\u0000\u0000" + + "\u0000\u0328\u032a\u0005\u0005\u0000\u0000\u0329\u0328\u0001\u0000\u0000" + + "\u0000\u032a\u032d\u0001\u0000\u0000\u0000\u032b\u0329\u0001\u0000\u0000" + + "\u0000\u032b\u032c\u0001\u0000\u0000\u0000\u032c\u032e\u0001\u0000\u0000" + + "\u0000\u032d\u032b\u0001\u0000\u0000\u0000\u032e\u0332\u0003<\u001e\u0000" + + "\u032f\u0331\u0005\u0005\u0000\u0000\u0330\u032f\u0001\u0000\u0000\u0000" + + "\u0331\u0334\u0001\u0000\u0000\u0000\u0332\u0330\u0001\u0000\u0000\u0000" + + "\u0332\u0333\u0001\u0000\u0000\u0000\u0333\u0335\u0001\u0000\u0000\u0000" + + "\u0334\u0332\u0001\u0000\u0000\u0000\u0335\u0336\u0005\u0007\u0000\u0000" + + "\u0336\u0338\u0001\u0000\u0000\u0000\u0337\u032b\u0001\u0000\u0000\u0000" + + "\u0337\u0338\u0001\u0000\u0000\u0000\u0338\u0340\u0001\u0000\u0000\u0000" + + "\u0339\u033b\u0005\u0005\u0000\u0000\u033a\u0339\u0001\u0000\u0000\u0000" + + "\u033b\u033e\u0001\u0000\u0000\u0000\u033c\u033a\u0001\u0000\u0000\u0000" + + "\u033c\u033d\u0001\u0000\u0000\u0000\u033d\u033f\u0001\u0000\u0000\u0000" + + "\u033e\u033c\u0001\u0000\u0000\u0000\u033f\u0341\u0003\u011e\u008f\u0000" + + "\u0340\u033c\u0001\u0000\u0000\u0000\u0340\u0341\u0001\u0000\u0000\u0000" + + "\u0341\u0345\u0001\u0000\u0000\u0000\u0342\u0344\u0005\u0005\u0000\u0000" + + "\u0343\u0342\u0001\u0000\u0000\u0000\u0344\u0347\u0001\u0000\u0000\u0000" + + "\u0345\u0343\u0001\u0000\u0000\u0000\u0345\u0346\u0001\u0000\u0000\u0000" + + "\u0346\u0348\u0001\u0000\u0000\u0000\u0347\u0345\u0001\u0000\u0000\u0000" + + "\u0348\u0357\u00036\u001b\u0000\u0349\u034b\u0005\u0005\u0000\u0000\u034a" + + "\u0349\u0001\u0000\u0000\u0000\u034b\u034e\u0001\u0000\u0000\u0000\u034c" + + "\u034a\u0001\u0000\u0000\u0000\u034c\u034d\u0001\u0000\u0000\u0000\u034d" + + "\u034f\u0001\u0000\u0000\u0000\u034e\u034c\u0001\u0000\u0000\u0000\u034f" + + "\u0353\u0005\u0019\u0000\u0000\u0350\u0352\u0005\u0005\u0000\u0000\u0351" + + "\u0350\u0001\u0000\u0000\u0000\u0352\u0355\u0001\u0000\u0000\u0000\u0353" + + "\u0351\u0001\u0000\u0000\u0000\u0353\u0354\u0001\u0000\u0000\u0000\u0354" + + "\u0356\u0001\u0000\u0000\u0000\u0355\u0353\u0001\u0000\u0000\u0000\u0356" + + "\u0358\u0003T*\u0000\u0357\u034c\u0001\u0000\u0000\u0000\u0357\u0358\u0001" + + "\u0000\u0000\u0000\u0358\u0360\u0001\u0000\u0000\u0000\u0359\u035b\u0005" + + "\u0005\u0000\u0000\u035a\u0359\u0001\u0000\u0000\u0000\u035b\u035e\u0001" + + "\u0000\u0000\u0000\u035c\u035a\u0001\u0000\u0000\u0000\u035c\u035d\u0001" + + "\u0000\u0000\u0000\u035d\u035f\u0001\u0000\u0000\u0000\u035e\u035c\u0001" + + "\u0000\u0000\u0000\u035f\u0361\u0003h4\u0000\u0360\u035c\u0001\u0000\u0000" + + "\u0000\u0360\u0361\u0001\u0000\u0000\u0000\u0361\u0369\u0001\u0000\u0000" + + "\u0000\u0362\u0364\u0005\u0005\u0000\u0000\u0363\u0362\u0001\u0000\u0000" + + "\u0000\u0364\u0367\u0001\u0000\u0000\u0000\u0365\u0363\u0001\u0000\u0000" + + "\u0000\u0365\u0366\u0001\u0000\u0000\u0000\u0366\u0368\u0001\u0000\u0000" + + "\u0000\u0367\u0365\u0001\u0000\u0000\u0000\u0368\u036a\u0003>\u001f\u0000" + + "\u0369\u0365\u0001\u0000\u0000\u0000\u0369\u036a\u0001\u0000\u0000\u0000" + + "\u036a5\u0001\u0000\u0000\u0000\u036b\u0377\u0005\t\u0000\u0000\u036c" + + "\u0371\u00038\u001c\u0000\u036d\u036e\u0005\b\u0000\u0000\u036e\u0370" + + "\u00038\u001c\u0000\u036f\u036d\u0001\u0000\u0000\u0000\u0370\u0373\u0001" + + "\u0000\u0000\u0000\u0371\u036f\u0001\u0000\u0000\u0000\u0371\u0372\u0001" + + "\u0000\u0000\u0000\u0372\u0375\u0001\u0000\u0000\u0000\u0373\u0371\u0001" + + "\u0000\u0000\u0000\u0374\u0376\u0005\b\u0000\u0000\u0375\u0374\u0001\u0000" + + "\u0000\u0000\u0375\u0376\u0001\u0000\u0000\u0000\u0376\u0378\u0001\u0000" + + "\u0000\u0000\u0377\u036c\u0001\u0000\u0000\u0000\u0377\u0378\u0001\u0000" + + "\u0000\u0000\u0378\u0379\u0001\u0000\u0000\u0000\u0379\u037a\u0005\n\u0000" + + "\u0000\u037a7\u0001\u0000\u0000\u0000\u037b\u037d\u0003\u00fc~\u0000\u037c" + + "\u037b\u0001\u0000\u0000\u0000\u037c\u037d\u0001\u0000\u0000\u0000\u037d" + + "\u037e\u0001\u0000\u0000\u0000\u037e\u0381\u0003:\u001d\u0000\u037f\u0380" + + "\u0005\u001b\u0000\u0000\u0380\u0382\u0003v;\u0000\u0381\u037f\u0001\u0000" + + "\u0000\u0000\u0381\u0382\u0001\u0000\u0000\u0000\u03829\u0001\u0000\u0000" + + "\u0000\u0383\u0384\u0003\u0120\u0090\u0000\u0384\u0385\u0005\u0019\u0000" + + "\u0000\u0385\u0386\u0003T*\u0000\u0386;\u0001\u0000\u0000\u0000\u0387" + + "\u0389\u0003V+\u0000\u0388\u0387\u0001\u0000\u0000\u0000\u0388\u0389\u0001" + + "\u0000\u0000\u0000\u0389\u038d\u0001\u0000\u0000\u0000\u038a\u038e\u0003" + + "X,\u0000\u038b\u038e\u0003Z-\u0000\u038c\u038e\u0003\\.\u0000\u038d\u038a" + + "\u0001\u0000\u0000\u0000\u038d\u038b\u0001\u0000\u0000\u0000\u038d\u038c" + + "\u0001\u0000\u0000\u0000\u038e=\u0001\u0000\u0000\u0000\u038f\u0399\u0003" + + "l6\u0000\u0390\u0394\u0005\u001b\u0000\u0000\u0391\u0393\u0005\u0005\u0000" + + "\u0000\u0392\u0391\u0001\u0000\u0000\u0000\u0393\u0396\u0001\u0000\u0000" + + "\u0000\u0394\u0392\u0001\u0000\u0000\u0000\u0394\u0395\u0001\u0000\u0000" + + "\u0000\u0395\u0397\u0001\u0000\u0000\u0000\u0396\u0394\u0001\u0000\u0000" + + "\u0000\u0397\u0399\u0003v;\u0000\u0398\u038f\u0001\u0000\u0000\u0000\u0398" + + "\u0390\u0001\u0000\u0000\u0000\u0399?\u0001\u0000\u0000\u0000\u039a\u039c" + + "\u0003\u00fc~\u0000\u039b\u039a\u0001\u0000\u0000\u0000\u039b\u039c\u0001" + + "\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000\u0000\u039d\u03a1\u0005" + + ">\u0000\u0000\u039e\u03a0\u0005\u0005\u0000\u0000\u039f\u039e\u0001\u0000" + + "\u0000\u0000\u03a0\u03a3\u0001\u0000\u0000\u0000\u03a1\u039f\u0001\u0000" + + "\u0000\u0000\u03a1\u03a2\u0001\u0000\u0000\u0000\u03a2\u03a4\u0001\u0000" + + "\u0000\u0000\u03a3\u03a1\u0001\u0000\u0000\u0000\u03a4\u03ac\u0003\u0120" + + "\u0090\u0000\u03a5\u03a7\u0005\u0005\u0000\u0000\u03a6\u03a5\u0001\u0000" + + "\u0000\u0000\u03a7\u03aa\u0001\u0000\u0000\u0000\u03a8\u03a6\u0001\u0000" + + "\u0000\u0000\u03a8\u03a9\u0001\u0000\u0000\u0000\u03a9\u03ab\u0001\u0000" + + "\u0000\u0000\u03aa\u03a8\u0001\u0000\u0000\u0000\u03ab\u03ad\u0003\u0016" + + "\u000b\u0000\u03ac\u03a8\u0001\u0000\u0000\u0000\u03ac\u03ad\u0001\u0000" + + "\u0000\u0000\u03ad\u03bc\u0001\u0000\u0000\u0000\u03ae\u03b0\u0005\u0005" + + "\u0000\u0000\u03af\u03ae\u0001\u0000\u0000\u0000\u03b0\u03b3\u0001\u0000" + + "\u0000\u0000\u03b1\u03af\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001\u0000" + + "\u0000\u0000\u03b2\u03b4\u0001\u0000\u0000\u0000\u03b3\u03b1\u0001\u0000" + + "\u0000\u0000\u03b4\u03b8\u0005\u0019\u0000\u0000\u03b5\u03b7\u0005\u0005" + + "\u0000\u0000\u03b6\u03b5\u0001\u0000\u0000\u0000\u03b7\u03ba\u0001\u0000" + + "\u0000\u0000\u03b8\u03b6\u0001\u0000\u0000\u0000\u03b8\u03b9\u0001\u0000" + + "\u0000\u0000\u03b9\u03bb\u0001\u0000\u0000\u0000\u03ba\u03b8\u0001\u0000" + + "\u0000\u0000\u03bb\u03bd\u0003\u001c\u000e\u0000\u03bc\u03b1\u0001\u0000" + + "\u0000\u0000\u03bc\u03bd\u0001\u0000\u0000\u0000\u03bd\u03c5\u0001\u0000" + + "\u0000\u0000\u03be\u03c0\u0005\u0005\u0000\u0000\u03bf\u03be\u0001\u0000" + + "\u0000\u0000\u03c0\u03c3\u0001\u0000\u0000\u0000\u03c1\u03bf\u0001\u0000" + + "\u0000\u0000\u03c1\u03c2\u0001\u0000\u0000\u0000\u03c2\u03c4\u0001\u0000" + + "\u0000\u0000\u03c3\u03c1\u0001\u0000\u0000\u0000\u03c4\u03c6\u0003$\u0012" + + "\u0000\u03c5\u03c1\u0001\u0000\u0000\u0000\u03c5\u03c6\u0001\u0000\u0000" + + "\u0000\u03c6A\u0001\u0000\u0000\u0000\u03c7\u03c9\u0003\u00fc~\u0000\u03c8" + + "\u03c7\u0001\u0000\u0000\u0000\u03c8\u03c9\u0001\u0000\u0000\u0000\u03c9" + + "\u03ca\u0001\u0000\u0000\u0000\u03ca\u03ce\u0005D\u0000\u0000\u03cb\u03cd" + + "\u0005\u0005\u0000\u0000\u03cc\u03cb\u0001\u0000\u0000\u0000\u03cd\u03d0" + + "\u0001\u0000\u0000\u0000\u03ce\u03cc\u0001\u0000\u0000\u0000\u03ce\u03cf" + + "\u0001\u0000\u0000\u0000\u03cf\u03d2\u0001\u0000\u0000\u0000\u03d0\u03ce" + + "\u0001\u0000\u0000\u0000\u03d1\u03d3\u0003\u00fc~\u0000\u03d2\u03d1\u0001" + + "\u0000\u0000\u0000\u03d2\u03d3\u0001\u0000\u0000\u0000\u03d3\u03d4\u0001" + + "\u0000\u0000\u0000\u03d4\u03dc\u0005>\u0000\u0000\u03d5\u03d7\u0005\u0005" + + "\u0000\u0000\u03d6\u03d5\u0001\u0000\u0000\u0000\u03d7\u03da\u0001\u0000" + + "\u0000\u0000\u03d8\u03d6\u0001\u0000\u0000\u0000\u03d8\u03d9\u0001\u0000" + + "\u0000\u0000\u03d9\u03db\u0001\u0000\u0000\u0000\u03da\u03d8\u0001\u0000" + + "\u0000\u0000\u03db\u03dd\u0003\u0120\u0090\u0000\u03dc\u03d8\u0001\u0000" + + "\u0000\u0000\u03dc\u03dd\u0001\u0000\u0000\u0000\u03dd\u03ec\u0001\u0000" + + "\u0000\u0000\u03de\u03e0\u0005\u0005\u0000\u0000\u03df\u03de\u0001\u0000" + + "\u0000\u0000\u03e0\u03e3\u0001\u0000\u0000\u0000\u03e1\u03df\u0001\u0000" + + "\u0000\u0000\u03e1\u03e2\u0001\u0000\u0000\u0000\u03e2\u03e4\u0001\u0000" + + "\u0000\u0000\u03e3\u03e1\u0001\u0000\u0000\u0000\u03e4\u03e8\u0005\u0019" + + "\u0000\u0000\u03e5\u03e7\u0005\u0005\u0000\u0000\u03e6\u03e5\u0001\u0000" + + "\u0000\u0000\u03e7\u03ea\u0001\u0000\u0000\u0000\u03e8\u03e6\u0001\u0000" + + "\u0000\u0000\u03e8\u03e9\u0001\u0000\u0000\u0000\u03e9\u03eb\u0001\u0000" + + "\u0000\u0000\u03ea\u03e8\u0001\u0000\u0000\u0000\u03eb\u03ed\u0003\u001c" + + "\u000e\u0000\u03ec\u03e1\u0001\u0000\u0000\u0000\u03ec\u03ed\u0001\u0000" + + "\u0000\u0000\u03ed\u03f5\u0001\u0000\u0000\u0000\u03ee\u03f0\u0005\u0005" + + "\u0000\u0000\u03ef\u03ee\u0001\u0000\u0000\u0000\u03f0\u03f3\u0001\u0000" + + "\u0000\u0000\u03f1\u03ef\u0001\u0000\u0000\u0000\u03f1\u03f2\u0001\u0000" + + "\u0000\u0000\u03f2\u03f4\u0001\u0000\u0000\u0000\u03f3\u03f1\u0001\u0000" + + "\u0000\u0000\u03f4\u03f6\u0003$\u0012\u0000\u03f5\u03f1\u0001\u0000\u0000" + + "\u0000\u03f5\u03f6\u0001\u0000\u0000\u0000\u03f6C\u0001\u0000\u0000\u0000" + + "\u03f7\u03f9\u0003\u00fc~\u0000\u03f8\u03f7\u0001\u0000\u0000\u0000\u03f8" + + "\u03f9\u0001\u0000\u0000\u0000\u03f9\u03fa\u0001\u0000\u0000\u0000\u03fa" + + "\u0402\u0007\u0001\u0000\u0000\u03fb\u03fd\u0005\u0005\u0000\u0000\u03fc" + + "\u03fb\u0001\u0000\u0000\u0000\u03fd\u0400\u0001\u0000\u0000\u0000\u03fe" + + "\u03fc\u0001\u0000\u0000\u0000\u03fe\u03ff\u0001\u0000\u0000\u0000\u03ff" + + "\u0401\u0001\u0000\u0000\u0000\u0400\u03fe\u0001\u0000\u0000\u0000\u0401" + + "\u0403\u0003P(\u0000\u0402\u03fe\u0001\u0000\u0000\u0000\u0402\u0403\u0001" + + "\u0000\u0000\u0000\u0403\u0413\u0001\u0000\u0000\u0000\u0404\u0406\u0005" + + "\u0005\u0000\u0000\u0405\u0404\u0001\u0000\u0000\u0000\u0406\u0409\u0001" + + "\u0000\u0000\u0000\u0407\u0405\u0001\u0000\u0000\u0000\u0407\u0408\u0001" + + "\u0000\u0000\u0000\u0408\u040a\u0001\u0000\u0000\u0000\u0409\u0407\u0001" + + "\u0000\u0000\u0000\u040a\u040e\u0003T*\u0000\u040b\u040d\u0005\u0005\u0000" + + "\u0000\u040c\u040b\u0001\u0000\u0000\u0000\u040d\u0410\u0001\u0000\u0000" + + "\u0000\u040e\u040c\u0001\u0000\u0000\u0000\u040e\u040f\u0001\u0000\u0000" + + "\u0000\u040f\u0411\u0001\u0000\u0000\u0000\u0410\u040e\u0001\u0000\u0000" + + "\u0000\u0411\u0412\u0005\u0007\u0000\u0000\u0412\u0414\u0001\u0000\u0000" + + "\u0000\u0413\u0407\u0001\u0000\u0000\u0000\u0413\u0414\u0001\u0000\u0000" + + "\u0000\u0414\u0418\u0001\u0000\u0000\u0000\u0415\u0417\u0005\u0005\u0000" + + "\u0000\u0416\u0415\u0001\u0000\u0000\u0000\u0417\u041a\u0001\u0000\u0000" + + "\u0000\u0418\u0416\u0001\u0000\u0000\u0000\u0418\u0419\u0001\u0000\u0000" + + "\u0000\u0419\u041d\u0001\u0000\u0000\u0000\u041a\u0418\u0001\u0000\u0000" + + "\u0000\u041b\u041e\u0003F#\u0000\u041c\u041e\u0003H$\u0000\u041d\u041b" + + "\u0001\u0000\u0000\u0000\u041d\u041c\u0001\u0000\u0000\u0000\u041e\u0426" + + "\u0001\u0000\u0000\u0000\u041f\u0421\u0005\u0005\u0000\u0000\u0420\u041f" + + "\u0001\u0000\u0000\u0000\u0421\u0424\u0001\u0000\u0000\u0000\u0422\u0420" + + "\u0001\u0000\u0000\u0000\u0422\u0423\u0001\u0000\u0000\u0000\u0423\u0425" + + "\u0001\u0000\u0000\u0000\u0424\u0422\u0001\u0000\u0000\u0000\u0425\u0427" + + "\u0003h4\u0000\u0426\u0422\u0001\u0000\u0000\u0000\u0426\u0427\u0001\u0000" + + "\u0000\u0000\u0427\u0436\u0001\u0000\u0000\u0000\u0428\u042a\u0005\u0005" + + "\u0000\u0000\u0429\u0428\u0001\u0000\u0000\u0000\u042a\u042d\u0001\u0000" + + "\u0000\u0000\u042b\u0429\u0001\u0000\u0000\u0000\u042b\u042c\u0001\u0000" + + "\u0000\u0000\u042c\u042e\u0001\u0000\u0000\u0000\u042d\u042b\u0001\u0000" + + "\u0000\u0000\u042e\u0432\u0007\u0002\u0000\u0000\u042f\u0431\u0005\u0005" + + "\u0000\u0000\u0430\u042f\u0001\u0000\u0000\u0000\u0431\u0434\u0001\u0000" + + "\u0000\u0000\u0432\u0430\u0001\u0000\u0000\u0000\u0432\u0433\u0001\u0000" + + "\u0000\u0000\u0433\u0435\u0001\u0000\u0000\u0000\u0434\u0432\u0001\u0000" + + "\u0000\u0000\u0435\u0437\u0003v;\u0000\u0436\u042b\u0001\u0000\u0000\u0000" + + "\u0436\u0437\u0001\u0000\u0000\u0000\u0437\u0450\u0001\u0000\u0000\u0000" + + "\u0438\u043a\u0005\u0005\u0000\u0000\u0439\u0438\u0001\u0000\u0000\u0000" + + "\u043a\u043d\u0001\u0000\u0000\u0000\u043b\u0439\u0001\u0000\u0000\u0000" + + "\u043b\u043c\u0001\u0000\u0000\u0000\u043c\u043e\u0001\u0000\u0000\u0000" + + "\u043d\u043b\u0001\u0000\u0000\u0000\u043e\u0442\u0003J%\u0000\u043f\u0440" + + "\u0003\u0122\u0091\u0000\u0440\u0441\u0003L&\u0000\u0441\u0443\u0001\u0000" + + "\u0000\u0000\u0442\u043f\u0001\u0000\u0000\u0000\u0442\u0443\u0001\u0000" + + "\u0000\u0000\u0443\u0451\u0001\u0000\u0000\u0000\u0444\u0446\u0005\u0005" + + "\u0000\u0000\u0445\u0444\u0001\u0000\u0000\u0000\u0446\u0449\u0001\u0000" + + "\u0000\u0000\u0447\u0445\u0001\u0000\u0000\u0000\u0447\u0448\u0001\u0000" + + "\u0000\u0000\u0448\u044a\u0001\u0000\u0000\u0000\u0449\u0447\u0001\u0000" + + "\u0000\u0000\u044a\u044e\u0003L&\u0000\u044b\u044c\u0003\u0122\u0091\u0000" + + "\u044c\u044d\u0003J%\u0000\u044d\u044f\u0001\u0000\u0000\u0000\u044e\u044b" + + "\u0001\u0000\u0000\u0000\u044e\u044f\u0001\u0000\u0000\u0000\u044f\u0451" + + "\u0001\u0000\u0000\u0000\u0450\u043b\u0001\u0000\u0000\u0000\u0450\u0447" + + "\u0001\u0000\u0000\u0000\u0450\u0451\u0001\u0000\u0000\u0000\u0451E\u0001" + + "\u0000\u0000\u0000\u0452\u0453\u0005\t\u0000\u0000\u0453\u0458\u0003H" + + "$\u0000\u0454\u0455\u0005\b\u0000\u0000\u0455\u0457\u0003H$\u0000\u0456" + + "\u0454\u0001\u0000\u0000\u0000\u0457\u045a\u0001\u0000\u0000\u0000\u0458" + + "\u0456\u0001\u0000\u0000\u0000\u0458\u0459\u0001\u0000\u0000\u0000\u0459" + + "\u045b\u0001\u0000\u0000\u0000\u045a\u0458\u0001\u0000\u0000\u0000\u045b" + + "\u045c\u0005\n\u0000\u0000\u045cG\u0001\u0000\u0000\u0000\u045d\u0460" + + "\u0003\u0120\u0090\u0000\u045e\u045f\u0005\u0019\u0000\u0000\u045f\u0461" + + "\u0003T*\u0000\u0460\u045e\u0001\u0000\u0000\u0000\u0460\u0461\u0001\u0000" + + "\u0000\u0000\u0461I\u0001\u0000\u0000\u0000\u0462\u0464\u0003\u00fc~\u0000" + + "\u0463\u0462\u0001\u0000\u0000\u0000\u0463\u0464\u0001\u0000\u0000\u0000" + + "\u0464\u0465\u0001\u0000\u0000\u0000\u0465\u0494\u0005a\u0000\u0000\u0466" + + "\u0468\u0003\u00fc~\u0000\u0467\u0466\u0001\u0000\u0000\u0000\u0467\u0468" + + "\u0001\u0000\u0000\u0000\u0468\u0469\u0001\u0000\u0000\u0000\u0469\u046d" + + "\u0005a\u0000\u0000\u046a\u046c\u0005\u0005\u0000\u0000\u046b\u046a\u0001" + + "\u0000\u0000\u0000\u046c\u046f\u0001\u0000\u0000\u0000\u046d\u046b\u0001" + + "\u0000\u0000\u0000\u046d\u046e\u0001\u0000\u0000\u0000\u046e\u0470\u0001" + + "\u0000\u0000\u0000\u046f\u046d\u0001\u0000\u0000\u0000\u0470\u0471\u0005" + + "\t\u0000\u0000\u0471\u0480\u0005\n\u0000\u0000\u0472\u0474\u0005\u0005" + + "\u0000\u0000\u0473\u0472\u0001\u0000\u0000\u0000\u0474\u0477\u0001\u0000" + + "\u0000\u0000\u0475\u0473\u0001\u0000\u0000\u0000\u0475\u0476\u0001\u0000" + + "\u0000\u0000\u0476\u0478\u0001\u0000\u0000\u0000\u0477\u0475\u0001\u0000" + + "\u0000\u0000\u0478\u047c\u0005\u0019\u0000\u0000\u0479\u047b\u0005\u0005" + + "\u0000\u0000\u047a\u0479\u0001\u0000\u0000\u0000\u047b\u047e\u0001\u0000" + + "\u0000\u0000\u047c\u047a\u0001\u0000\u0000\u0000\u047c\u047d\u0001\u0000" + + "\u0000\u0000\u047d\u047f\u0001\u0000\u0000\u0000\u047e\u047c\u0001\u0000" + + "\u0000\u0000\u047f\u0481\u0003T*\u0000\u0480\u0475\u0001\u0000\u0000\u0000" + + "\u0480\u0481\u0001\u0000\u0000\u0000\u0481\u0485\u0001\u0000\u0000\u0000" + + "\u0482\u0484\u0005\u0005\u0000\u0000\u0483\u0482\u0001\u0000\u0000\u0000" + + "\u0484\u0487\u0001\u0000\u0000\u0000\u0485\u0483\u0001\u0000\u0000\u0000" + + "\u0485\u0486\u0001\u0000\u0000\u0000\u0486\u0491\u0001\u0000\u0000\u0000" + + "\u0487\u0485\u0001\u0000\u0000\u0000\u0488\u0492\u0003l6\u0000\u0489\u048d" + + "\u0005\u001b\u0000\u0000\u048a\u048c\u0005\u0005\u0000\u0000\u048b\u048a" + + "\u0001\u0000\u0000\u0000\u048c\u048f\u0001\u0000\u0000\u0000\u048d\u048b" + + "\u0001\u0000\u0000\u0000\u048d\u048e\u0001\u0000\u0000\u0000\u048e\u0490" + + "\u0001\u0000\u0000\u0000\u048f\u048d\u0001\u0000\u0000\u0000\u0490\u0492" + + "\u0003v;\u0000\u0491\u0488\u0001\u0000\u0000\u0000\u0491\u0489\u0001\u0000" + + "\u0000\u0000\u0492\u0494\u0001\u0000\u0000\u0000\u0493\u0463\u0001\u0000" + + "\u0000\u0000\u0493\u0467\u0001\u0000\u0000\u0000\u0494K\u0001\u0000\u0000" + + "\u0000\u0495\u0497\u0003\u00fc~\u0000\u0496\u0495\u0001\u0000\u0000\u0000" + + "\u0496\u0497\u0001\u0000\u0000\u0000\u0497\u0498\u0001\u0000\u0000\u0000" + + "\u0498\u04b9\u0005b\u0000\u0000\u0499\u049b\u0003\u00fc~\u0000\u049a\u0499" + + "\u0001\u0000\u0000\u0000\u049a\u049b\u0001\u0000\u0000\u0000\u049b\u049c" + + "\u0001\u0000\u0000\u0000\u049c\u04a0\u0005b\u0000\u0000\u049d\u049f\u0005" + + "\u0005\u0000\u0000\u049e\u049d\u0001\u0000\u0000\u0000\u049f\u04a2\u0001" + + "\u0000\u0000\u0000\u04a0\u049e\u0001\u0000\u0000\u0000\u04a0\u04a1\u0001" + + "\u0000\u0000\u0000\u04a1\u04a3\u0001\u0000\u0000\u0000\u04a2\u04a0\u0001" + + "\u0000\u0000\u0000\u04a3\u04a8\u0005\t\u0000\u0000\u04a4\u04a7\u0003\u0114" + + "\u008a\u0000\u04a5\u04a7\u0003\u010e\u0087\u0000\u04a6\u04a4\u0001\u0000" + + "\u0000\u0000\u04a6\u04a5\u0001\u0000\u0000\u0000\u04a7\u04aa\u0001\u0000" + + "\u0000\u0000\u04a8\u04a6\u0001\u0000\u0000\u0000\u04a8\u04a9\u0001\u0000" + + "\u0000\u0000\u04a9\u04ad\u0001\u0000\u0000\u0000\u04aa\u04a8\u0001\u0000" + + "\u0000\u0000\u04ab\u04ae\u0003\u0120\u0090\u0000\u04ac\u04ae\u0003:\u001d" + + "\u0000\u04ad\u04ab\u0001\u0000\u0000\u0000\u04ad\u04ac\u0001\u0000\u0000" + + "\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af\u04b3\u0005\n\u0000\u0000" + + "\u04b0\u04b2\u0005\u0005\u0000\u0000\u04b1\u04b0\u0001\u0000\u0000\u0000" + + "\u04b2\u04b5\u0001\u0000\u0000\u0000\u04b3\u04b1\u0001\u0000\u0000\u0000" + + "\u04b3\u04b4\u0001\u0000\u0000\u0000\u04b4\u04b6\u0001\u0000\u0000\u0000" + + "\u04b5\u04b3\u0001\u0000\u0000\u0000\u04b6\u04b7\u0003>\u001f\u0000\u04b7" + + "\u04b9\u0001\u0000\u0000\u0000\u04b8\u0496\u0001\u0000\u0000\u0000\u04b8" + + "\u049a\u0001\u0000\u0000\u0000\u04b9M\u0001\u0000\u0000\u0000\u04ba\u04bc" + + "\u0003\u00fc~\u0000\u04bb\u04ba\u0001\u0000\u0000\u0000\u04bb\u04bc\u0001" + + "\u0000\u0000\u0000\u04bc\u04bd\u0001\u0000\u0000\u0000\u04bd\u04c1\u0005" + + "A\u0000\u0000\u04be\u04c0\u0005\u0005\u0000\u0000\u04bf\u04be\u0001\u0000" + + "\u0000\u0000\u04c0\u04c3\u0001\u0000\u0000\u0000\u04c1\u04bf\u0001\u0000" + + "\u0000\u0000\u04c1\u04c2\u0001\u0000\u0000\u0000\u04c2\u04c4\u0001\u0000" + + "\u0000\u0000\u04c3\u04c1\u0001\u0000\u0000\u0000\u04c4\u04cc\u0003\u0120" + + "\u0090\u0000\u04c5\u04c7\u0005\u0005\u0000\u0000\u04c6\u04c5\u0001\u0000" + + "\u0000\u0000\u04c7\u04ca\u0001\u0000\u0000\u0000\u04c8\u04c6\u0001\u0000" + + "\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000\u0000\u04c9\u04cb\u0001\u0000" + + "\u0000\u0000\u04ca\u04c8\u0001\u0000\u0000\u0000\u04cb\u04cd\u0003P(\u0000" + + "\u04cc\u04c8\u0001\u0000\u0000\u0000\u04cc\u04cd\u0001\u0000\u0000\u0000" + + "\u04cd\u04d1\u0001\u0000\u0000\u0000\u04ce\u04d0\u0005\u0005\u0000\u0000" + + "\u04cf\u04ce\u0001\u0000\u0000\u0000\u04d0\u04d3\u0001\u0000\u0000\u0000" + + "\u04d1\u04cf\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000\u0000\u0000" + + "\u04d2\u04d4\u0001\u0000\u0000\u0000\u04d3\u04d1\u0001\u0000\u0000\u0000" + + "\u04d4\u04d8\u0005\u001b\u0000\u0000\u04d5\u04d7\u0005\u0005\u0000\u0000" + + "\u04d6\u04d5\u0001\u0000\u0000\u0000\u04d7\u04da\u0001\u0000\u0000\u0000" + + "\u04d8\u04d6\u0001\u0000\u0000\u0000\u04d8\u04d9\u0001\u0000\u0000\u0000" + + "\u04d9\u04db\u0001\u0000\u0000\u0000\u04da\u04d8\u0001\u0000\u0000\u0000" + + "\u04db\u04dc\u0003T*\u0000\u04dcO\u0001\u0000\u0000\u0000\u04dd\u04e1" + + "\u0005+\u0000\u0000\u04de\u04e0\u0005\u0005\u0000\u0000\u04df\u04de\u0001" + + "\u0000\u0000\u0000\u04e0\u04e3\u0001\u0000\u0000\u0000\u04e1\u04df\u0001" + + "\u0000\u0000\u0000\u04e1\u04e2\u0001\u0000\u0000\u0000\u04e2\u04e4\u0001" + + "\u0000\u0000\u0000\u04e3\u04e1\u0001\u0000\u0000\u0000\u04e4\u04f5\u0003" + + "R)\u0000\u04e5\u04e7\u0005\u0005\u0000\u0000\u04e6\u04e5\u0001\u0000\u0000" + + "\u0000\u04e7\u04ea\u0001\u0000\u0000\u0000\u04e8\u04e6\u0001\u0000\u0000" + + "\u0000\u04e8\u04e9\u0001\u0000\u0000\u0000\u04e9\u04eb\u0001\u0000\u0000" + + "\u0000\u04ea\u04e8\u0001\u0000\u0000\u0000\u04eb\u04ef\u0005\b\u0000\u0000" + + "\u04ec\u04ee\u0005\u0005\u0000\u0000\u04ed\u04ec\u0001\u0000\u0000\u0000" + + "\u04ee\u04f1\u0001\u0000\u0000\u0000\u04ef\u04ed\u0001\u0000\u0000\u0000" + + "\u04ef\u04f0\u0001\u0000\u0000\u0000\u04f0\u04f2\u0001\u0000\u0000\u0000" + + "\u04f1\u04ef\u0001\u0000\u0000\u0000\u04f2\u04f4\u0003R)\u0000\u04f3\u04e8" + + "\u0001\u0000\u0000\u0000\u04f4\u04f7\u0001\u0000\u0000\u0000\u04f5\u04f3" + + "\u0001\u0000\u0000\u0000\u04f5\u04f6\u0001\u0000\u0000\u0000\u04f6\u04ff" + + "\u0001\u0000\u0000\u0000\u04f7\u04f5\u0001\u0000\u0000\u0000\u04f8\u04fa" + + "\u0005\u0005\u0000\u0000\u04f9\u04f8\u0001\u0000\u0000\u0000\u04fa\u04fd" + + "\u0001\u0000\u0000\u0000\u04fb\u04f9\u0001\u0000\u0000\u0000\u04fb\u04fc" + + "\u0001\u0000\u0000\u0000\u04fc\u04fe\u0001\u0000\u0000\u0000\u04fd\u04fb" + + "\u0001\u0000\u0000\u0000\u04fe\u0500\u0005\b\u0000\u0000\u04ff\u04fb\u0001" + + "\u0000\u0000\u0000\u04ff\u0500\u0001\u0000\u0000\u0000\u0500\u0504\u0001" + + "\u0000\u0000\u0000\u0501\u0503\u0005\u0005\u0000\u0000\u0502\u0501\u0001" + + "\u0000\u0000\u0000\u0503\u0506\u0001\u0000\u0000\u0000\u0504\u0502\u0001" + + "\u0000\u0000\u0000\u0504\u0505\u0001\u0000\u0000\u0000\u0505\u0507\u0001" + + "\u0000\u0000\u0000\u0506\u0504\u0001\u0000\u0000\u0000\u0507\u0508\u0005" + + ",\u0000\u0000\u0508Q\u0001\u0000\u0000\u0000\u0509\u050b\u0003\u00fc~" + + "\u0000\u050a\u0509\u0001\u0000\u0000\u0000\u050a\u050b\u0001\u0000\u0000" + + "\u0000\u050b\u050f\u0001\u0000\u0000\u0000\u050c\u050e\u0005\u0005\u0000" + + "\u0000\u050d\u050c\u0001\u0000\u0000\u0000\u050e\u0511\u0001\u0000\u0000" + + "\u0000\u050f\u050d\u0001\u0000\u0000\u0000\u050f\u0510\u0001\u0000\u0000" + + "\u0000\u0510\u0514\u0001\u0000\u0000\u0000\u0511\u050f\u0001\u0000\u0000" + + "\u0000\u0512\u0515\u0003\u0120\u0090\u0000\u0513\u0515\u0005\u000f\u0000" + + "\u0000\u0514\u0512\u0001\u0000\u0000\u0000\u0514\u0513\u0001\u0000\u0000" + + "\u0000\u0515\u0524\u0001\u0000\u0000\u0000\u0516\u0518\u0005\u0005\u0000" + + "\u0000\u0517\u0516\u0001\u0000\u0000\u0000\u0518\u051b\u0001\u0000\u0000" + + "\u0000\u0519\u0517\u0001\u0000\u0000\u0000\u0519\u051a\u0001\u0000\u0000" + + "\u0000\u051a\u051c\u0001\u0000\u0000\u0000\u051b\u0519\u0001\u0000\u0000" + + "\u0000\u051c\u0520\u0005\u0019\u0000\u0000\u051d\u051f\u0005\u0005\u0000" + + "\u0000\u051e\u051d\u0001\u0000\u0000\u0000\u051f\u0522\u0001\u0000\u0000" + + "\u0000\u0520\u051e\u0001\u0000\u0000\u0000\u0520\u0521\u0001\u0000\u0000" + + "\u0000\u0521\u0523\u0001\u0000\u0000\u0000\u0522\u0520\u0001\u0000\u0000" + + "\u0000\u0523\u0525\u0003T*\u0000\u0524\u0519\u0001\u0000\u0000\u0000\u0524" + + "\u0525\u0001\u0000\u0000\u0000\u0525S\u0001\u0000\u0000\u0000\u0526\u0528" + + "\u0003V+\u0000\u0527\u0526\u0001\u0000\u0000\u0000\u0527\u0528\u0001\u0000" + + "\u0000\u0000\u0528\u052d\u0001\u0000\u0000\u0000\u0529\u052e\u0003^/\u0000" + + "\u052a\u052e\u0003X,\u0000\u052b\u052e\u0003Z-\u0000\u052c\u052e\u0003" + + "\\.\u0000\u052d\u0529\u0001\u0000\u0000\u0000\u052d\u052a\u0001\u0000" + + "\u0000\u0000\u052d\u052b\u0001\u0000\u0000\u0000\u052d\u052c\u0001\u0000" + + "\u0000\u0000\u052eU\u0001\u0000\u0000\u0000\u052f\u0538\u0003\u0114\u008a" + + "\u0000\u0530\u0534\u0005v\u0000\u0000\u0531\u0533\u0005\u0005\u0000\u0000" + + "\u0532\u0531\u0001\u0000\u0000\u0000\u0533\u0536\u0001\u0000\u0000\u0000" + + "\u0534\u0532\u0001\u0000\u0000\u0000\u0534\u0535\u0001\u0000\u0000\u0000" + + "\u0535\u0538\u0001\u0000\u0000\u0000\u0536\u0534\u0001\u0000\u0000\u0000" + + "\u0537\u052f\u0001\u0000\u0000\u0000\u0537\u0530\u0001\u0000\u0000\u0000" + + "\u0538\u0539\u0001\u0000\u0000\u0000\u0539\u0537\u0001\u0000\u0000\u0000" + + "\u0539\u053a\u0001\u0000\u0000\u0000\u053aW\u0001\u0000\u0000\u0000\u053b" + + "\u053c\u0005\t\u0000\u0000\u053c\u053d\u0003T*\u0000\u053d\u053e\u0005" + + "\n\u0000\u0000\u053eY\u0001\u0000\u0000\u0000\u053f\u0542\u0003\\.\u0000" + + "\u0540\u0542\u0003X,\u0000\u0541\u053f\u0001\u0000\u0000\u0000\u0541\u0540" + + "\u0001\u0000\u0000\u0000\u0542\u0546\u0001\u0000\u0000\u0000\u0543\u0545" + + "\u0005\u0005\u0000\u0000\u0544\u0543\u0001\u0000\u0000\u0000\u0545\u0548" + + "\u0001\u0000\u0000\u0000\u0546\u0544\u0001\u0000\u0000\u0000\u0546\u0547" + + "\u0001\u0000\u0000\u0000\u0547\u054a\u0001\u0000\u0000\u0000\u0548\u0546" + + "\u0001\u0000\u0000\u0000\u0549\u054b\u0005)\u0000\u0000\u054a\u0549\u0001" + + "\u0000\u0000\u0000\u054b\u054c\u0001\u0000\u0000\u0000\u054c\u054a\u0001" + + "\u0000\u0000\u0000\u054c\u054d\u0001\u0000\u0000\u0000\u054d[\u0001\u0000" + + "\u0000\u0000\u054e\u054f\u0005\t\u0000\u0000\u054f\u0550\u0003\\.\u0000" + + "\u0550\u0551\u0005\n\u0000\u0000\u0551\u0555\u0001\u0000\u0000\u0000\u0552" + + "\u0555\u0003b1\u0000\u0553\u0555\u0005g\u0000\u0000\u0554\u054e\u0001" + + "\u0000\u0000\u0000\u0554\u0552\u0001\u0000\u0000\u0000\u0554\u0553\u0001" + + "\u0000\u0000\u0000\u0555]\u0001\u0000\u0000\u0000\u0556\u055a\u0003`0" + + "\u0000\u0557\u0559\u0005\u0005\u0000\u0000\u0558\u0557\u0001\u0000\u0000" + + "\u0000\u0559\u055c\u0001\u0000\u0000\u0000\u055a\u0558\u0001\u0000\u0000" + + "\u0000\u055a\u055b\u0001\u0000\u0000\u0000\u055b\u055d\u0001\u0000\u0000" + + "\u0000\u055c\u055a\u0001\u0000\u0000\u0000\u055d\u0561\u0005\u0007\u0000" + + "\u0000\u055e\u0560\u0005\u0005\u0000\u0000\u055f\u055e\u0001\u0000\u0000" + + "\u0000\u0560\u0563\u0001\u0000\u0000\u0000\u0561\u055f\u0001\u0000\u0000" + + "\u0000\u0561\u0562\u0001\u0000\u0000\u0000\u0562\u0565\u0001\u0000\u0000" + + "\u0000\u0563\u0561\u0001\u0000\u0000\u0000\u0564\u0556\u0001\u0000\u0000" + + "\u0000\u0564\u0565\u0001\u0000\u0000\u0000\u0565\u0566\u0001\u0000\u0000" + + "\u0000\u0566\u056a\u0003f3\u0000\u0567\u0569\u0005\u0005\u0000\u0000\u0568" + + "\u0567\u0001\u0000\u0000\u0000\u0569\u056c\u0001\u0000\u0000\u0000\u056a" + + "\u0568\u0001\u0000\u0000\u0000\u056a\u056b\u0001\u0000\u0000\u0000\u056b" + + "\u056d\u0001\u0000\u0000\u0000\u056c\u056a\u0001\u0000\u0000\u0000\u056d" + + "\u0571\u0005!\u0000\u0000\u056e\u0570\u0005\u0005\u0000\u0000\u056f\u056e" + + "\u0001\u0000\u0000\u0000\u0570\u0573\u0001\u0000\u0000\u0000\u0571\u056f" + + "\u0001\u0000\u0000\u0000\u0571\u0572\u0001\u0000\u0000\u0000\u0572\u0574" + + "\u0001\u0000\u0000\u0000\u0573\u0571\u0001\u0000\u0000\u0000\u0574\u0575" + + "\u0003T*\u0000\u0575_\u0001\u0000\u0000\u0000\u0576\u057a\u0003X,\u0000" + + "\u0577\u057a\u0003Z-\u0000\u0578\u057a\u0003\\.\u0000\u0579\u0576\u0001" + + "\u0000\u0000\u0000\u0579\u0577\u0001\u0000\u0000\u0000\u0579\u0578\u0001" + + "\u0000\u0000\u0000\u057aa\u0001\u0000\u0000\u0000\u057b\u058c\u0003d2" + + "\u0000\u057c\u057e\u0005\u0005\u0000\u0000\u057d\u057c\u0001\u0000\u0000" + + "\u0000\u057e\u0581\u0001\u0000\u0000\u0000\u057f\u057d\u0001\u0000\u0000" + + "\u0000\u057f\u0580\u0001\u0000\u0000\u0000\u0580\u0582\u0001\u0000\u0000" + + "\u0000\u0581\u057f\u0001\u0000\u0000\u0000\u0582\u0586\u0005\u0007\u0000" + + "\u0000\u0583\u0585\u0005\u0005\u0000\u0000\u0584\u0583\u0001\u0000\u0000" + + "\u0000\u0585\u0588\u0001\u0000\u0000\u0000\u0586\u0584\u0001\u0000\u0000" + + "\u0000\u0586\u0587\u0001\u0000\u0000\u0000\u0587\u0589\u0001\u0000\u0000" + + "\u0000\u0588\u0586\u0001\u0000\u0000\u0000\u0589\u058b\u0003d2\u0000\u058a" + + "\u057f\u0001\u0000\u0000\u0000\u058b\u058e\u0001\u0000\u0000\u0000\u058c" + + "\u058a\u0001\u0000\u0000\u0000\u058c\u058d\u0001\u0000\u0000\u0000\u058d" + + "c\u0001\u0000\u0000\u0000\u058e\u058c\u0001\u0000\u0000\u0000\u058f\u0597" + + "\u0003\u0120\u0090\u0000\u0590\u0592\u0005\u0005\u0000\u0000\u0591\u0590" + + "\u0001\u0000\u0000\u0000\u0592\u0595\u0001\u0000\u0000\u0000\u0593\u0591" + + "\u0001\u0000\u0000\u0000\u0593\u0594\u0001\u0000\u0000\u0000\u0594\u0596" + + "\u0001\u0000\u0000\u0000\u0595\u0593\u0001\u0000\u0000\u0000\u0596\u0598" + + "\u0003\u009eO\u0000\u0597\u0593\u0001\u0000\u0000\u0000\u0597\u0598\u0001" + + "\u0000\u0000\u0000\u0598e\u0001\u0000\u0000\u0000\u0599\u059d\u0005\t" + + "\u0000\u0000\u059a\u059c\u0005\u0005\u0000\u0000\u059b\u059a\u0001\u0000" + + "\u0000\u0000\u059c\u059f\u0001\u0000\u0000\u0000\u059d\u059b\u0001\u0000" + + "\u0000\u0000\u059d\u059e\u0001\u0000\u0000\u0000\u059e\u05a2\u0001\u0000" + + "\u0000\u0000\u059f\u059d\u0001\u0000\u0000\u0000\u05a0\u05a3\u0003:\u001d" + + "\u0000\u05a1\u05a3\u0003T*\u0000\u05a2\u05a0\u0001\u0000\u0000\u0000\u05a2" + + "\u05a1\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000\u0000\u0000\u05a3" + + "\u05b7\u0001\u0000\u0000\u0000\u05a4\u05a6\u0005\u0005\u0000\u0000\u05a5" + + "\u05a4\u0001\u0000\u0000\u0000\u05a6\u05a9\u0001\u0000\u0000\u0000\u05a7" + + "\u05a5\u0001\u0000\u0000\u0000\u05a7\u05a8\u0001\u0000\u0000\u0000\u05a8" + + "\u05aa\u0001\u0000\u0000\u0000\u05a9\u05a7\u0001\u0000\u0000\u0000\u05aa" + + "\u05ae\u0005\b\u0000\u0000\u05ab\u05ad\u0005\u0005\u0000\u0000\u05ac\u05ab" + + "\u0001\u0000\u0000\u0000\u05ad\u05b0\u0001\u0000\u0000\u0000\u05ae\u05ac" + + "\u0001\u0000\u0000\u0000\u05ae\u05af\u0001\u0000\u0000\u0000\u05af\u05b3" + + "\u0001\u0000\u0000\u0000\u05b0\u05ae\u0001\u0000\u0000\u0000\u05b1\u05b4" + + "\u0003:\u001d\u0000\u05b2\u05b4\u0003T*\u0000\u05b3\u05b1\u0001\u0000" + + "\u0000\u0000\u05b3\u05b2\u0001\u0000\u0000\u0000\u05b4\u05b6\u0001\u0000" + + "\u0000\u0000\u05b5\u05a7\u0001\u0000\u0000\u0000\u05b6\u05b9\u0001\u0000" + + "\u0000\u0000\u05b7\u05b5\u0001\u0000\u0000\u0000\u05b7\u05b8\u0001\u0000" + + "\u0000\u0000\u05b8\u05c1\u0001\u0000\u0000\u0000\u05b9\u05b7\u0001\u0000" + + "\u0000\u0000\u05ba\u05bc\u0005\u0005\u0000\u0000\u05bb\u05ba\u0001\u0000" + + "\u0000\u0000\u05bc\u05bf\u0001\u0000\u0000\u0000\u05bd\u05bb\u0001\u0000" + + "\u0000\u0000\u05bd\u05be\u0001\u0000\u0000\u0000\u05be\u05c0\u0001\u0000" + + "\u0000\u0000\u05bf\u05bd\u0001\u0000\u0000\u0000\u05c0\u05c2\u0005\b\u0000" + + "\u0000\u05c1\u05bd\u0001\u0000\u0000\u0000\u05c1\u05c2\u0001\u0000\u0000" + + "\u0000\u05c2\u05c6\u0001\u0000\u0000\u0000\u05c3\u05c5\u0005\u0005\u0000" + + "\u0000\u05c4\u05c3\u0001\u0000\u0000\u0000\u05c5\u05c8\u0001\u0000\u0000" + + "\u0000\u05c6\u05c4\u0001\u0000\u0000\u0000\u05c6\u05c7\u0001\u0000\u0000" + + "\u0000\u05c7\u05c9\u0001\u0000\u0000\u0000\u05c8\u05c6\u0001\u0000\u0000" + + "\u0000\u05c9\u05ca\u0005\n\u0000\u0000\u05cag\u0001\u0000\u0000\u0000" + + "\u05cb\u05cf\u0005I\u0000\u0000\u05cc\u05ce\u0005\u0005\u0000\u0000\u05cd" + + "\u05cc\u0001\u0000\u0000\u0000\u05ce\u05d1\u0001\u0000\u0000\u0000\u05cf" + + "\u05cd\u0001\u0000\u0000\u0000\u05cf\u05d0\u0001\u0000\u0000\u0000\u05d0" + + "\u05d2\u0001\u0000\u0000\u0000\u05d1\u05cf\u0001\u0000\u0000\u0000\u05d2" + + "\u05e3\u0003j5\u0000\u05d3\u05d5\u0005\u0005\u0000\u0000\u05d4\u05d3\u0001" + + "\u0000\u0000\u0000\u05d5\u05d8\u0001\u0000\u0000\u0000\u05d6\u05d4\u0001" + + "\u0000\u0000\u0000\u05d6\u05d7\u0001\u0000\u0000\u0000\u05d7\u05d9\u0001" + + "\u0000\u0000\u0000\u05d8\u05d6\u0001\u0000\u0000\u0000\u05d9\u05dd\u0005" + + "\b\u0000\u0000\u05da\u05dc\u0005\u0005\u0000\u0000\u05db\u05da\u0001\u0000" + + "\u0000\u0000\u05dc\u05df\u0001\u0000\u0000\u0000\u05dd\u05db\u0001\u0000" + + "\u0000\u0000\u05dd\u05de\u0001\u0000\u0000\u0000\u05de\u05e0\u0001\u0000" + + "\u0000\u0000\u05df\u05dd\u0001\u0000\u0000\u0000\u05e0\u05e2\u0003j5\u0000" + + "\u05e1\u05d6\u0001\u0000\u0000\u0000\u05e2\u05e5\u0001\u0000\u0000\u0000" + + "\u05e3\u05e1\u0001\u0000\u0000\u0000\u05e3\u05e4\u0001\u0000\u0000\u0000" + + "\u05e4i\u0001\u0000\u0000\u0000\u05e5\u05e3\u0001\u0000\u0000\u0000\u05e6" + + "\u05e8\u0003\u0114\u008a\u0000\u05e7\u05e6\u0001\u0000\u0000\u0000\u05e8" + + "\u05eb\u0001\u0000\u0000\u0000\u05e9\u05e7\u0001\u0000\u0000\u0000\u05e9" + + "\u05ea\u0001\u0000\u0000\u0000\u05ea\u05ec\u0001\u0000\u0000\u0000\u05eb" + + "\u05e9\u0001\u0000\u0000\u0000\u05ec\u05f0\u0003\u0120\u0090\u0000\u05ed" + + "\u05ef\u0005\u0005\u0000\u0000\u05ee\u05ed\u0001\u0000\u0000\u0000\u05ef" + + "\u05f2\u0001\u0000\u0000\u0000\u05f0\u05ee\u0001\u0000\u0000\u0000\u05f0" + + "\u05f1\u0001\u0000\u0000\u0000\u05f1\u05f3\u0001\u0000\u0000\u0000\u05f2" + + "\u05f0\u0001\u0000\u0000\u0000\u05f3\u05f7\u0005\u0019\u0000\u0000\u05f4" + + "\u05f6\u0005\u0005\u0000\u0000\u05f5\u05f4\u0001\u0000\u0000\u0000\u05f6" + + "\u05f9\u0001\u0000\u0000\u0000\u05f7\u05f5\u0001\u0000\u0000\u0000\u05f7" + + "\u05f8\u0001\u0000\u0000\u0000\u05f8\u05fa\u0001\u0000\u0000\u0000\u05f9" + + "\u05f7\u0001\u0000\u0000\u0000\u05fa\u05fb\u0003T*\u0000\u05fbk\u0001" + + "\u0000\u0000\u0000\u05fc\u05fd\u0005\r\u0000\u0000\u05fd\u05fe\u0003n" + + "7\u0000\u05fe\u05ff\u0005\u000e\u0000\u0000\u05ffm\u0001\u0000\u0000\u0000" + + "\u0600\u0602\u0003\u0124\u0092\u0000\u0601\u0600\u0001\u0000\u0000\u0000" + + "\u0602\u0605\u0001\u0000\u0000\u0000\u0603\u0601\u0001\u0000\u0000\u0000" + + "\u0603\u0604\u0001\u0000\u0000\u0000\u0604\u0614\u0001\u0000\u0000\u0000" + + "\u0605\u0603\u0001\u0000\u0000\u0000\u0606\u0611\u0003p8\u0000\u0607\u0609" + + "\u0003\u0124\u0092\u0000\u0608\u0607\u0001\u0000\u0000\u0000\u0609\u060a" + + "\u0001\u0000\u0000\u0000\u060a\u0608\u0001\u0000\u0000\u0000\u060a\u060b" + + "\u0001\u0000\u0000\u0000\u060b\u060d\u0001\u0000\u0000\u0000\u060c\u060e" + + "\u0003p8\u0000\u060d\u060c\u0001\u0000\u0000\u0000\u060d\u060e\u0001\u0000" + + "\u0000\u0000\u060e\u0610\u0001\u0000\u0000\u0000\u060f\u0608\u0001\u0000" + + "\u0000\u0000\u0610\u0613\u0001\u0000\u0000\u0000\u0611\u060f\u0001\u0000" + + "\u0000\u0000\u0611\u0612\u0001\u0000\u0000\u0000\u0612\u0615\u0001\u0000" + + "\u0000\u0000\u0613\u0611\u0001\u0000\u0000\u0000\u0614\u0606\u0001\u0000" + + "\u0000\u0000\u0614\u0615\u0001\u0000\u0000\u0000\u0615o\u0001\u0000\u0000" + + "\u0000\u0616\u0619\u0003t:\u0000\u0617\u0619\u0003r9\u0000\u0618\u0616" + + "\u0001\u0000\u0000\u0000\u0618\u0617\u0001\u0000\u0000\u0000\u0619q\u0001" + + "\u0000\u0000\u0000\u061a\u061c\u0003\u0114\u008a\u0000\u061b\u061a\u0001" + + "\u0000\u0000\u0000\u061c\u061f\u0001\u0000\u0000\u0000\u061d\u061b\u0001" + + "\u0000\u0000\u0000\u061d\u061e\u0001\u0000\u0000\u0000\u061e\u0623\u0001" + + "\u0000\u0000\u0000\u061f\u061d\u0001\u0000\u0000\u0000\u0620\u0622\u0005" + + "\u0005\u0000\u0000\u0621\u0620\u0001\u0000\u0000\u0000\u0622\u0625\u0001" + + "\u0000\u0000\u0000\u0623\u0621\u0001\u0000\u0000\u0000\u0623\u0624\u0001" + + "\u0000\u0000\u0000\u0624\u0626\u0001\u0000\u0000\u0000\u0625\u0623\u0001" + + "\u0000\u0000\u0000\u0626\u0627\u0003v;\u0000\u0627s\u0001\u0000\u0000" + + "\u0000\u0628\u062a\u0003\u0112\u0089\u0000\u0629\u0628\u0001\u0000\u0000" + + "\u0000\u062a\u062d\u0001\u0000\u0000\u0000\u062b\u0629\u0001\u0000\u0000" + + "\u0000\u062b\u062c\u0001\u0000\u0000\u0000\u062c\u0632\u0001\u0000\u0000" + + "\u0000\u062d\u062b\u0001\u0000\u0000\u0000\u062e\u0633\u0003\u0014\n\u0000" + + "\u062f\u0633\u00034\u001a\u0000\u0630\u0633\u0003D\"\u0000\u0631\u0633" + + "\u0003N\'\u0000\u0632\u062e\u0001\u0000\u0000\u0000\u0632\u062f\u0001" + + "\u0000\u0000\u0000\u0632\u0630\u0001\u0000\u0000\u0000\u0632\u0631\u0001" + + "\u0000\u0000\u0000\u0633u\u0001\u0000\u0000\u0000\u0634\u063a\u0003x<" + + "\u0000\u0635\u0636\u0003\u00e6s\u0000\u0636\u0637\u0003x<\u0000\u0637" + + "\u0639\u0001\u0000\u0000\u0000\u0638\u0635\u0001\u0000\u0000\u0000\u0639" + + "\u063c\u0001\u0000\u0000\u0000\u063a\u0638\u0001\u0000\u0000\u0000\u063a" + + "\u063b\u0001\u0000\u0000\u0000\u063bw\u0001\u0000\u0000\u0000\u063c\u063a" + + "\u0001\u0000\u0000\u0000\u063d\u064e\u0003z=\u0000\u063e\u0640\u0005\u0005" + + "\u0000\u0000\u063f\u063e\u0001\u0000\u0000\u0000\u0640\u0643\u0001\u0000" + + "\u0000\u0000\u0641\u063f\u0001\u0000\u0000\u0000\u0641\u0642\u0001\u0000" + + "\u0000\u0000\u0642\u0644\u0001\u0000\u0000\u0000\u0643\u0641\u0001\u0000" + + "\u0000\u0000\u0644\u0648\u0005\u0017\u0000\u0000\u0645\u0647\u0005\u0005" + + "\u0000\u0000\u0646\u0645\u0001\u0000\u0000\u0000\u0647\u064a\u0001\u0000" + + "\u0000\u0000\u0648\u0646\u0001\u0000\u0000\u0000\u0648\u0649\u0001\u0000" + + "\u0000\u0000\u0649\u064b\u0001\u0000\u0000\u0000\u064a\u0648\u0001\u0000" + + "\u0000\u0000\u064b\u064d\u0003z=\u0000\u064c\u0641\u0001\u0000\u0000\u0000" + + "\u064d\u0650\u0001\u0000\u0000\u0000\u064e\u064c\u0001\u0000\u0000\u0000" + + "\u064e\u064f\u0001\u0000\u0000\u0000\u064fy\u0001\u0000\u0000\u0000\u0650" + + "\u064e\u0001\u0000\u0000\u0000\u0651\u0662\u0003|>\u0000\u0652\u0654\u0005" + + "\u0005\u0000\u0000\u0653\u0652\u0001\u0000\u0000\u0000\u0654\u0657\u0001" + + "\u0000\u0000\u0000\u0655\u0653\u0001\u0000\u0000\u0000\u0655\u0656\u0001" + + "\u0000\u0000\u0000\u0656\u0658\u0001\u0000\u0000\u0000\u0657\u0655\u0001" + + "\u0000\u0000\u0000\u0658\u065c\u0005\u0016\u0000\u0000\u0659\u065b\u0005" + + "\u0005\u0000\u0000\u065a\u0659\u0001\u0000\u0000\u0000\u065b\u065e\u0001" + + "\u0000\u0000\u0000\u065c\u065a\u0001\u0000\u0000\u0000\u065c\u065d\u0001" + + "\u0000\u0000\u0000\u065d\u065f\u0001\u0000\u0000\u0000\u065e\u065c\u0001" + + "\u0000\u0000\u0000\u065f\u0661\u0003|>\u0000\u0660\u0655\u0001\u0000\u0000" + + "\u0000\u0661\u0664\u0001\u0000\u0000\u0000\u0662\u0660\u0001\u0000\u0000" + + "\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663{\u0001\u0000\u0000\u0000" + + "\u0664\u0662\u0001\u0000\u0000\u0000\u0665\u0671\u0003~?\u0000\u0666\u066a" + + "\u0003\u00e8t\u0000\u0667\u0669\u0005\u0005\u0000\u0000\u0668\u0667\u0001" + + "\u0000\u0000\u0000\u0669\u066c\u0001\u0000\u0000\u0000\u066a\u0668\u0001" + + "\u0000\u0000\u0000\u066a\u066b\u0001\u0000\u0000\u0000\u066b\u066d\u0001" + + "\u0000\u0000\u0000\u066c\u066a\u0001\u0000\u0000\u0000\u066d\u066e\u0003" + + "~?\u0000\u066e\u0670\u0001\u0000\u0000\u0000\u066f\u0666\u0001\u0000\u0000" + + "\u0000\u0670\u0673\u0001\u0000\u0000\u0000\u0671\u066f\u0001\u0000\u0000" + + "\u0000\u0671\u0672\u0001\u0000\u0000\u0000\u0672}\u0001\u0000\u0000\u0000" + + "\u0673\u0671\u0001\u0000\u0000\u0000\u0674\u067e\u0003\u0080@\u0000\u0675" + + "\u0679\u0003\u00eau\u0000\u0676\u0678\u0005\u0005\u0000\u0000\u0677\u0676" + + "\u0001\u0000\u0000\u0000\u0678\u067b\u0001\u0000\u0000\u0000\u0679\u0677" + + "\u0001\u0000\u0000\u0000\u0679\u067a\u0001\u0000\u0000\u0000\u067a\u067c" + + "\u0001\u0000\u0000\u0000\u067b\u0679\u0001\u0000\u0000\u0000\u067c\u067d" + + "\u0003\u0080@\u0000\u067d\u067f\u0001\u0000\u0000\u0000\u067e\u0675\u0001" + + "\u0000\u0000\u0000\u067e\u067f\u0001\u0000\u0000\u0000\u067f\u007f\u0001" + + "\u0000\u0000\u0000\u0680\u0697\u0003\u0082A\u0000\u0681\u0685\u0003\u00ec" + + "v\u0000\u0682\u0684\u0005\u0005\u0000\u0000\u0683\u0682\u0001\u0000\u0000" + + "\u0000\u0684\u0687\u0001\u0000\u0000\u0000\u0685\u0683\u0001\u0000\u0000" + + "\u0000\u0685\u0686\u0001\u0000\u0000\u0000\u0686\u0688\u0001\u0000\u0000" + + "\u0000\u0687\u0685\u0001\u0000\u0000\u0000\u0688\u0689\u0003\u0082A\u0000" + + "\u0689\u068b\u0001\u0000\u0000\u0000\u068a\u0681\u0001\u0000\u0000\u0000" + + "\u068b\u068c\u0001\u0000\u0000\u0000\u068c\u068a\u0001\u0000\u0000\u0000" + + "\u068c\u068d\u0001\u0000\u0000\u0000\u068d\u0698\u0001\u0000\u0000\u0000" + + "\u068e\u0692\u0003\u00eew\u0000\u068f\u0691\u0005\u0005\u0000\u0000\u0690" + + "\u068f\u0001\u0000\u0000\u0000\u0691\u0694\u0001\u0000\u0000\u0000\u0692" + + "\u0690\u0001\u0000\u0000\u0000\u0692\u0693\u0001\u0000\u0000\u0000\u0693" + + "\u0695\u0001\u0000\u0000\u0000\u0694\u0692\u0001\u0000\u0000\u0000\u0695" + + "\u0696\u0003T*\u0000\u0696\u0698\u0001\u0000\u0000\u0000\u0697\u068a\u0001" + + "\u0000\u0000\u0000\u0697\u068e\u0001\u0000\u0000\u0000\u0697\u0698\u0001" + + "\u0000\u0000\u0000\u0698\u0081\u0001\u0000\u0000\u0000\u0699\u06aa\u0003" + + "\u0084B\u0000\u069a\u069c\u0005\u0005\u0000\u0000\u069b\u069a\u0001\u0000" + + "\u0000\u0000\u069c\u069f\u0001\u0000\u0000\u0000\u069d\u069b\u0001\u0000" + + "\u0000\u0000\u069d\u069e\u0001\u0000\u0000\u0000\u069e\u06a0\u0001\u0000" + + "\u0000\u0000\u069f\u069d\u0001\u0000\u0000\u0000\u06a0\u06a4\u0005*\u0000" + + "\u0000\u06a1\u06a3\u0005\u0005\u0000\u0000\u06a2\u06a1\u0001\u0000\u0000" + + "\u0000\u06a3\u06a6\u0001\u0000\u0000\u0000\u06a4\u06a2\u0001\u0000\u0000" + + "\u0000\u06a4\u06a5\u0001\u0000\u0000\u0000\u06a5\u06a7\u0001\u0000\u0000" + + "\u0000\u06a6\u06a4\u0001\u0000\u0000\u0000\u06a7\u06a9\u0003\u0084B\u0000" + + "\u06a8\u069d\u0001\u0000\u0000\u0000\u06a9\u06ac\u0001\u0000\u0000\u0000" + + "\u06aa\u06a8\u0001\u0000\u0000\u0000\u06aa\u06ab\u0001\u0000\u0000\u0000" + + "\u06ab\u0083\u0001\u0000\u0000\u0000\u06ac\u06aa\u0001\u0000\u0000\u0000" + + "\u06ad\u06b9\u0003\u0086C\u0000\u06ae\u06b2\u0003\u0120\u0090\u0000\u06af" + + "\u06b1\u0005\u0005\u0000\u0000\u06b0\u06af\u0001\u0000\u0000\u0000\u06b1" + + "\u06b4\u0001\u0000\u0000\u0000\u06b2\u06b0\u0001\u0000\u0000\u0000\u06b2" + + "\u06b3\u0001\u0000\u0000\u0000\u06b3\u06b5\u0001\u0000\u0000\u0000\u06b4" + + "\u06b2\u0001\u0000\u0000\u0000\u06b5\u06b6\u0003\u0086C\u0000\u06b6\u06b8" + + "\u0001\u0000\u0000\u0000\u06b7\u06ae\u0001\u0000\u0000\u0000\u06b8\u06bb" + + "\u0001\u0000\u0000\u0000\u06b9\u06b7\u0001\u0000\u0000\u0000\u06b9\u06ba" + + "\u0001\u0000\u0000\u0000\u06ba\u0085\u0001\u0000\u0000\u0000\u06bb\u06b9" + + "\u0001\u0000\u0000\u0000\u06bc\u06c7\u0003\u0088D\u0000\u06bd\u06c1\u0005" + + "#\u0000\u0000\u06be\u06c0\u0005\u0005\u0000\u0000\u06bf\u06be\u0001\u0000" + + "\u0000\u0000\u06c0\u06c3\u0001\u0000\u0000\u0000\u06c1\u06bf\u0001\u0000" + + "\u0000\u0000\u06c1\u06c2\u0001\u0000\u0000\u0000\u06c2\u06c4\u0001\u0000" + + "\u0000\u0000\u06c3\u06c1\u0001\u0000\u0000\u0000\u06c4\u06c6\u0003\u0088" + + "D\u0000\u06c5\u06bd\u0001\u0000\u0000\u0000\u06c6\u06c9\u0001\u0000\u0000" + + "\u0000\u06c7\u06c5\u0001\u0000\u0000\u0000\u06c7\u06c8\u0001\u0000\u0000" + + "\u0000\u06c8\u0087\u0001\u0000\u0000\u0000\u06c9\u06c7\u0001\u0000\u0000" + + "\u0000\u06ca\u06d6\u0003\u008aE\u0000\u06cb\u06cf\u0003\u00f0x\u0000\u06cc" + + "\u06ce\u0005\u0005\u0000\u0000\u06cd\u06cc\u0001\u0000\u0000\u0000\u06ce" + + "\u06d1\u0001\u0000\u0000\u0000\u06cf\u06cd\u0001\u0000\u0000\u0000\u06cf" + + "\u06d0\u0001\u0000\u0000\u0000\u06d0\u06d2\u0001\u0000\u0000\u0000\u06d1" + + "\u06cf\u0001\u0000\u0000\u0000\u06d2\u06d3\u0003\u008aE\u0000\u06d3\u06d5" + + "\u0001\u0000\u0000\u0000\u06d4\u06cb\u0001\u0000\u0000\u0000\u06d5\u06d8" + + "\u0001\u0000\u0000\u0000\u06d6\u06d4\u0001\u0000\u0000\u0000\u06d6\u06d7" + + "\u0001\u0000\u0000\u0000\u06d7\u0089\u0001\u0000\u0000\u0000\u06d8\u06d6" + + "\u0001\u0000\u0000\u0000\u06d9\u06e5\u0003\u008cF\u0000\u06da\u06de\u0003" + + "\u00f2y\u0000\u06db\u06dd\u0005\u0005\u0000\u0000\u06dc\u06db\u0001\u0000" + + "\u0000\u0000\u06dd\u06e0\u0001\u0000\u0000\u0000\u06de\u06dc\u0001\u0000" + + "\u0000\u0000\u06de\u06df\u0001\u0000\u0000\u0000\u06df\u06e1\u0001\u0000" + + "\u0000\u0000\u06e0\u06de\u0001\u0000\u0000\u0000\u06e1\u06e2\u0003\u008c" + + "F\u0000\u06e2\u06e4\u0001\u0000\u0000\u0000\u06e3\u06da\u0001\u0000\u0000" + + "\u0000\u06e4\u06e7\u0001\u0000\u0000\u0000\u06e5\u06e3\u0001\u0000\u0000" + + "\u0000\u06e5\u06e6\u0001\u0000\u0000\u0000\u06e6\u008b\u0001\u0000\u0000" + + "\u0000\u06e7\u06e5\u0001\u0000\u0000\u0000\u06e8\u06f4\u0003\u008eG\u0000" + + "\u06e9\u06eb\u0005\u0005\u0000\u0000\u06ea\u06e9\u0001\u0000\u0000\u0000" + + "\u06eb\u06ee\u0001\u0000\u0000\u0000\u06ec\u06ea\u0001\u0000\u0000\u0000" + + "\u06ec\u06ed\u0001\u0000\u0000\u0000\u06ed\u06ef\u0001\u0000\u0000\u0000" + + "\u06ee\u06ec\u0001\u0000\u0000\u0000\u06ef\u06f0\u0003\u00f4z\u0000\u06f0" + + "\u06f1\u0003\u008eG\u0000\u06f1\u06f3\u0001\u0000\u0000\u0000\u06f2\u06ec" + + "\u0001\u0000\u0000\u0000\u06f3\u06f6\u0001\u0000\u0000\u0000\u06f4\u06f2" + + "\u0001\u0000\u0000\u0000\u06f4\u06f5\u0001\u0000\u0000\u0000\u06f5\u008d" + + "\u0001\u0000\u0000\u0000\u06f6\u06f4\u0001\u0000\u0000\u0000\u06f7\u06f9" + + "\u0003\u00f6{\u0000\u06f8\u06f7\u0001\u0000\u0000\u0000\u06f9\u06fc\u0001" + + "\u0000\u0000\u0000\u06fa\u06f8\u0001\u0000\u0000\u0000\u06fa\u06fb\u0001" + + "\u0000\u0000\u0000\u06fb\u06fd\u0001\u0000\u0000\u0000\u06fc\u06fa\u0001" + + "\u0000\u0000\u0000\u06fd\u06fe\u0003\u0090H\u0000\u06fe\u008f\u0001\u0000" + + "\u0000\u0000\u06ff\u0702\u0003\u0092I\u0000\u0700\u0702\u0003\u00e4r\u0000" + + "\u0701\u06ff\u0001\u0000\u0000\u0000\u0701\u0700\u0001\u0000\u0000\u0000" + + "\u0702\u0706\u0001\u0000\u0000\u0000\u0703\u0705\u0003\u00f8|\u0000\u0704" + + "\u0703\u0001\u0000\u0000\u0000\u0705\u0708\u0001\u0000\u0000\u0000\u0706" + + "\u0704\u0001\u0000\u0000\u0000\u0706\u0707\u0001\u0000\u0000\u0000\u0707" + + "\u0091\u0001\u0000\u0000\u0000\u0708\u0706\u0001\u0000\u0000\u0000\u0709" + + "\u0718\u0003\u0094J\u0000\u070a\u0718\u0003\u00a6S\u0000\u070b\u0718\u0003" + + "\u00b6[\u0000\u070c\u0718\u0003\u00c0`\u0000\u070d\u0718\u0003\u00c2a" + + "\u0000\u070e\u0718\u0003\u00c4b\u0000\u070f\u0718\u0003\u00d4j\u0000\u0710" + + "\u0718\u0003\u00bc^\u0000\u0711\u0718\u0003\u00e2q\u0000\u0712\u0718\u0003" + + "\u00dam\u0000\u0713\u0718\u0003\u00be_\u0000\u0714\u0718\u0003\u0120\u0090" + + "\u0000\u0715\u0716\u0005?\u0000\u0000\u0716\u0718\u0003\u011e\u008f\u0000" + + "\u0717\u0709\u0001\u0000\u0000\u0000\u0717\u070a\u0001\u0000\u0000\u0000" + + "\u0717\u070b\u0001\u0000\u0000\u0000\u0717\u070c\u0001\u0000\u0000\u0000" + + "\u0717\u070d\u0001\u0000\u0000\u0000\u0717\u070e\u0001\u0000\u0000\u0000" + + "\u0717\u070f\u0001\u0000\u0000\u0000\u0717\u0710\u0001\u0000\u0000\u0000" + + "\u0717\u0711\u0001\u0000\u0000\u0000\u0717\u0712\u0001\u0000\u0000\u0000" + + "\u0717\u0713\u0001\u0000\u0000\u0000\u0717\u0714\u0001\u0000\u0000\u0000" + + "\u0717\u0715\u0001\u0000\u0000\u0000\u0718\u0093\u0001\u0000\u0000\u0000" + + "\u0719\u071a\u0005\t\u0000\u0000\u071a\u071b\u0003v;\u0000\u071b\u071c" + + "\u0005\n\u0000\u0000\u071c\u0095\u0001\u0000\u0000\u0000\u071d\u071f\u0003" + + "\u009eO\u0000\u071e\u0720\u0003\u009cN\u0000\u071f\u071e\u0001\u0000\u0000" + + "\u0000\u071f\u0720\u0001\u0000\u0000\u0000\u0720\u0724\u0001\u0000\u0000" + + "\u0000\u0721\u0723\u0003\u0098L\u0000\u0722\u0721\u0001\u0000\u0000\u0000" + + "\u0723\u0726\u0001\u0000\u0000\u0000\u0724\u0722\u0001\u0000\u0000\u0000" + + "\u0724\u0725\u0001\u0000\u0000\u0000\u0725\u0734\u0001\u0000\u0000\u0000" + + "\u0726\u0724\u0001\u0000\u0000\u0000\u0727\u072b\u0003\u009cN\u0000\u0728" + + "\u072a\u0003\u0098L\u0000\u0729\u0728\u0001\u0000\u0000\u0000\u072a\u072d" + + "\u0001\u0000\u0000\u0000\u072b\u0729\u0001\u0000\u0000\u0000\u072b\u072c" + + "\u0001\u0000\u0000\u0000\u072c\u0734\u0001\u0000\u0000\u0000\u072d\u072b" + + "\u0001\u0000\u0000\u0000\u072e\u0730\u0003\u0098L\u0000\u072f\u072e\u0001" + + "\u0000\u0000\u0000\u0730\u0731\u0001\u0000\u0000\u0000\u0731\u072f\u0001" + + "\u0000\u0000\u0000\u0731\u0732\u0001\u0000\u0000\u0000\u0732\u0734\u0001" + + "\u0000\u0000\u0000\u0733\u071d\u0001\u0000\u0000\u0000\u0733\u0727\u0001" + + "\u0000\u0000\u0000\u0733\u072f\u0001\u0000\u0000\u0000\u0734\u0097\u0001" + + "\u0000\u0000\u0000\u0735\u0737\u0003\u011c\u008e\u0000\u0736\u0735\u0001" + + "\u0000\u0000\u0000\u0737\u073a\u0001\u0000\u0000\u0000\u0738\u0736\u0001" + + "\u0000\u0000\u0000\u0738\u0739\u0001\u0000\u0000\u0000\u0739\u073c\u0001" + + "\u0000\u0000\u0000\u073a\u0738\u0001\u0000\u0000\u0000\u073b\u073d\u0005" + + "\u008e\u0000\u0000\u073c\u073b\u0001\u0000\u0000\u0000\u073c\u073d\u0001" + + "\u0000\u0000\u0000\u073d\u0741\u0001\u0000\u0000\u0000\u073e\u0740\u0005" + + "\u0005\u0000\u0000\u073f\u073e\u0001\u0000\u0000\u0000\u0740\u0743\u0001" + + "\u0000\u0000\u0000\u0741\u073f\u0001\u0000\u0000\u0000\u0741\u0742\u0001" + + "\u0000\u0000\u0000\u0742\u0744\u0001\u0000\u0000\u0000\u0743\u0741\u0001" + + "\u0000\u0000\u0000\u0744\u0745\u0003\u00b6[\u0000\u0745\u0099\u0001\u0000" + + "\u0000\u0000\u0746\u074f\u0005\u000b\u0000\u0000\u0747\u074c\u0003v;\u0000" + + "\u0748\u0749\u0005\b\u0000\u0000\u0749\u074b\u0003v;\u0000\u074a\u0748" + + "\u0001\u0000\u0000\u0000\u074b\u074e\u0001\u0000\u0000\u0000\u074c\u074a" + + "\u0001\u0000\u0000\u0000\u074c\u074d\u0001\u0000\u0000\u0000\u074d\u0750" + + "\u0001\u0000\u0000\u0000\u074e\u074c\u0001\u0000\u0000\u0000\u074f\u0747" + + "\u0001\u0000\u0000\u0000\u074f\u0750\u0001\u0000\u0000\u0000\u0750\u0751" + + "\u0001\u0000\u0000\u0000\u0751\u0752\u0005\f\u0000\u0000\u0752\u009b\u0001" + + "\u0000\u0000\u0000\u0753\u0765\u0005\t\u0000\u0000\u0754\u0759\u0003\u00a4" + + "R\u0000\u0755\u0756\u0005\b\u0000\u0000\u0756\u0758\u0003\u00a4R\u0000" + + "\u0757\u0755\u0001\u0000\u0000\u0000\u0758\u075b\u0001\u0000\u0000\u0000" + + "\u0759\u0757\u0001\u0000\u0000\u0000\u0759\u075a\u0001\u0000\u0000\u0000" + + "\u075a\u0763\u0001\u0000\u0000\u0000\u075b\u0759\u0001\u0000\u0000\u0000" + + "\u075c\u075e\u0005\u0005\u0000\u0000\u075d\u075c\u0001\u0000\u0000\u0000" + + "\u075e\u0761\u0001\u0000\u0000\u0000\u075f\u075d\u0001\u0000\u0000\u0000" + + "\u075f\u0760\u0001\u0000\u0000\u0000\u0760\u0762\u0001\u0000\u0000\u0000" + + "\u0761\u075f\u0001\u0000\u0000\u0000\u0762\u0764\u0005\b\u0000\u0000\u0763" + + "\u075f\u0001\u0000\u0000\u0000\u0763\u0764\u0001\u0000\u0000\u0000\u0764" + + "\u0766\u0001\u0000\u0000\u0000\u0765\u0754\u0001\u0000\u0000\u0000\u0765" + + "\u0766\u0001\u0000\u0000\u0000\u0766\u0767\u0001\u0000\u0000\u0000\u0767" + + "\u0768\u0005\n\u0000\u0000\u0768\u009d\u0001\u0000\u0000\u0000\u0769\u076d" + + "\u0005+\u0000\u0000\u076a\u076c\u0005\u0005\u0000\u0000\u076b\u076a\u0001" + + "\u0000\u0000\u0000\u076c\u076f\u0001\u0000\u0000\u0000\u076d\u076b\u0001" + + "\u0000\u0000\u0000\u076d\u076e\u0001\u0000\u0000\u0000\u076e\u0770\u0001" + + "\u0000\u0000\u0000\u076f\u076d\u0001\u0000\u0000\u0000\u0770\u077b\u0003" + + "\u00a0P\u0000\u0771\u0773\u0005\u0005\u0000\u0000\u0772\u0771\u0001\u0000" + + "\u0000\u0000\u0773\u0776\u0001\u0000\u0000\u0000\u0774\u0772\u0001\u0000" + + "\u0000\u0000\u0774\u0775\u0001\u0000\u0000\u0000\u0775\u0777\u0001\u0000" + + "\u0000\u0000\u0776\u0774\u0001\u0000\u0000\u0000\u0777\u0778\u0005\b\u0000" + + "\u0000\u0778\u077a\u0003\u00a0P\u0000\u0779\u0774\u0001\u0000\u0000\u0000" + + "\u077a\u077d\u0001\u0000\u0000\u0000\u077b\u0779\u0001\u0000\u0000\u0000" + + "\u077b\u077c\u0001\u0000\u0000\u0000\u077c\u0785\u0001\u0000\u0000\u0000" + + "\u077d\u077b\u0001\u0000\u0000\u0000\u077e\u0780\u0005\u0005\u0000\u0000" + + "\u077f\u077e\u0001\u0000\u0000\u0000\u0780\u0783\u0001\u0000\u0000\u0000" + + "\u0781\u077f\u0001\u0000\u0000\u0000\u0781\u0782\u0001\u0000\u0000\u0000" + + "\u0782\u0784\u0001\u0000\u0000\u0000\u0783\u0781\u0001\u0000\u0000\u0000" + + "\u0784\u0786\u0005\b\u0000\u0000\u0785\u0781\u0001\u0000\u0000\u0000\u0785" + + "\u0786\u0001\u0000\u0000\u0000\u0786\u078a\u0001\u0000\u0000\u0000\u0787" + + "\u0789\u0005\u0005\u0000\u0000\u0788\u0787\u0001\u0000\u0000\u0000\u0789" + + "\u078c\u0001\u0000\u0000\u0000\u078a\u0788\u0001\u0000\u0000\u0000\u078a" + + "\u078b\u0001\u0000\u0000\u0000\u078b\u078d\u0001\u0000\u0000\u0000\u078c" + + "\u078a\u0001\u0000\u0000\u0000\u078d\u078f\u0005,\u0000\u0000\u078e\u0790" + + "\u0005)\u0000\u0000\u078f\u078e\u0001\u0000\u0000\u0000\u078f\u0790\u0001" + + "\u0000\u0000\u0000\u0790\u009f\u0001\u0000\u0000\u0000\u0791\u0793\u0003" + + "\u00a2Q\u0000\u0792\u0791\u0001\u0000\u0000\u0000\u0792\u0793\u0001\u0000" + + "\u0000\u0000\u0793\u0794\u0001\u0000\u0000\u0000\u0794\u0797\u0003T*\u0000" + + "\u0795\u0797\u0005\u000f\u0000\u0000\u0796\u0792\u0001\u0000\u0000\u0000" + + "\u0796\u0795\u0001\u0000\u0000\u0000\u0797\u00a1\u0001\u0000\u0000\u0000" + + "\u0798\u079a\u0003\u0106\u0083\u0000\u0799\u0798\u0001\u0000\u0000\u0000" + + "\u079a\u079b\u0001\u0000\u0000\u0000\u079b\u0799\u0001\u0000\u0000\u0000" + + "\u079b\u079c\u0001\u0000\u0000\u0000\u079c\u00a3\u0001\u0000\u0000\u0000" + + "\u079d\u07a1\u0003\u0120\u0090\u0000\u079e\u07a0\u0005\u0005\u0000\u0000" + + "\u079f\u079e\u0001\u0000\u0000\u0000\u07a0\u07a3\u0001\u0000\u0000\u0000" + + "\u07a1\u079f\u0001\u0000\u0000\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000" + + "\u07a2\u07a4\u0001\u0000\u0000\u0000\u07a3\u07a1\u0001\u0000\u0000\u0000" + + "\u07a4\u07a8\u0005\u001b\u0000\u0000\u07a5\u07a7\u0005\u0005\u0000\u0000" + + "\u07a6\u07a5\u0001\u0000\u0000\u0000\u07a7\u07aa\u0001\u0000\u0000\u0000" + + "\u07a8\u07a6\u0001\u0000\u0000\u0000\u07a8\u07a9\u0001\u0000\u0000\u0000" + + "\u07a9\u07ac\u0001\u0000\u0000\u0000\u07aa\u07a8\u0001\u0000\u0000\u0000" + + "\u07ab\u079d\u0001\u0000\u0000\u0000\u07ab\u07ac\u0001\u0000\u0000\u0000" + + "\u07ac\u07ae\u0001\u0000\u0000\u0000\u07ad\u07af\u0005\u000f\u0000\u0000" + + "\u07ae\u07ad\u0001\u0000\u0000\u0000\u07ae\u07af\u0001\u0000\u0000\u0000" + + "\u07af\u07b3\u0001\u0000\u0000\u0000\u07b0\u07b2\u0005\u0005\u0000\u0000" + + "\u07b1\u07b0\u0001\u0000\u0000\u0000\u07b2\u07b5\u0001\u0000\u0000\u0000" + + "\u07b3\u07b1\u0001\u0000\u0000\u0000\u07b3\u07b4\u0001\u0000\u0000\u0000" + + "\u07b4\u07b6\u0001\u0000\u0000\u0000\u07b5\u07b3\u0001\u0000\u0000\u0000" + + "\u07b6\u07b7\u0003v;\u0000\u07b7\u00a5\u0001\u0000\u0000\u0000\u07b8\u07c2" + + "\u0005\u008a\u0000\u0000\u07b9\u07c2\u0005\u0087\u0000\u0000\u07ba\u07c2" + + "\u0003\u00a8T\u0000\u07bb\u07c2\u0005\u0088\u0000\u0000\u07bc\u07c2\u0005" + + "\u0089\u0000\u0000\u07bd\u07c2\u0005\u0090\u0000\u0000\u07be\u07c2\u0005" + + "\u0083\u0000\u0000\u07bf\u07c2\u0005\u008b\u0000\u0000\u07c0\u07c2\u0005" + + "\u0086\u0000\u0000\u07c1\u07b8\u0001\u0000\u0000\u0000\u07c1\u07b9\u0001" + + "\u0000\u0000\u0000\u07c1\u07ba\u0001\u0000\u0000\u0000\u07c1\u07bb\u0001" + + "\u0000\u0000\u0000\u07c1\u07bc\u0001\u0000\u0000\u0000\u07c1\u07bd\u0001" + + "\u0000\u0000\u0000\u07c1\u07be\u0001\u0000\u0000\u0000\u07c1\u07bf\u0001" + + "\u0000\u0000\u0000\u07c1\u07c0\u0001\u0000\u0000\u0000\u07c2\u00a7\u0001" + + "\u0000\u0000\u0000\u07c3\u07c6\u0003\u00aaU\u0000\u07c4\u07c6\u0003\u00ac" + + "V\u0000\u07c5\u07c3\u0001\u0000\u0000\u0000\u07c5\u07c4\u0001\u0000\u0000" + + "\u0000\u07c6\u00a9\u0001\u0000\u0000\u0000\u07c7\u07cc\u0005\u0081\u0000" + + "\u0000\u07c8\u07cb\u0003\u00aeW\u0000\u07c9\u07cb\u0003\u00b0X\u0000\u07ca" + + "\u07c8\u0001\u0000\u0000\u0000\u07ca\u07c9\u0001\u0000\u0000\u0000\u07cb" + + "\u07ce\u0001\u0000\u0000\u0000\u07cc\u07ca\u0001\u0000\u0000\u0000\u07cc" + + "\u07cd\u0001\u0000\u0000\u0000\u07cd\u07cf\u0001\u0000\u0000\u0000\u07ce" + + "\u07cc\u0001\u0000\u0000\u0000\u07cf\u07d0\u0005\u009b\u0000\u0000\u07d0" + + "\u00ab\u0001\u0000\u0000\u0000\u07d1\u07d8\u0005\u0082\u0000\u0000\u07d2" + + "\u07d7\u0003\u00b2Y\u0000\u07d3\u07d7\u0003\u00b4Z\u0000\u07d4\u07d7\u0003" + + "\u00aaU\u0000\u07d5\u07d7\u0005\u00a1\u0000\u0000\u07d6\u07d2\u0001\u0000" + + "\u0000\u0000\u07d6\u07d3\u0001\u0000\u0000\u0000\u07d6\u07d4\u0001\u0000" + + "\u0000\u0000\u07d6\u07d5\u0001\u0000\u0000\u0000\u07d7\u07da\u0001\u0000" + + "\u0000\u0000\u07d8\u07d6\u0001\u0000\u0000\u0000\u07d8\u07d9\u0001\u0000" + + "\u0000\u0000\u07d9\u07db\u0001\u0000\u0000\u0000\u07da\u07d8\u0001\u0000" + + "\u0000\u0000\u07db\u07dc\u0005\u00a0\u0000\u0000\u07dc\u00ad\u0001\u0000" + + "\u0000\u0000\u07dd\u07de\u0007\u0003\u0000\u0000\u07de\u00af\u0001\u0000" + + "\u0000\u0000\u07df\u07e0\u0005\u009f\u0000\u0000\u07e0\u07e1\u0003v;\u0000" + + "\u07e1\u07e2\u0005\u000e\u0000\u0000\u07e2\u00b1\u0001\u0000\u0000\u0000" + + "\u07e3\u07e4\u0007\u0004\u0000\u0000\u07e4\u00b3\u0001\u0000\u0000\u0000" + + "\u07e5\u07e6\u0005\u00a5\u0000\u0000\u07e6\u07e7\u0003v;\u0000\u07e7\u07e8" + + "\u0005\u000e\u0000\u0000\u07e8\u00b5\u0001\u0000\u0000\u0000\u07e9\u07eb" + + "\u0003\u0114\u008a\u0000\u07ea\u07e9\u0001\u0000\u0000\u0000\u07eb\u07ee" + + "\u0001\u0000\u0000\u0000\u07ec\u07ea\u0001\u0000\u0000\u0000\u07ec\u07ed" + + "\u0001\u0000\u0000\u0000\u07ed\u081d\u0001\u0000\u0000\u0000\u07ee\u07ec" + + "\u0001\u0000\u0000\u0000\u07ef\u07f3\u0005\r\u0000\u0000\u07f0\u07f2\u0005" + + "\u0005\u0000\u0000\u07f1\u07f0\u0001\u0000\u0000\u0000\u07f2\u07f5\u0001" + + "\u0000\u0000\u0000\u07f3\u07f1\u0001\u0000\u0000\u0000\u07f3\u07f4\u0001" + + "\u0000\u0000\u0000\u07f4\u07f6\u0001\u0000\u0000\u0000\u07f5\u07f3\u0001" + + "\u0000\u0000\u0000\u07f6\u07fa\u0003n7\u0000\u07f7\u07f9\u0005\u0005\u0000" + + "\u0000\u07f8\u07f7\u0001\u0000\u0000\u0000\u07f9\u07fc\u0001\u0000\u0000" + + "\u0000\u07fa\u07f8\u0001\u0000\u0000\u0000\u07fa\u07fb\u0001\u0000\u0000" + + "\u0000\u07fb\u07fd\u0001\u0000\u0000\u0000\u07fc\u07fa\u0001\u0000\u0000" + + "\u0000\u07fd\u07fe\u0005\u000e\u0000\u0000\u07fe\u081e\u0001\u0000\u0000" + + "\u0000\u07ff\u0803\u0005\r\u0000\u0000\u0800\u0802\u0005\u0005\u0000\u0000" + + "\u0801\u0800\u0001\u0000\u0000\u0000\u0802\u0805\u0001\u0000\u0000\u0000" + + "\u0803\u0801\u0001\u0000\u0000\u0000\u0803\u0804\u0001\u0000\u0000\u0000" + + "\u0804\u0806\u0001\u0000\u0000\u0000\u0805\u0803\u0001\u0000\u0000\u0000" + + "\u0806\u080a\u0003\u00b8\\\u0000\u0807\u0809\u0005\u0005\u0000\u0000\u0808" + + "\u0807\u0001\u0000\u0000\u0000\u0809\u080c\u0001\u0000\u0000\u0000\u080a" + + "\u0808\u0001\u0000\u0000\u0000\u080a\u080b\u0001\u0000\u0000\u0000\u080b" + + "\u080d\u0001\u0000\u0000\u0000\u080c\u080a\u0001\u0000\u0000\u0000\u080d" + + "\u0811\u0005!\u0000\u0000\u080e\u0810\u0005\u0005\u0000\u0000\u080f\u080e" + + "\u0001\u0000\u0000\u0000\u0810\u0813\u0001\u0000\u0000\u0000\u0811\u080f" + + "\u0001\u0000\u0000\u0000\u0811\u0812\u0001\u0000\u0000\u0000\u0812\u0814" + + "\u0001\u0000\u0000\u0000\u0813\u0811\u0001\u0000\u0000\u0000\u0814\u0818" + + "\u0003n7\u0000\u0815\u0817\u0005\u0005\u0000\u0000\u0816\u0815\u0001\u0000" + + "\u0000\u0000\u0817\u081a\u0001\u0000\u0000\u0000\u0818\u0816\u0001\u0000" + + "\u0000\u0000\u0818\u0819\u0001\u0000\u0000\u0000\u0819\u081b\u0001\u0000" + + "\u0000\u0000\u081a\u0818\u0001\u0000\u0000\u0000\u081b\u081c\u0005\u000e" + + "\u0000\u0000\u081c\u081e\u0001\u0000\u0000\u0000\u081d\u07ef\u0001\u0000" + + "\u0000\u0000\u081d\u07ff\u0001\u0000\u0000\u0000\u081e\u00b7\u0001\u0000" + + "\u0000\u0000\u081f\u0821\u0003\u00ba]\u0000\u0820\u081f\u0001\u0000\u0000" + + "\u0000\u0820\u0821\u0001\u0000\u0000\u0000\u0821\u0832\u0001\u0000\u0000" + + "\u0000\u0822\u0824\u0005\u0005\u0000\u0000\u0823\u0822\u0001\u0000\u0000" + + "\u0000\u0824\u0827\u0001\u0000\u0000\u0000\u0825\u0823\u0001\u0000\u0000" + + "\u0000\u0825\u0826\u0001\u0000\u0000\u0000\u0826\u0828\u0001\u0000\u0000" + + "\u0000\u0827\u0825\u0001\u0000\u0000\u0000\u0828\u082c\u0005\b\u0000\u0000" + + "\u0829\u082b\u0005\u0005\u0000\u0000\u082a\u0829\u0001\u0000\u0000\u0000" + + "\u082b\u082e\u0001\u0000\u0000\u0000\u082c\u082a\u0001\u0000\u0000\u0000" + + "\u082c\u082d\u0001\u0000\u0000\u0000\u082d\u082f\u0001\u0000\u0000\u0000" + + "\u082e\u082c\u0001\u0000\u0000\u0000\u082f\u0831\u0003\u00ba]\u0000\u0830" + + "\u0825\u0001\u0000\u0000\u0000\u0831\u0834\u0001\u0000\u0000\u0000\u0832" + + "\u0830\u0001\u0000\u0000\u0000\u0832\u0833\u0001\u0000\u0000\u0000\u0833" + + "\u00b9\u0001\u0000\u0000\u0000\u0834\u0832\u0001\u0000\u0000\u0000\u0835" + + "\u0848\u0003H$\u0000\u0836\u0845\u0003F#\u0000\u0837\u0839\u0005\u0005" + + "\u0000\u0000\u0838\u0837\u0001\u0000\u0000\u0000\u0839\u083c\u0001\u0000" + + "\u0000\u0000\u083a\u0838\u0001\u0000\u0000\u0000\u083a\u083b\u0001\u0000" + + "\u0000\u0000\u083b\u083d\u0001\u0000\u0000\u0000\u083c\u083a\u0001\u0000" + + "\u0000\u0000\u083d\u0841\u0005\u0019\u0000\u0000\u083e\u0840\u0005\u0005" + + "\u0000\u0000\u083f\u083e\u0001\u0000\u0000\u0000\u0840\u0843\u0001\u0000" + + "\u0000\u0000\u0841\u083f\u0001\u0000\u0000\u0000\u0841\u0842\u0001\u0000" + + "\u0000\u0000\u0842\u0844\u0001\u0000\u0000\u0000\u0843\u0841\u0001\u0000" + + "\u0000\u0000\u0844\u0846\u0003T*\u0000\u0845\u083a\u0001\u0000\u0000\u0000" + + "\u0845\u0846\u0001\u0000\u0000\u0000\u0846\u0848\u0001\u0000\u0000\u0000" + + "\u0847\u0835\u0001\u0000\u0000\u0000\u0847\u0836\u0001\u0000\u0000\u0000" + + "\u0848\u00bb\u0001\u0000\u0000\u0000\u0849\u0858\u0005>\u0000\u0000\u084a" + + "\u084c\u0005\u0005\u0000\u0000\u084b\u084a\u0001\u0000\u0000\u0000\u084c" + + "\u084f\u0001\u0000\u0000\u0000\u084d\u084b\u0001\u0000\u0000\u0000\u084d" + + "\u084e\u0001\u0000\u0000\u0000\u084e\u0850\u0001\u0000\u0000\u0000\u084f" + + "\u084d\u0001\u0000\u0000\u0000\u0850\u0854\u0005\u0019\u0000\u0000\u0851" + + "\u0853\u0005\u0005\u0000\u0000\u0852\u0851\u0001\u0000\u0000\u0000\u0853" + + "\u0856\u0001\u0000\u0000\u0000\u0854\u0852\u0001\u0000\u0000\u0000\u0854" + + "\u0855\u0001\u0000\u0000\u0000\u0855\u0857\u0001\u0000\u0000\u0000\u0856" + + "\u0854\u0001\u0000\u0000\u0000\u0857\u0859\u0003\u001c\u000e\u0000\u0858" + + "\u084d\u0001\u0000\u0000\u0000\u0858\u0859\u0001\u0000\u0000\u0000\u0859" + + "\u085d\u0001\u0000\u0000\u0000\u085a\u085c\u0005\u0005\u0000\u0000\u085b" + + "\u085a\u0001\u0000\u0000\u0000\u085c\u085f\u0001\u0000\u0000\u0000\u085d" + + "\u085b\u0001\u0000\u0000\u0000\u085d\u085e\u0001\u0000\u0000\u0000\u085e" + + "\u0861\u0001\u0000\u0000\u0000\u085f\u085d\u0001\u0000\u0000\u0000\u0860" + + "\u0862\u0003$\u0012\u0000\u0861\u0860\u0001\u0000\u0000\u0000\u0861\u0862" + + "\u0001\u0000\u0000\u0000\u0862\u00bd\u0001\u0000\u0000\u0000\u0863\u0865" + + "\u0005\u000b\u0000\u0000\u0864\u0866\u0003v;\u0000\u0865\u0864\u0001\u0000" + + "\u0000\u0000\u0865\u0866\u0001\u0000\u0000\u0000\u0866\u086b\u0001\u0000" + + "\u0000\u0000\u0867\u0868\u0005\b\u0000\u0000\u0868\u086a\u0003v;\u0000" + + "\u0869\u0867\u0001\u0000\u0000\u0000\u086a\u086d\u0001\u0000\u0000\u0000" + + "\u086b\u0869\u0001\u0000\u0000\u0000\u086b\u086c\u0001\u0000\u0000\u0000" + + "\u086c\u086e\u0001\u0000\u0000\u0000\u086d\u086b\u0001\u0000\u0000\u0000" + + "\u086e\u086f\u0005\f\u0000\u0000\u086f\u00bf\u0001\u0000\u0000\u0000\u0870" + + "\u0872\u0005F\u0000\u0000\u0871\u0873\u0005\u008d\u0000\u0000\u0872\u0871" + + "\u0001\u0000\u0000\u0000\u0872\u0873\u0001\u0000\u0000\u0000\u0873\u00c1" + + "\u0001\u0000\u0000\u0000\u0874\u0885\u0005G\u0000\u0000\u0875\u0879\u0005" + + "+\u0000\u0000\u0876\u0878\u0005\u0005\u0000\u0000\u0877\u0876\u0001\u0000" + + "\u0000\u0000\u0878\u087b\u0001\u0000\u0000\u0000\u0879\u0877\u0001\u0000" + + "\u0000\u0000\u0879\u087a\u0001\u0000\u0000\u0000\u087a\u087c\u0001\u0000" + + "\u0000\u0000\u087b\u0879\u0001\u0000\u0000\u0000\u087c\u0880\u0003T*\u0000" + + "\u087d\u087f\u0005\u0005\u0000\u0000\u087e\u087d\u0001\u0000\u0000\u0000" + + "\u087f\u0882\u0001\u0000\u0000\u0000\u0880\u087e\u0001\u0000\u0000\u0000" + + "\u0880\u0881\u0001\u0000\u0000\u0000\u0881\u0883\u0001\u0000\u0000\u0000" + + "\u0882\u0880\u0001\u0000\u0000\u0000\u0883\u0884\u0005,\u0000\u0000\u0884" + + "\u0886\u0001\u0000\u0000\u0000\u0885\u0875\u0001\u0000\u0000\u0000\u0885" + + "\u0886\u0001\u0000\u0000\u0000\u0886\u0888\u0001\u0000\u0000\u0000\u0887" + + "\u0889\u0005\u008d\u0000\u0000\u0888\u0887\u0001\u0000\u0000\u0000\u0888" + + "\u0889\u0001\u0000\u0000\u0000\u0889\u00c3\u0001\u0000\u0000\u0000\u088a" + + "\u088d\u0003\u00c6c\u0000\u088b\u088d\u0003\u00cae\u0000\u088c\u088a\u0001" + + "\u0000\u0000\u0000\u088c\u088b\u0001\u0000\u0000\u0000\u088d\u00c5\u0001" + + "\u0000\u0000\u0000\u088e\u0892\u0005J\u0000\u0000\u088f\u0891\u0005\u0005" + + "\u0000\u0000\u0890\u088f\u0001\u0000\u0000\u0000\u0891\u0894\u0001\u0000" + + "\u0000\u0000\u0892\u0890\u0001\u0000\u0000\u0000\u0892\u0893\u0001\u0000" + + "\u0000\u0000\u0893\u0895\u0001\u0000\u0000\u0000\u0894\u0892\u0001\u0000" + + "\u0000\u0000\u0895\u0896\u0005\t\u0000\u0000\u0896\u0897\u0003v;\u0000" + + "\u0897\u089b\u0005\n\u0000\u0000\u0898\u089a\u0005\u0005\u0000\u0000\u0899" + + "\u0898\u0001\u0000\u0000\u0000\u089a\u089d\u0001\u0000\u0000\u0000\u089b" + + "\u0899\u0001\u0000\u0000\u0000\u089b\u089c\u0001\u0000\u0000\u0000\u089c" + + "\u089f\u0001\u0000\u0000\u0000\u089d\u089b\u0001\u0000\u0000\u0000\u089e" + + "\u08a0\u0003\u00c8d\u0000\u089f\u089e\u0001\u0000\u0000\u0000\u089f\u08a0" + + "\u0001\u0000\u0000\u0000\u08a0\u08a2\u0001\u0000\u0000\u0000\u08a1\u08a3" + + "\u0005\u001a\u0000\u0000\u08a2\u08a1\u0001\u0000\u0000\u0000\u08a2\u08a3" + + "\u0001\u0000\u0000\u0000\u08a3\u08b4\u0001\u0000\u0000\u0000\u08a4\u08a6" + + "\u0005\u0005\u0000\u0000\u08a5\u08a4\u0001\u0000\u0000\u0000\u08a6\u08a9" + + "\u0001\u0000\u0000\u0000\u08a7\u08a5\u0001\u0000\u0000\u0000\u08a7\u08a8" + + "\u0001\u0000\u0000\u0000\u08a8\u08aa\u0001\u0000\u0000\u0000\u08a9\u08a7" + + "\u0001\u0000\u0000\u0000\u08aa\u08ae\u0005K\u0000\u0000\u08ab\u08ad\u0005" + + "\u0005\u0000\u0000\u08ac\u08ab\u0001\u0000\u0000\u0000\u08ad\u08b0\u0001" + + "\u0000\u0000\u0000\u08ae\u08ac\u0001\u0000\u0000\u0000\u08ae\u08af\u0001" + + "\u0000\u0000\u0000\u08af\u08b2\u0001\u0000\u0000\u0000\u08b0\u08ae\u0001" + + "\u0000\u0000\u0000\u08b1\u08b3\u0003\u00c8d\u0000\u08b2\u08b1\u0001\u0000" + + "\u0000\u0000\u08b2\u08b3\u0001\u0000\u0000\u0000\u08b3\u08b5\u0001\u0000" + + "\u0000\u0000\u08b4\u08a7\u0001\u0000\u0000\u0000\u08b4\u08b5\u0001\u0000" + + "\u0000\u0000\u08b5\u00c7\u0001\u0000\u0000\u0000\u08b6\u08b9\u0003l6\u0000" + + "\u08b7\u08b9\u0003v;\u0000\u08b8\u08b6\u0001\u0000\u0000\u0000\u08b8\u08b7" + + "\u0001\u0000\u0000\u0000\u08b9\u00c9\u0001\u0000\u0000\u0000\u08ba\u08be" + + "\u0005L\u0000\u0000\u08bb\u08bd\u0005\u0005\u0000\u0000\u08bc\u08bb\u0001" + + "\u0000\u0000\u0000\u08bd\u08c0\u0001\u0000\u0000\u0000\u08be\u08bc\u0001" + + "\u0000\u0000\u0000\u08be\u08bf\u0001\u0000\u0000\u0000\u08bf\u08c5\u0001" + + "\u0000\u0000\u0000\u08c0\u08be\u0001\u0000\u0000\u0000\u08c1\u08c2\u0005" + + "\t\u0000\u0000\u08c2\u08c3\u0003v;\u0000\u08c3\u08c4\u0005\n\u0000\u0000" + + "\u08c4\u08c6\u0001\u0000\u0000\u0000\u08c5\u08c1\u0001\u0000\u0000\u0000" + + "\u08c5\u08c6\u0001\u0000\u0000\u0000\u08c6\u08ca\u0001\u0000\u0000\u0000" + + "\u08c7\u08c9\u0005\u0005\u0000\u0000\u08c8\u08c7\u0001\u0000\u0000\u0000" + + "\u08c9\u08cc\u0001\u0000\u0000\u0000\u08ca\u08c8\u0001\u0000\u0000\u0000" + + "\u08ca\u08cb\u0001\u0000\u0000\u0000\u08cb\u08cd\u0001\u0000\u0000\u0000" + + "\u08cc\u08ca\u0001\u0000\u0000\u0000\u08cd\u08d1\u0005\r\u0000\u0000\u08ce" + + "\u08d0\u0005\u0005\u0000\u0000\u08cf\u08ce\u0001\u0000\u0000\u0000\u08d0" + + "\u08d3\u0001\u0000\u0000\u0000\u08d1\u08cf\u0001\u0000\u0000\u0000\u08d1" + + "\u08d2\u0001\u0000\u0000\u0000\u08d2\u08dd\u0001\u0000\u0000\u0000\u08d3" + + "\u08d1\u0001\u0000\u0000\u0000\u08d4\u08d8\u0003\u00ccf\u0000\u08d5\u08d7" + + "\u0005\u0005\u0000\u0000\u08d6\u08d5\u0001\u0000\u0000\u0000\u08d7\u08da" + + "\u0001\u0000\u0000\u0000\u08d8\u08d6\u0001\u0000\u0000\u0000\u08d8\u08d9" + + "\u0001\u0000\u0000\u0000\u08d9\u08dc\u0001\u0000\u0000\u0000\u08da\u08d8" + + "\u0001\u0000\u0000\u0000\u08db\u08d4\u0001\u0000\u0000\u0000\u08dc\u08df" + + "\u0001\u0000\u0000\u0000\u08dd\u08db\u0001\u0000\u0000\u0000\u08dd\u08de" + + "\u0001\u0000\u0000\u0000\u08de\u08e3\u0001\u0000\u0000\u0000\u08df\u08dd" + + "\u0001\u0000\u0000\u0000\u08e0\u08e2\u0005\u0005\u0000\u0000\u08e1\u08e0" + + "\u0001\u0000\u0000\u0000\u08e2\u08e5\u0001\u0000\u0000\u0000\u08e3\u08e1" + + "\u0001\u0000\u0000\u0000\u08e3\u08e4\u0001\u0000\u0000\u0000\u08e4\u08e6" + + "\u0001\u0000\u0000\u0000\u08e5\u08e3\u0001\u0000\u0000\u0000\u08e6\u08e7" + + "\u0005\u000e\u0000\u0000\u08e7\u00cb\u0001\u0000\u0000\u0000\u08e8\u08f9" + + "\u0003\u00ceg\u0000\u08e9\u08eb\u0005\u0005\u0000\u0000\u08ea\u08e9\u0001" + + "\u0000\u0000\u0000\u08eb\u08ee\u0001\u0000\u0000\u0000\u08ec\u08ea\u0001" + + "\u0000\u0000\u0000\u08ec\u08ed\u0001\u0000\u0000\u0000\u08ed\u08ef\u0001" + + "\u0000\u0000\u0000\u08ee\u08ec\u0001\u0000\u0000\u0000\u08ef\u08f3\u0005" + + "\b\u0000\u0000\u08f0\u08f2\u0005\u0005\u0000\u0000\u08f1\u08f0\u0001\u0000" + + "\u0000\u0000\u08f2\u08f5\u0001\u0000\u0000\u0000\u08f3\u08f1\u0001\u0000" + + "\u0000\u0000\u08f3\u08f4\u0001\u0000\u0000\u0000\u08f4\u08f6\u0001\u0000" + + "\u0000\u0000\u08f5\u08f3\u0001\u0000\u0000\u0000\u08f6\u08f8\u0003\u00ce" + + "g\u0000\u08f7\u08ec"; + private static final String _serializedATNSegment1 = + "\u0001\u0000\u0000\u0000\u08f8\u08fb\u0001\u0000\u0000\u0000\u08f9\u08f7" + + "\u0001\u0000\u0000\u0000\u08f9\u08fa\u0001\u0000\u0000\u0000\u08fa\u08ff" + + "\u0001\u0000\u0000\u0000\u08fb\u08f9\u0001\u0000\u0000\u0000\u08fc\u08fe" + + "\u0005\u0005\u0000\u0000\u08fd\u08fc\u0001\u0000\u0000\u0000\u08fe\u0901" + + "\u0001\u0000\u0000\u0000\u08ff\u08fd\u0001\u0000\u0000\u0000\u08ff\u0900" + + "\u0001\u0000\u0000\u0000\u0900\u0902\u0001\u0000\u0000\u0000\u0901\u08ff" + + "\u0001\u0000\u0000\u0000\u0902\u0906\u0005!\u0000\u0000\u0903\u0905\u0005" + + "\u0005\u0000\u0000\u0904\u0903\u0001\u0000\u0000\u0000\u0905\u0908\u0001" + + "\u0000\u0000\u0000\u0906\u0904\u0001\u0000\u0000\u0000\u0906\u0907\u0001" + + "\u0000\u0000\u0000\u0907\u0909\u0001\u0000\u0000\u0000\u0908\u0906\u0001" + + "\u0000\u0000\u0000\u0909\u090b\u0003\u00c8d\u0000\u090a\u090c\u0003\u0122" + + "\u0091\u0000\u090b\u090a\u0001\u0000\u0000\u0000\u090b\u090c\u0001\u0000" + + "\u0000\u0000\u090c\u091d\u0001\u0000\u0000\u0000\u090d\u0911\u0005K\u0000" + + "\u0000\u090e\u0910\u0005\u0005\u0000\u0000\u090f\u090e\u0001\u0000\u0000" + + "\u0000\u0910\u0913\u0001\u0000\u0000\u0000\u0911\u090f\u0001\u0000\u0000" + + "\u0000\u0911\u0912\u0001\u0000\u0000\u0000\u0912\u0914\u0001\u0000\u0000" + + "\u0000\u0913\u0911\u0001\u0000\u0000\u0000\u0914\u0918\u0005!\u0000\u0000" + + "\u0915\u0917\u0005\u0005\u0000\u0000\u0916\u0915\u0001\u0000\u0000\u0000" + + "\u0917\u091a\u0001\u0000\u0000\u0000\u0918\u0916\u0001\u0000\u0000\u0000" + + "\u0918\u0919\u0001\u0000\u0000\u0000\u0919\u091b\u0001\u0000\u0000\u0000" + + "\u091a\u0918\u0001\u0000\u0000\u0000\u091b\u091d\u0003\u00c8d\u0000\u091c" + + "\u08e8\u0001\u0000\u0000\u0000\u091c\u090d\u0001\u0000\u0000\u0000\u091d" + + "\u00cd\u0001\u0000\u0000\u0000\u091e\u0922\u0003v;\u0000\u091f\u0922\u0003" + + "\u00d0h\u0000\u0920\u0922\u0003\u00d2i\u0000\u0921\u091e\u0001\u0000\u0000" + + "\u0000\u0921\u091f\u0001\u0000\u0000\u0000\u0921\u0920\u0001\u0000\u0000" + + "\u0000\u0922\u00cf\u0001\u0000\u0000\u0000\u0923\u0927\u0003\u00ecv\u0000" + + "\u0924\u0926\u0005\u0005\u0000\u0000\u0925\u0924\u0001\u0000\u0000\u0000" + + "\u0926\u0929\u0001\u0000\u0000\u0000\u0927\u0925\u0001\u0000\u0000\u0000" + + "\u0927\u0928\u0001\u0000\u0000\u0000\u0928\u092a\u0001\u0000\u0000\u0000" + + "\u0929\u0927\u0001\u0000\u0000\u0000\u092a\u092b\u0003v;\u0000\u092b\u00d1" + + "\u0001\u0000\u0000\u0000\u092c\u0930\u0003\u00eew\u0000\u092d\u092f\u0005" + + "\u0005\u0000\u0000\u092e\u092d\u0001\u0000\u0000\u0000\u092f\u0932\u0001" + + "\u0000\u0000\u0000\u0930\u092e\u0001\u0000\u0000\u0000\u0930\u0931\u0001" + + "\u0000\u0000\u0000\u0931\u0933\u0001\u0000\u0000\u0000\u0932\u0930\u0001" + + "\u0000\u0000\u0000\u0933\u0934\u0003T*\u0000\u0934\u00d3\u0001\u0000\u0000" + + "\u0000\u0935\u0939\u0005M\u0000\u0000\u0936\u0938\u0005\u0005\u0000\u0000" + + "\u0937\u0936\u0001\u0000\u0000\u0000\u0938\u093b\u0001\u0000\u0000\u0000" + + "\u0939\u0937\u0001\u0000\u0000\u0000\u0939\u093a\u0001\u0000\u0000\u0000" + + "\u093a\u093c\u0001\u0000\u0000\u0000\u093b\u0939\u0001\u0000\u0000\u0000" + + "\u093c\u0946\u0003l6\u0000\u093d\u093f\u0005\u0005\u0000\u0000\u093e\u093d" + + "\u0001\u0000\u0000\u0000\u093f\u0942\u0001\u0000\u0000\u0000\u0940\u093e" + + "\u0001\u0000\u0000\u0000\u0940\u0941\u0001\u0000\u0000\u0000\u0941\u0943" + + "\u0001\u0000\u0000\u0000\u0942\u0940\u0001\u0000\u0000\u0000\u0943\u0945" + + "\u0003\u00d6k\u0000\u0944\u0940\u0001\u0000\u0000\u0000\u0945\u0948\u0001" + + "\u0000\u0000\u0000\u0946\u0944\u0001\u0000\u0000\u0000\u0946\u0947\u0001" + + "\u0000\u0000\u0000\u0947\u0950\u0001\u0000\u0000\u0000\u0948\u0946\u0001" + + "\u0000\u0000\u0000\u0949\u094b\u0005\u0005\u0000\u0000\u094a\u0949\u0001" + + "\u0000\u0000\u0000\u094b\u094e\u0001\u0000\u0000\u0000\u094c\u094a\u0001" + + "\u0000\u0000\u0000\u094c\u094d\u0001\u0000\u0000\u0000\u094d\u094f\u0001" + + "\u0000\u0000\u0000\u094e\u094c\u0001\u0000\u0000\u0000\u094f\u0951\u0003" + + "\u00d8l\u0000\u0950\u094c\u0001\u0000\u0000\u0000\u0950\u0951\u0001\u0000" + + "\u0000\u0000\u0951\u00d5\u0001\u0000\u0000\u0000\u0952\u0956\u0005N\u0000" + + "\u0000\u0953\u0955\u0005\u0005\u0000\u0000\u0954\u0953\u0001\u0000\u0000" + + "\u0000\u0955\u0958\u0001\u0000\u0000\u0000\u0956\u0954\u0001\u0000\u0000" + + "\u0000\u0956\u0957\u0001\u0000\u0000\u0000\u0957\u0959\u0001\u0000\u0000" + + "\u0000\u0958\u0956\u0001\u0000\u0000\u0000\u0959\u095d\u0005\t\u0000\u0000" + + "\u095a\u095c\u0003\u0114\u008a\u0000\u095b\u095a\u0001\u0000\u0000\u0000" + + "\u095c\u095f\u0001\u0000\u0000\u0000\u095d\u095b\u0001\u0000\u0000\u0000" + + "\u095d\u095e\u0001\u0000\u0000\u0000\u095e\u0960\u0001\u0000\u0000\u0000" + + "\u095f\u095d\u0001\u0000\u0000\u0000\u0960\u0961\u0003\u0120\u0090\u0000" + + "\u0961\u0962\u0005\u0019\u0000\u0000\u0962\u0963\u0003b1\u0000\u0963\u0967" + + "\u0005\n\u0000\u0000\u0964\u0966\u0005\u0005\u0000\u0000\u0965\u0964\u0001" + + "\u0000\u0000\u0000\u0966\u0969\u0001\u0000\u0000\u0000\u0967\u0965\u0001" + + "\u0000\u0000\u0000\u0967\u0968\u0001\u0000\u0000\u0000\u0968\u096a\u0001" + + "\u0000\u0000\u0000\u0969\u0967\u0001\u0000\u0000\u0000\u096a\u096b\u0003" + + "l6\u0000\u096b\u00d7\u0001\u0000\u0000\u0000\u096c\u0970\u0005O\u0000" + + "\u0000\u096d\u096f\u0005\u0005\u0000\u0000\u096e\u096d\u0001\u0000\u0000" + + "\u0000\u096f\u0972\u0001\u0000\u0000\u0000\u0970\u096e\u0001\u0000\u0000" + + "\u0000\u0970\u0971\u0001\u0000\u0000\u0000\u0971\u0973\u0001\u0000\u0000" + + "\u0000\u0972\u0970\u0001\u0000\u0000\u0000\u0973\u0974\u0003l6\u0000\u0974" + + "\u00d9\u0001\u0000\u0000\u0000\u0975\u0979\u0003\u00dcn\u0000\u0976\u0979" + + "\u0003\u00deo\u0000\u0977\u0979\u0003\u00e0p\u0000\u0978\u0975\u0001\u0000" + + "\u0000\u0000\u0978\u0976\u0001\u0000\u0000\u0000\u0978\u0977\u0001\u0000" + + "\u0000\u0000\u0979\u00db\u0001\u0000\u0000\u0000\u097a\u097e\u0005P\u0000" + + "\u0000\u097b\u097d\u0005\u0005\u0000\u0000\u097c\u097b\u0001\u0000\u0000" + + "\u0000\u097d\u0980\u0001\u0000\u0000\u0000\u097e\u097c\u0001\u0000\u0000" + + "\u0000\u097e\u097f\u0001\u0000\u0000\u0000\u097f\u0981\u0001\u0000\u0000" + + "\u0000\u0980\u097e\u0001\u0000\u0000\u0000\u0981\u0985\u0005\t\u0000\u0000" + + "\u0982\u0984\u0003\u0114\u008a\u0000\u0983\u0982\u0001\u0000\u0000\u0000" + + "\u0984\u0987\u0001\u0000\u0000\u0000\u0985\u0983\u0001\u0000\u0000\u0000" + + "\u0985\u0986\u0001\u0000\u0000\u0000\u0986\u098a\u0001\u0000\u0000\u0000" + + "\u0987\u0985\u0001\u0000\u0000\u0000\u0988\u098b\u0003H$\u0000\u0989\u098b" + + "\u0003F#\u0000\u098a\u0988\u0001\u0000\u0000\u0000\u098a\u0989\u0001\u0000" + + "\u0000\u0000\u098b\u098c\u0001\u0000\u0000\u0000\u098c\u098d\u0005Y\u0000" + + "\u0000\u098d\u098e\u0003v;\u0000\u098e\u0992\u0005\n\u0000\u0000\u098f" + + "\u0991\u0005\u0005\u0000\u0000\u0990\u098f\u0001\u0000\u0000\u0000\u0991" + + "\u0994\u0001\u0000\u0000\u0000\u0992\u0990\u0001\u0000\u0000\u0000\u0992" + + "\u0993\u0001\u0000\u0000\u0000\u0993\u0996\u0001\u0000\u0000\u0000\u0994" + + "\u0992\u0001\u0000\u0000\u0000\u0995\u0997\u0003\u00c8d\u0000\u0996\u0995" + + "\u0001\u0000\u0000\u0000\u0996\u0997\u0001\u0000\u0000\u0000\u0997\u00dd" + + "\u0001\u0000\u0000\u0000\u0998\u099c\u0005R\u0000\u0000\u0999\u099b\u0005" + + "\u0005\u0000\u0000\u099a\u0999\u0001\u0000\u0000\u0000\u099b\u099e\u0001" + + "\u0000\u0000\u0000\u099c\u099a\u0001\u0000\u0000\u0000\u099c\u099d\u0001" + + "\u0000\u0000\u0000\u099d\u099f\u0001\u0000\u0000\u0000\u099e\u099c\u0001" + + "\u0000\u0000\u0000\u099f\u09a0\u0005\t\u0000\u0000\u09a0\u09a1\u0003v" + + ";\u0000\u09a1\u09a5\u0005\n\u0000\u0000\u09a2\u09a4\u0005\u0005\u0000" + + "\u0000\u09a3\u09a2\u0001\u0000\u0000\u0000\u09a4\u09a7\u0001\u0000\u0000" + + "\u0000\u09a5\u09a3\u0001\u0000\u0000\u0000\u09a5\u09a6\u0001\u0000\u0000" + + "\u0000\u09a6\u09a9\u0001\u0000\u0000\u0000\u09a7\u09a5\u0001\u0000\u0000" + + "\u0000\u09a8\u09aa\u0003\u00c8d\u0000\u09a9\u09a8\u0001\u0000\u0000\u0000" + + "\u09a9\u09aa\u0001\u0000\u0000\u0000\u09aa\u00df\u0001\u0000\u0000\u0000" + + "\u09ab\u09af\u0005Q\u0000\u0000\u09ac\u09ae\u0005\u0005\u0000\u0000\u09ad" + + "\u09ac\u0001\u0000\u0000\u0000\u09ae\u09b1\u0001\u0000\u0000\u0000\u09af" + + "\u09ad\u0001\u0000\u0000\u0000\u09af\u09b0\u0001\u0000\u0000\u0000\u09b0" + + "\u09b3\u0001\u0000\u0000\u0000\u09b1\u09af\u0001\u0000\u0000\u0000\u09b2" + + "\u09b4\u0003\u00c8d\u0000\u09b3\u09b2\u0001\u0000\u0000\u0000\u09b3\u09b4" + + "\u0001\u0000\u0000\u0000\u09b4\u09b8\u0001\u0000\u0000\u0000\u09b5\u09b7" + + "\u0005\u0005\u0000\u0000\u09b6\u09b5\u0001\u0000\u0000\u0000\u09b7\u09ba" + + "\u0001\u0000\u0000\u0000\u09b8\u09b6\u0001\u0000\u0000\u0000\u09b8\u09b9" + + "\u0001\u0000\u0000\u0000\u09b9\u09bb\u0001\u0000\u0000\u0000\u09ba\u09b8" + + "\u0001\u0000\u0000\u0000\u09bb\u09bf\u0005R\u0000\u0000\u09bc\u09be\u0005" + + "\u0005\u0000\u0000\u09bd\u09bc\u0001\u0000\u0000\u0000\u09be\u09c1\u0001" + + "\u0000\u0000\u0000\u09bf\u09bd\u0001\u0000\u0000\u0000\u09bf\u09c0\u0001" + + "\u0000\u0000\u0000\u09c0\u09c2\u0001\u0000\u0000\u0000\u09c1\u09bf\u0001" + + "\u0000\u0000\u0000\u09c2\u09c3\u0005\t\u0000\u0000\u09c3\u09c4\u0003v" + + ";\u0000\u09c4\u09c5\u0005\n\u0000\u0000\u09c5\u00e1\u0001\u0000\u0000" + + "\u0000\u09c6\u09ca\u0005S\u0000\u0000\u09c7\u09c9\u0005\u0005\u0000\u0000" + + "\u09c8\u09c7\u0001\u0000\u0000\u0000\u09c9\u09cc\u0001\u0000\u0000\u0000" + + "\u09ca\u09c8\u0001\u0000\u0000\u0000\u09ca\u09cb\u0001\u0000\u0000\u0000" + + "\u09cb\u09cd\u0001\u0000\u0000\u0000\u09cc\u09ca\u0001\u0000\u0000\u0000" + + "\u09cd\u09d7\u0003v;\u0000\u09ce\u09d0\u0007\u0005\u0000\u0000\u09cf\u09d1" + + "\u0003v;\u0000\u09d0\u09cf\u0001\u0000\u0000\u0000\u09d0\u09d1\u0001\u0000" + + "\u0000\u0000\u09d1\u09d7\u0001\u0000\u0000\u0000\u09d2\u09d7\u0005U\u0000" + + "\u0000\u09d3\u09d7\u00056\u0000\u0000\u09d4\u09d7\u0005V\u0000\u0000\u09d5" + + "\u09d7\u00057\u0000\u0000\u09d6\u09c6\u0001\u0000\u0000\u0000\u09d6\u09ce" + + "\u0001\u0000\u0000\u0000\u09d6\u09d2\u0001\u0000\u0000\u0000\u09d6\u09d3" + + "\u0001\u0000\u0000\u0000\u09d6\u09d4\u0001\u0000\u0000\u0000\u09d6\u09d5" + + "\u0001\u0000\u0000\u0000\u09d7\u00e3\u0001\u0000\u0000\u0000\u09d8\u09e2" + + "\u0003b1\u0000\u09d9\u09dd\u0005)\u0000\u0000\u09da\u09dc\u0005\u0005" + + "\u0000\u0000\u09db\u09da\u0001\u0000\u0000\u0000\u09dc\u09df\u0001\u0000" + + "\u0000\u0000\u09dd\u09db\u0001\u0000\u0000\u0000\u09dd\u09de\u0001\u0000" + + "\u0000\u0000\u09de\u09e1\u0001\u0000\u0000\u0000\u09df\u09dd\u0001\u0000" + + "\u0000\u0000\u09e0\u09d9\u0001\u0000\u0000\u0000\u09e1\u09e4\u0001\u0000" + + "\u0000\u0000\u09e2\u09e0\u0001\u0000\u0000\u0000\u09e2\u09e3\u0001\u0000" + + "\u0000\u0000\u09e3\u09e6\u0001\u0000\u0000\u0000\u09e4\u09e2\u0001\u0000" + + "\u0000\u0000\u09e5\u09d8\u0001\u0000\u0000\u0000\u09e5\u09e6\u0001\u0000" + + "\u0000\u0000\u09e6\u09ea\u0001\u0000\u0000\u0000\u09e7\u09e9\u0005\u0005" + + "\u0000\u0000\u09e8\u09e7\u0001\u0000\u0000\u0000\u09e9\u09ec\u0001\u0000" + + "\u0000\u0000\u09ea\u09e8\u0001\u0000\u0000\u0000\u09ea\u09eb\u0001\u0000" + + "\u0000\u0000\u09eb\u09ed\u0001\u0000\u0000\u0000\u09ec\u09ea\u0001\u0000" + + "\u0000\u0000\u09ed\u09f1\u0007\u0006\u0000\u0000\u09ee\u09f0\u0005\u0005" + + "\u0000\u0000\u09ef\u09ee\u0001\u0000\u0000\u0000\u09f0\u09f3\u0001\u0000" + + "\u0000\u0000\u09f1\u09ef\u0001\u0000\u0000\u0000\u09f1\u09f2\u0001\u0000" + + "\u0000\u0000\u09f2\u09f6\u0001\u0000\u0000\u0000\u09f3\u09f1\u0001\u0000" + + "\u0000\u0000\u09f4\u09f7\u0003\u011e\u008f\u0000\u09f5\u09f7\u0005;\u0000" + + "\u0000\u09f6\u09f4\u0001\u0000\u0000\u0000\u09f6\u09f5\u0001\u0000\u0000" + + "\u0000\u09f7\u0a08\u0001\u0000\u0000\u0000\u09f8\u09fc\u0005F\u0000\u0000" + + "\u09f9\u09fb\u0005\u0005\u0000\u0000\u09fa\u09f9\u0001\u0000\u0000\u0000" + + "\u09fb\u09fe\u0001\u0000\u0000\u0000\u09fc\u09fa\u0001\u0000\u0000\u0000" + + "\u09fc\u09fd\u0001\u0000\u0000\u0000\u09fd\u09ff\u0001\u0000\u0000\u0000" + + "\u09fe\u09fc\u0001\u0000\u0000\u0000\u09ff\u0a03\u0005$\u0000\u0000\u0a00" + + "\u0a02\u0005\u0005\u0000\u0000\u0a01\u0a00\u0001\u0000\u0000\u0000\u0a02" + + "\u0a05\u0001\u0000\u0000\u0000\u0a03\u0a01\u0001\u0000\u0000\u0000\u0a03" + + "\u0a04\u0001\u0000\u0000\u0000\u0a04\u0a06\u0001\u0000\u0000\u0000\u0a05" + + "\u0a03\u0001\u0000\u0000\u0000\u0a06\u0a08\u0005;\u0000\u0000\u0a07\u09e5" + + "\u0001\u0000\u0000\u0000\u0a07\u09f8\u0001\u0000\u0000\u0000\u0a08\u00e5" + + "\u0001\u0000\u0000\u0000\u0a09\u0a0a\u0007\u0007\u0000\u0000\u0a0a\u00e7" + + "\u0001\u0000\u0000\u0000\u0a0b\u0a0c\u0007\b\u0000\u0000\u0a0c\u00e9\u0001" + + "\u0000\u0000\u0000\u0a0d\u0a0e\u0007\t\u0000\u0000\u0a0e\u00eb\u0001\u0000" + + "\u0000\u0000\u0a0f\u0a10\u0007\n\u0000\u0000\u0a10\u00ed\u0001\u0000\u0000" + + "\u0000\u0a11\u0a12\u0007\u000b\u0000\u0000\u0a12\u00ef\u0001\u0000\u0000" + + "\u0000\u0a13\u0a14\u0007\f\u0000\u0000\u0a14\u00f1\u0001\u0000\u0000\u0000" + + "\u0a15\u0a16\u0007\r\u0000\u0000\u0a16\u00f3\u0001\u0000\u0000\u0000\u0a17" + + "\u0a18\u0007\u000e\u0000\u0000\u0a18\u00f5\u0001\u0000\u0000\u0000\u0a19" + + "\u0a21\u0005\u0014\u0000\u0000\u0a1a\u0a21\u0005\u0015\u0000\u0000\u0a1b" + + "\u0a21\u0005\u0012\u0000\u0000\u0a1c\u0a21\u0005\u0013\u0000\u0000\u0a1d" + + "\u0a21\u0005\u0018\u0000\u0000\u0a1e\u0a21\u0003\u0114\u008a\u0000\u0a1f" + + "\u0a21\u0003\u0112\u0089\u0000\u0a20\u0a19\u0001\u0000\u0000\u0000\u0a20" + + "\u0a1a\u0001\u0000\u0000\u0000\u0a20\u0a1b\u0001\u0000\u0000\u0000\u0a20" + + "\u0a1c\u0001\u0000\u0000\u0000\u0a20\u0a1d\u0001\u0000\u0000\u0000\u0a20" + + "\u0a1e\u0001\u0000\u0000\u0000\u0a20\u0a1f\u0001\u0000\u0000\u0000\u0a21" + + "\u00f7\u0001\u0000\u0000\u0000\u0a22\u0a32\u0005\u0014\u0000\u0000\u0a23" + + "\u0a32\u0005\u0015\u0000\u0000\u0a24\u0a25\u0005\u0018\u0000\u0000\u0a25" + + "\u0a32\u0005\u0018\u0000\u0000\u0a26\u0a32\u0003\u0096K\u0000\u0a27\u0a32" + + "\u0003\u009aM\u0000\u0a28\u0a2a\u0005\u0005\u0000\u0000\u0a29\u0a28\u0001" + + "\u0000\u0000\u0000\u0a2a\u0a2d\u0001\u0000\u0000\u0000\u0a2b\u0a29\u0001" + + "\u0000\u0000\u0000\u0a2b\u0a2c\u0001\u0000\u0000\u0000\u0a2c\u0a2e\u0001" + + "\u0000\u0000\u0000\u0a2d\u0a2b\u0001\u0000\u0000\u0000\u0a2e\u0a2f\u0003" + + "\u00fa}\u0000\u0a2f\u0a30\u0003\u0090H\u0000\u0a30\u0a32\u0001\u0000\u0000" + + "\u0000\u0a31\u0a22\u0001\u0000\u0000\u0000\u0a31\u0a23\u0001\u0000\u0000" + + "\u0000\u0a31\u0a24\u0001\u0000\u0000\u0000\u0a31\u0a26\u0001\u0000\u0000" + + "\u0000\u0a31\u0a27\u0001\u0000\u0000\u0000\u0a31\u0a2b\u0001\u0000\u0000" + + "\u0000\u0a32\u00f9\u0001\u0000\u0000\u0000\u0a33\u0a37\u0005\u0007\u0000" + + "\u0000\u0a34\u0a35\u0005)\u0000\u0000\u0a35\u0a37\u0005\u0007\u0000\u0000" + + "\u0a36\u0a33\u0001\u0000\u0000\u0000\u0a36\u0a34\u0001\u0000\u0000\u0000" + + "\u0a37\u00fb\u0001\u0000\u0000\u0000\u0a38\u0a3b\u0003\u0114\u008a\u0000" + + "\u0a39\u0a3b\u0003\u00fe\u007f\u0000\u0a3a\u0a38\u0001\u0000\u0000\u0000" + + "\u0a3a\u0a39\u0001\u0000\u0000\u0000\u0a3b\u0a3c\u0001\u0000\u0000\u0000" + + "\u0a3c\u0a3a\u0001\u0000\u0000\u0000\u0a3c\u0a3d\u0001\u0000\u0000\u0000" + + "\u0a3d\u00fd\u0001\u0000\u0000\u0000\u0a3e\u0a48\u0003\u0100\u0080\u0000" + + "\u0a3f\u0a48\u0003\u0102\u0081\u0000\u0a40\u0a48\u0003\u0104\u0082\u0000" + + "\u0a41\u0a48\u0003\u0106\u0083\u0000\u0a42\u0a48\u0003\u0108\u0084\u0000" + + "\u0a43\u0a48\u0003\u010a\u0085\u0000\u0a44\u0a48\u0003\u010c\u0086\u0000" + + "\u0a45\u0a48\u0003\u010e\u0087\u0000\u0a46\u0a48\u0003\u0110\u0088\u0000" + + "\u0a47\u0a3e\u0001\u0000\u0000\u0000\u0a47\u0a3f\u0001\u0000\u0000\u0000" + + "\u0a47\u0a40\u0001\u0000\u0000\u0000\u0a47\u0a41\u0001\u0000\u0000\u0000" + + "\u0a47\u0a42\u0001\u0000\u0000\u0000\u0a47\u0a43\u0001\u0000\u0000\u0000" + + "\u0a47\u0a44\u0001\u0000\u0000\u0000\u0a47\u0a45\u0001\u0000\u0000\u0000" + + "\u0a47\u0a46\u0001\u0000\u0000\u0000\u0a48\u0a4c\u0001\u0000\u0000\u0000" + + "\u0a49\u0a4b\u0005\u0005\u0000\u0000\u0a4a\u0a49\u0001\u0000\u0000\u0000" + + "\u0a4b\u0a4e\u0001\u0000\u0000\u0000\u0a4c\u0a4a\u0001\u0000\u0000\u0000" + + "\u0a4c\u0a4d\u0001\u0000\u0000\u0000\u0a4d\u00ff\u0001\u0000\u0000\u0000" + + "\u0a4e\u0a4c\u0001\u0000\u0000\u0000\u0a4f\u0a50\u0007\u000f\u0000\u0000" + + "\u0a50\u0101\u0001\u0000\u0000\u0000\u0a51\u0a52\u0007\u0010\u0000\u0000" + + "\u0a52\u0103\u0001\u0000\u0000\u0000\u0a53\u0a54\u0007\u0011\u0000\u0000" + + "\u0a54\u0105\u0001\u0000\u0000\u0000\u0a55\u0a56\u0007\u0012\u0000\u0000" + + "\u0a56\u0107\u0001\u0000\u0000\u0000\u0a57\u0a58\u0007\u0013\u0000\u0000" + + "\u0a58\u0109\u0001\u0000\u0000\u0000\u0a59\u0a5a\u0005{\u0000\u0000\u0a5a" + + "\u010b\u0001\u0000\u0000\u0000\u0a5b\u0a5c\u0007\u0014\u0000\u0000\u0a5c" + + "\u010d\u0001\u0000\u0000\u0000\u0a5d\u0a5e\u0007\u0015\u0000\u0000\u0a5e" + + "\u010f\u0001\u0000\u0000\u0000\u0a5f\u0a60\u0005\u0080\u0000\u0000\u0a60" + + "\u0111\u0001\u0000\u0000\u0000\u0a61\u0a65\u0005\u008e\u0000\u0000\u0a62" + + "\u0a64\u0005\u0005\u0000\u0000\u0a63\u0a62\u0001\u0000\u0000\u0000\u0a64" + + "\u0a67\u0001\u0000\u0000\u0000\u0a65\u0a63\u0001\u0000\u0000\u0000\u0a65" + + "\u0a66\u0001\u0000\u0000\u0000\u0a66\u0113\u0001\u0000\u0000\u0000\u0a67" + + "\u0a65\u0001\u0000\u0000\u0000\u0a68\u0a6b\u0003\u0116\u008b\u0000\u0a69" + + "\u0a6b\u0003\u0118\u008c\u0000\u0a6a\u0a68\u0001\u0000\u0000\u0000\u0a6a" + + "\u0a69\u0001\u0000\u0000\u0000\u0a6b\u0a6f\u0001\u0000\u0000\u0000\u0a6c" + + "\u0a6e\u0005\u0005\u0000\u0000\u0a6d\u0a6c\u0001\u0000\u0000\u0000\u0a6e" + + "\u0a71\u0001\u0000\u0000\u0000\u0a6f\u0a6d\u0001\u0000\u0000\u0000\u0a6f" + + "\u0a70\u0001\u0000\u0000\u0000\u0a70\u0115\u0001\u0000\u0000\u0000\u0a71" + + "\u0a6f\u0001\u0000\u0000\u0000\u0a72\u0a76\u0003\u011a\u008d\u0000\u0a73" + + "\u0a75\u0005\u0005\u0000\u0000\u0a74\u0a73\u0001\u0000\u0000\u0000\u0a75" + + "\u0a78\u0001\u0000\u0000\u0000\u0a76\u0a74\u0001\u0000\u0000\u0000\u0a76" + + "\u0a77\u0001\u0000\u0000\u0000\u0a77\u0a79\u0001\u0000\u0000\u0000\u0a78" + + "\u0a76\u0001\u0000\u0000\u0000\u0a79\u0a7d\u0005\u0019\u0000\u0000\u0a7a" + + "\u0a7c\u0005\u0005\u0000\u0000\u0a7b\u0a7a\u0001\u0000\u0000\u0000\u0a7c" + + "\u0a7f\u0001\u0000\u0000\u0000\u0a7d\u0a7b\u0001\u0000\u0000\u0000\u0a7d" + + "\u0a7e\u0001\u0000\u0000\u0000\u0a7e\u0a80\u0001\u0000\u0000\u0000\u0a7f" + + "\u0a7d\u0001\u0000\u0000\u0000\u0a80\u0a81\u0003\u011c\u008e\u0000\u0a81" + + "\u0aa9\u0001\u0000\u0000\u0000\u0a82\u0a93\u0005\u008d\u0000\u0000\u0a83" + + "\u0a85\u0005\u0005\u0000\u0000\u0a84\u0a83\u0001\u0000\u0000\u0000\u0a85" + + "\u0a88\u0001\u0000\u0000\u0000\u0a86\u0a84\u0001\u0000\u0000\u0000\u0a86" + + "\u0a87\u0001\u0000\u0000\u0000\u0a87\u0a89\u0001\u0000\u0000\u0000\u0a88" + + "\u0a86\u0001\u0000\u0000\u0000\u0a89\u0a8d\u0005\u0007\u0000\u0000\u0a8a" + + "\u0a8c\u0005\u0005\u0000\u0000\u0a8b\u0a8a\u0001\u0000\u0000\u0000\u0a8c" + + "\u0a8f\u0001\u0000\u0000\u0000\u0a8d\u0a8b\u0001\u0000\u0000\u0000\u0a8d" + + "\u0a8e\u0001\u0000\u0000\u0000\u0a8e\u0a90\u0001\u0000\u0000\u0000\u0a8f" + + "\u0a8d\u0001\u0000\u0000\u0000\u0a90\u0a92\u0003\u0120\u0090\u0000\u0a91" + + "\u0a86\u0001\u0000\u0000\u0000\u0a92\u0a95\u0001\u0000\u0000\u0000\u0a93" + + "\u0a91\u0001\u0000\u0000\u0000\u0a93\u0a94\u0001\u0000\u0000\u0000\u0a94" + + "\u0a9d\u0001\u0000\u0000\u0000\u0a95\u0a93\u0001\u0000\u0000\u0000\u0a96" + + "\u0a98\u0005\u0005\u0000\u0000\u0a97\u0a96\u0001\u0000\u0000\u0000\u0a98" + + "\u0a9b\u0001\u0000\u0000\u0000\u0a99\u0a97\u0001\u0000\u0000\u0000\u0a99" + + "\u0a9a\u0001\u0000\u0000\u0000\u0a9a\u0a9c\u0001\u0000\u0000\u0000\u0a9b" + + "\u0a99\u0001\u0000\u0000\u0000\u0a9c\u0a9e\u0003\u009eO\u0000\u0a9d\u0a99" + + "\u0001\u0000\u0000\u0000\u0a9d\u0a9e\u0001\u0000\u0000\u0000\u0a9e\u0aa6" + + "\u0001\u0000\u0000\u0000\u0a9f\u0aa1\u0005\u0005\u0000\u0000\u0aa0\u0a9f" + + "\u0001\u0000\u0000\u0000\u0aa1\u0aa4\u0001\u0000\u0000\u0000\u0aa2\u0aa0" + + "\u0001\u0000\u0000\u0000\u0aa2\u0aa3\u0001\u0000\u0000\u0000\u0aa3\u0aa5" + + "\u0001\u0000\u0000\u0000\u0aa4\u0aa2\u0001\u0000\u0000\u0000\u0aa5\u0aa7" + + "\u0003\u009cN\u0000\u0aa6\u0aa2\u0001\u0000\u0000\u0000\u0aa6\u0aa7\u0001" + + "\u0000\u0000\u0000\u0aa7\u0aa9\u0001\u0000\u0000\u0000\u0aa8\u0a72\u0001" + + "\u0000\u0000\u0000\u0aa8\u0a82\u0001\u0000\u0000\u0000\u0aa9\u0117\u0001" + + "\u0000\u0000\u0000\u0aaa\u0aab\u0003\u011a\u008d\u0000\u0aab\u0aac\u0005" + + "\u0019\u0000\u0000\u0aac\u0aae\u0005\u000b\u0000\u0000\u0aad\u0aaf\u0003" + + "\u011c\u008e\u0000\u0aae\u0aad\u0001\u0000\u0000\u0000\u0aaf\u0ab0\u0001" + + "\u0000\u0000\u0000\u0ab0\u0aae\u0001\u0000\u0000\u0000\u0ab0\u0ab1\u0001" + + "\u0000\u0000\u0000\u0ab1\u0ab2\u0001\u0000\u0000\u0000\u0ab2\u0ab3\u0005" + + "\f\u0000\u0000\u0ab3\u0abe\u0001\u0000\u0000\u0000\u0ab4\u0ab5\u0005(" + + "\u0000\u0000\u0ab5\u0ab7\u0005\u000b\u0000\u0000\u0ab6\u0ab8\u0003\u011c" + + "\u008e\u0000\u0ab7\u0ab6\u0001\u0000\u0000\u0000\u0ab8\u0ab9\u0001\u0000" + + "\u0000\u0000\u0ab9\u0ab7\u0001\u0000\u0000\u0000\u0ab9\u0aba\u0001\u0000" + + "\u0000\u0000\u0aba\u0abb\u0001\u0000\u0000\u0000\u0abb\u0abc\u0005\f\u0000" + + "\u0000\u0abc\u0abe\u0001\u0000\u0000\u0000\u0abd\u0aaa\u0001\u0000\u0000" + + "\u0000\u0abd\u0ab4\u0001\u0000\u0000\u0000\u0abe\u0119\u0001\u0000\u0000" + + "\u0000\u0abf\u0ac0\u0007\u0016\u0000\u0000\u0ac0\u011b\u0001\u0000\u0000" + + "\u0000\u0ac1\u0ac3\u0003\u011e\u008f\u0000\u0ac2\u0ac4\u0003\u009eO\u0000" + + "\u0ac3\u0ac2\u0001\u0000\u0000\u0000\u0ac3\u0ac4\u0001\u0000\u0000\u0000" + + "\u0ac4\u0ac6\u0001\u0000\u0000\u0000\u0ac5\u0ac7\u0003\u009cN\u0000\u0ac6" + + "\u0ac5\u0001\u0000\u0000\u0000\u0ac6\u0ac7\u0001\u0000\u0000\u0000\u0ac7" + + "\u011d\u0001\u0000\u0000\u0000\u0ac8\u0ad3\u0003\u0120\u0090\u0000\u0ac9" + + "\u0acb\u0005\u0005\u0000\u0000\u0aca\u0ac9\u0001\u0000\u0000\u0000\u0acb" + + "\u0ace\u0001\u0000\u0000\u0000\u0acc\u0aca\u0001\u0000\u0000\u0000\u0acc" + + "\u0acd\u0001\u0000\u0000\u0000\u0acd\u0acf\u0001\u0000\u0000\u0000\u0ace" + + "\u0acc\u0001\u0000\u0000\u0000\u0acf\u0ad0\u0005\u0007\u0000\u0000\u0ad0" + + "\u0ad2\u0003\u0120\u0090\u0000\u0ad1\u0acc\u0001\u0000\u0000\u0000\u0ad2" + + "\u0ad5\u0001\u0000\u0000\u0000\u0ad3\u0ad1\u0001\u0000\u0000\u0000\u0ad3" + + "\u0ad4\u0001\u0000\u0000\u0000\u0ad4\u011f\u0001\u0000\u0000\u0000\u0ad5" + + "\u0ad3\u0001\u0000\u0000\u0000\u0ad6\u0ad7\u0007\u0017\u0000\u0000\u0ad7" + + "\u0121\u0001\u0000\u0000\u0000\u0ad8\u0ada\u0005\u0005\u0000\u0000\u0ad9" + + "\u0ad8\u0001\u0000\u0000\u0000\u0ada\u0adb\u0001\u0000\u0000\u0000\u0adb" + + "\u0ad9\u0001\u0000\u0000\u0000\u0adb\u0adc\u0001\u0000\u0000\u0000\u0adc" + + "\u0aeb\u0001\u0000\u0000\u0000\u0add\u0adf\u0005\u0005\u0000\u0000\u0ade" + + "\u0add\u0001\u0000\u0000\u0000\u0adf\u0ae2\u0001\u0000\u0000\u0000\u0ae0" + + "\u0ade\u0001\u0000\u0000\u0000\u0ae0\u0ae1\u0001\u0000\u0000\u0000\u0ae1" + + "\u0ae3\u0001\u0000\u0000\u0000\u0ae2\u0ae0\u0001\u0000\u0000\u0000\u0ae3" + + "\u0ae7\u0005\u001a\u0000\u0000\u0ae4\u0ae6\u0005\u0005\u0000\u0000\u0ae5" + + "\u0ae4\u0001\u0000\u0000\u0000\u0ae6\u0ae9\u0001\u0000\u0000\u0000\u0ae7" + + "\u0ae5\u0001\u0000\u0000\u0000\u0ae7\u0ae8\u0001\u0000\u0000\u0000\u0ae8" + + "\u0aeb\u0001\u0000\u0000\u0000\u0ae9\u0ae7\u0001\u0000\u0000\u0000\u0aea" + + "\u0ad9\u0001\u0000\u0000\u0000\u0aea\u0ae0\u0001\u0000\u0000\u0000\u0aeb" + + "\u0123\u0001\u0000\u0000\u0000\u0aec\u0aed\u0007\u0018\u0000\u0000\u0aed" + + "\u0125\u0001\u0000\u0000\u0000\u01ad\u0129\u0130\u0137\u013a\u013e\u0141" + + "\u0148\u014f\u0156\u0159\u015d\u0160\u0165\u016d\u0175\u017a\u017d\u0181" + + "\u0184\u0189\u018b\u0190\u0198\u019b\u01a5\u01a8\u01ae\u01b5\u01b9\u01be" + + "\u01c2\u01c7\u01ce\u01d2\u01d7\u01db\u01e0\u01e7\u01eb\u01ee\u01f4\u01f7" + + "\u0201\u0205\u0207\u020c\u020f\u0216\u021b\u0222\u0229\u022f\u0235\u023b" + + "\u0244\u024b\u0254\u025a\u0260\u026d\u0272\u0278\u027e\u0284\u028b\u0292" + + "\u0296\u029b\u029f\u02a5\u02ad\u02b1\u02b7\u02bb\u02c0\u02c7\u02cd\u02d0" + + "\u02d5\u02de\u02e3\u02e6\u02eb\u02f2\u02f6\u02fb\u02ff\u0304\u0308\u030b" + + "\u0311\u0318\u031d\u0322\u0326\u032b\u0332\u0337\u033c\u0340\u0345\u034c" + + "\u0353\u0357\u035c\u0360\u0365\u0369\u0371\u0375\u0377\u037c\u0381\u0388" + + "\u038d\u0394\u0398\u039b\u03a1\u03a8\u03ac\u03b1\u03b8\u03bc\u03c1\u03c5" + + "\u03c8\u03ce\u03d2\u03d8\u03dc\u03e1\u03e8\u03ec\u03f1\u03f5\u03f8\u03fe" + + "\u0402\u0407\u040e\u0413\u0418\u041d\u0422\u0426\u042b\u0432\u0436\u043b" + + "\u0442\u0447\u044e\u0450\u0458\u0460\u0463\u0467\u046d\u0475\u047c\u0480" + + "\u0485\u048d\u0491\u0493\u0496\u049a\u04a0\u04a6\u04a8\u04ad\u04b3\u04b8" + + "\u04bb\u04c1\u04c8\u04cc\u04d1\u04d8\u04e1\u04e8\u04ef\u04f5\u04fb\u04ff" + + "\u0504\u050a\u050f\u0514\u0519\u0520\u0524\u0527\u052d\u0534\u0537\u0539" + + "\u0541\u0546\u054c\u0554\u055a\u0561\u0564\u056a\u0571\u0579\u057f\u0586" + + "\u058c\u0593\u0597\u059d\u05a2\u05a7\u05ae\u05b3\u05b7\u05bd\u05c1\u05c6" + + "\u05cf\u05d6\u05dd\u05e3\u05e9\u05f0\u05f7\u0603\u060a\u060d\u0611\u0614" + + "\u0618\u061d\u0623\u062b\u0632\u063a\u0641\u0648\u064e\u0655\u065c\u0662" + + "\u066a\u0671\u0679\u067e\u0685\u068c\u0692\u0697\u069d\u06a4\u06aa\u06b2" + + "\u06b9\u06c1\u06c7\u06cf\u06d6\u06de\u06e5\u06ec\u06f4\u06fa\u0701\u0706" + + "\u0717\u071f\u0724\u072b\u0731\u0733\u0738\u073c\u0741\u074c\u074f\u0759" + + "\u075f\u0763\u0765\u076d\u0774\u077b\u0781\u0785\u078a\u078f\u0792\u0796" + + "\u079b\u07a1\u07a8\u07ab\u07ae\u07b3\u07c1\u07c5\u07ca\u07cc\u07d6\u07d8" + + "\u07ec\u07f3\u07fa\u0803\u080a\u0811\u0818\u081d\u0820\u0825\u082c\u0832" + + "\u083a\u0841\u0845\u0847\u084d\u0854\u0858\u085d\u0861\u0865\u086b\u0872" + + "\u0879\u0880\u0885\u0888\u088c\u0892\u089b\u089f\u08a2\u08a7\u08ae\u08b2" + + "\u08b4\u08b8\u08be\u08c5\u08ca\u08d1\u08d8\u08dd\u08e3\u08ec\u08f3\u08f9" + + "\u08ff\u0906\u090b\u0911\u0918\u091c\u0921\u0927\u0930\u0939\u0940\u0946" + + "\u094c\u0950\u0956\u095d\u0967\u0970\u0978\u097e\u0985\u098a\u0992\u0996" + + "\u099c\u09a5\u09a9\u09af\u09b3\u09b8\u09bf\u09ca\u09d0\u09d6\u09dd\u09e2" + + "\u09e5\u09ea\u09f1\u09f6\u09fc\u0a03\u0a07\u0a20\u0a2b\u0a31\u0a36\u0a3a" + + "\u0a3c\u0a47\u0a4c\u0a65\u0a6a\u0a6f\u0a76\u0a7d\u0a86\u0a8d\u0a93\u0a99" + + "\u0a9d\u0aa2\u0aa6\u0aa8\u0ab0\u0ab9\u0abd\u0ac3\u0ac6\u0acc\u0ad3\u0adb" + + "\u0ae0\u0ae7\u0aea"; + public static final String _serializedATN = Utils.join( + new String[]{ + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/KotlinParser.tokens b/src/main/java/KotlinParser.tokens new file mode 100644 index 0000000..fd7e064 --- /dev/null +++ b/src/main/java/KotlinParser.tokens @@ -0,0 +1,288 @@ +ShebangLine=1 +DelimitedComment=2 +LineComment=3 +WS=4 +NL=5 +RESERVED=6 +DOT=7 +COMMA=8 +LPAREN=9 +RPAREN=10 +LSQUARE=11 +RSQUARE=12 +LCURL=13 +RCURL=14 +MULT=15 +MOD=16 +DIV=17 +ADD=18 +SUB=19 +INCR=20 +DECR=21 +CONJ=22 +DISJ=23 +EXCL=24 +COLON=25 +SEMICOLON=26 +ASSIGNMENT=27 +ADD_ASSIGNMENT=28 +SUB_ASSIGNMENT=29 +MULT_ASSIGNMENT=30 +DIV_ASSIGNMENT=31 +MOD_ASSIGNMENT=32 +ARROW=33 +DOUBLE_ARROW=34 +RANGE=35 +COLONCOLON=36 +Q_COLONCOLON=37 +DOUBLE_SEMICOLON=38 +HASH=39 +AT=40 +QUEST=41 +ELVIS=42 +LANGLE=43 +RANGLE=44 +LE=45 +GE=46 +EXCL_EQ=47 +EXCL_EQEQ=48 +AS_SAFE=49 +EQEQ=50 +EQEQEQ=51 +SINGLE_QUOTE=52 +RETURN_AT=53 +CONTINUE_AT=54 +BREAK_AT=55 +FILE=56 +PACKAGE=57 +IMPORT=58 +CLASS=59 +INTERFACE=60 +FUN=61 +OBJECT=62 +VAL=63 +VAR=64 +TYPE_ALIAS=65 +CONSTRUCTOR=66 +BY=67 +COMPANION=68 +INIT=69 +THIS=70 +SUPER=71 +TYPEOF=72 +WHERE=73 +IF=74 +ELSE=75 +WHEN=76 +TRY=77 +CATCH=78 +FINALLY=79 +FOR=80 +DO=81 +WHILE=82 +THROW=83 +RETURN=84 +CONTINUE=85 +BREAK=86 +AS=87 +IS=88 +IN=89 +NOT_IS=90 +NOT_IN=91 +OUT=92 +FIELD=93 +PROPERTY=94 +GET=95 +SET=96 +GETTER=97 +SETTER=98 +RECEIVER=99 +PARAM=100 +SETPARAM=101 +DELEGATE=102 +DYNAMIC=103 +PUBLIC=104 +PRIVATE=105 +PROTECTED=106 +INTERNAL=107 +ENUM=108 +SEALED=109 +ANNOTATION=110 +DATA=111 +INNER=112 +TAILREC=113 +OPERATOR=114 +INLINE=115 +INFIX=116 +EXTERNAL=117 +SUSPEND=118 +OVERRIDE=119 +ABSTRACT=120 +FINAL=121 +OPEN=122 +CONST=123 +LATEINIT=124 +VARARG=125 +NOINLINE=126 +CROSSINLINE=127 +REIFIED=128 +QUOTE_OPEN=129 +TRIPLE_QUOTE_OPEN=130 +RealLiteral=131 +FloatLiteral=132 +DoubleLiteral=133 +LongLiteral=134 +IntegerLiteral=135 +HexLiteral=136 +BinLiteral=137 +BooleanLiteral=138 +NullLiteral=139 +Identifier=140 +LabelReference=141 +LabelDefinition=142 +FieldIdentifier=143 +CharacterLiteral=144 +UNICODE_CLASS_LL=145 +UNICODE_CLASS_LM=146 +UNICODE_CLASS_LO=147 +UNICODE_CLASS_LT=148 +UNICODE_CLASS_LU=149 +UNICODE_CLASS_ND=150 +UNICODE_CLASS_NL=151 +Inside_Comment=152 +Inside_WS=153 +Inside_NL=154 +QUOTE_CLOSE=155 +LineStrRef=156 +LineStrText=157 +LineStrEscapedChar=158 +LineStrExprStart=159 +TRIPLE_QUOTE_CLOSE=160 +MultiLineStringQuote=161 +MultiLineStrRef=162 +MultiLineStrText=163 +MultiLineStrEscapedChar=164 +MultiLineStrExprStart=165 +MultiLineNL=166 +StrExpr_IN=167 +StrExpr_Comment=168 +StrExpr_WS=169 +StrExpr_NL=170 +'...'=6 +'.'=7 +','=8 +'('=9 +'['=11 +'{'=13 +'}'=14 +'*'=15 +'%'=16 +'/'=17 +'+'=18 +'-'=19 +'++'=20 +'--'=21 +'&&'=22 +'||'=23 +'!'=24 +':'=25 +';'=26 +'='=27 +'+='=28 +'-='=29 +'*='=30 +'/='=31 +'%='=32 +'->'=33 +'=>'=34 +'..'=35 +'::'=36 +'?::'=37 +';;'=38 +'#'=39 +'@'=40 +'?'=41 +'?:'=42 +'<'=43 +'>'=44 +'<='=45 +'>='=46 +'!='=47 +'!=='=48 +'as?'=49 +'=='=50 +'==='=51 +'\''=52 +'@file'=56 +'package'=57 +'import'=58 +'class'=59 +'interface'=60 +'fun'=61 +'object'=62 +'val'=63 +'var'=64 +'typealias'=65 +'constructor'=66 +'by'=67 +'companion'=68 +'init'=69 +'this'=70 +'super'=71 +'typeof'=72 +'where'=73 +'if'=74 +'else'=75 +'when'=76 +'try'=77 +'catch'=78 +'finally'=79 +'for'=80 +'do'=81 +'while'=82 +'throw'=83 +'return'=84 +'continue'=85 +'break'=86 +'as'=87 +'is'=88 +'in'=89 +'out'=92 +'@field'=93 +'@property'=94 +'@get'=95 +'@set'=96 +'get'=97 +'set'=98 +'@receiver'=99 +'@param'=100 +'@setparam'=101 +'@delegate'=102 +'dynamic'=103 +'public'=104 +'private'=105 +'protected'=106 +'internal'=107 +'enum'=108 +'sealed'=109 +'annotation'=110 +'data'=111 +'inner'=112 +'tailrec'=113 +'operator'=114 +'inline'=115 +'infix'=116 +'external'=117 +'suspend'=118 +'override'=119 +'abstract'=120 +'final'=121 +'open'=122 +'const'=123 +'lateinit'=124 +'vararg'=125 +'noinline'=126 +'crossinline'=127 +'reified'=128 +'"""'=130 +'null'=139 diff --git a/src/main/java/KotlinParserBaseListener.java b/src/main/java/KotlinParserBaseListener.java new file mode 100644 index 0000000..7e6fb89 --- /dev/null +++ b/src/main/java/KotlinParserBaseListener.java @@ -0,0 +1,2695 @@ +// Generated from KotlinParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link KotlinParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class KotlinParserBaseListener implements KotlinParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKotlinFile(KotlinParser.KotlinFileContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKotlinFile(KotlinParser.KotlinFileContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterScript(KotlinParser.ScriptContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitScript(KotlinParser.ScriptContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPreamble(KotlinParser.PreambleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPreamble(KotlinParser.PreambleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFileAnnotations(KotlinParser.FileAnnotationsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFileAnnotations(KotlinParser.FileAnnotationsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPackageHeader(KotlinParser.PackageHeaderContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPackageHeader(KotlinParser.PackageHeaderContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImportList(KotlinParser.ImportListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImportList(KotlinParser.ImportListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImportHeader(KotlinParser.ImportHeaderContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImportHeader(KotlinParser.ImportHeaderContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImportAlias(KotlinParser.ImportAliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImportAlias(KotlinParser.ImportAliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassParameters(KotlinParser.ClassParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassParameters(KotlinParser.ClassParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassParameter(KotlinParser.ClassParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassParameter(KotlinParser.ClassParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassBody(KotlinParser.ClassBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassBody(KotlinParser.ClassBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEnumEntries(KotlinParser.EnumEntriesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEnumEntries(KotlinParser.EnumEntriesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEnumEntry(KotlinParser.EnumEntryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEnumEntry(KotlinParser.EnumEntryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParameter(KotlinParser.ParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParameter(KotlinParser.ParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterReceiverType(KotlinParser.ReceiverTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitReceiverType(KotlinParser.ReceiverTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionBody(KotlinParser.FunctionBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionBody(KotlinParser.FunctionBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCompanionObject(KotlinParser.CompanionObjectContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCompanionObject(KotlinParser.CompanionObjectContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGetter(KotlinParser.GetterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGetter(KotlinParser.GetterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSetter(KotlinParser.SetterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSetter(KotlinParser.SetterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeAlias(KotlinParser.TypeAliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeAlias(KotlinParser.TypeAliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeParameters(KotlinParser.TypeParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeParameters(KotlinParser.TypeParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeParameter(KotlinParser.TypeParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeParameter(KotlinParser.TypeParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType(KotlinParser.TypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType(KotlinParser.TypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeModifierList(KotlinParser.TypeModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeModifierList(KotlinParser.TypeModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNullableType(KotlinParser.NullableTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNullableType(KotlinParser.NullableTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeReference(KotlinParser.TypeReferenceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeReference(KotlinParser.TypeReferenceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionType(KotlinParser.FunctionTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionType(KotlinParser.FunctionTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionTypeReceiver(KotlinParser.FunctionTypeReceiverContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionTypeReceiver(KotlinParser.FunctionTypeReceiverContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterUserType(KotlinParser.UserTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitUserType(KotlinParser.UserTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBlock(KotlinParser.BlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBlock(KotlinParser.BlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStatements(KotlinParser.StatementsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStatements(KotlinParser.StatementsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStatement(KotlinParser.StatementContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStatement(KotlinParser.StatementContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBlockLevelExpression(KotlinParser.BlockLevelExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBlockLevelExpression(KotlinParser.BlockLevelExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDeclaration(KotlinParser.DeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDeclaration(KotlinParser.DeclarationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExpression(KotlinParser.ExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExpression(KotlinParser.ExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDisjunction(KotlinParser.DisjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDisjunction(KotlinParser.DisjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterConjunction(KotlinParser.ConjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitConjunction(KotlinParser.ConjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEqualityComparison(KotlinParser.EqualityComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEqualityComparison(KotlinParser.EqualityComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterComparison(KotlinParser.ComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitComparison(KotlinParser.ComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNamedInfix(KotlinParser.NamedInfixContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNamedInfix(KotlinParser.NamedInfixContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterRangeExpression(KotlinParser.RangeExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitRangeExpression(KotlinParser.RangeExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeRHS(KotlinParser.TypeRHSContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeRHS(KotlinParser.TypeRHSContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAtomicExpression(KotlinParser.AtomicExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAtomicExpression(KotlinParser.AtomicExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCallSuffix(KotlinParser.CallSuffixContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCallSuffix(KotlinParser.CallSuffixContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterArrayAccess(KotlinParser.ArrayAccessContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitArrayAccess(KotlinParser.ArrayAccessContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterValueArguments(KotlinParser.ValueArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitValueArguments(KotlinParser.ValueArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeProjection(KotlinParser.TypeProjectionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeProjection(KotlinParser.TypeProjectionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeProjectionModifierList(KotlinParser.TypeProjectionModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeProjectionModifierList(KotlinParser.TypeProjectionModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterValueArgument(KotlinParser.ValueArgumentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitValueArgument(KotlinParser.ValueArgumentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStringLiteral(KotlinParser.StringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStringLiteral(KotlinParser.StringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLineStringContent(KotlinParser.LineStringContentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLineStringContent(KotlinParser.LineStringContentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterThisExpression(KotlinParser.ThisExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitThisExpression(KotlinParser.ThisExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSuperExpression(KotlinParser.SuperExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSuperExpression(KotlinParser.SuperExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterConditionalExpression(KotlinParser.ConditionalExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitConditionalExpression(KotlinParser.ConditionalExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIfExpression(KotlinParser.IfExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIfExpression(KotlinParser.IfExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWhenExpression(KotlinParser.WhenExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWhenExpression(KotlinParser.WhenExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWhenEntry(KotlinParser.WhenEntryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWhenEntry(KotlinParser.WhenEntryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWhenCondition(KotlinParser.WhenConditionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWhenCondition(KotlinParser.WhenConditionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterRangeTest(KotlinParser.RangeTestContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitRangeTest(KotlinParser.RangeTestContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeTest(KotlinParser.TypeTestContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeTest(KotlinParser.TypeTestContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTryExpression(KotlinParser.TryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTryExpression(KotlinParser.TryExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCatchBlock(KotlinParser.CatchBlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCatchBlock(KotlinParser.CatchBlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLoopExpression(KotlinParser.LoopExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLoopExpression(KotlinParser.LoopExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterForExpression(KotlinParser.ForExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitForExpression(KotlinParser.ForExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWhileExpression(KotlinParser.WhileExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWhileExpression(KotlinParser.WhileExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDoWhileExpression(KotlinParser.DoWhileExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDoWhileExpression(KotlinParser.DoWhileExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterJumpExpression(KotlinParser.JumpExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitJumpExpression(KotlinParser.JumpExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCallableReference(KotlinParser.CallableReferenceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCallableReference(KotlinParser.CallableReferenceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAssignmentOperator(KotlinParser.AssignmentOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAssignmentOperator(KotlinParser.AssignmentOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEqualityOperation(KotlinParser.EqualityOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEqualityOperation(KotlinParser.EqualityOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterInOperator(KotlinParser.InOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitInOperator(KotlinParser.InOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIsOperator(KotlinParser.IsOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIsOperator(KotlinParser.IsOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMultiplicativeOperation(KotlinParser.MultiplicativeOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMultiplicativeOperation(KotlinParser.MultiplicativeOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeOperation(KotlinParser.TypeOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeOperation(KotlinParser.TypeOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPrefixUnaryOperation(KotlinParser.PrefixUnaryOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPrefixUnaryOperation(KotlinParser.PrefixUnaryOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPostfixUnaryOperation(KotlinParser.PostfixUnaryOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPostfixUnaryOperation(KotlinParser.PostfixUnaryOperationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterModifierList(KotlinParser.ModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitModifierList(KotlinParser.ModifierListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterModifier(KotlinParser.ModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitModifier(KotlinParser.ModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClassModifier(KotlinParser.ClassModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClassModifier(KotlinParser.ClassModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMemberModifier(KotlinParser.MemberModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMemberModifier(KotlinParser.MemberModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterVarianceAnnotation(KotlinParser.VarianceAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitVarianceAnnotation(KotlinParser.VarianceAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParameterModifier(KotlinParser.ParameterModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParameterModifier(KotlinParser.ParameterModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLabelDefinition(KotlinParser.LabelDefinitionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLabelDefinition(KotlinParser.LabelDefinitionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotations(KotlinParser.AnnotationsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotations(KotlinParser.AnnotationsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotation(KotlinParser.AnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotation(KotlinParser.AnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotationList(KotlinParser.AnnotationListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotationList(KotlinParser.AnnotationListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIdentifier(KotlinParser.IdentifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIdentifier(KotlinParser.IdentifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSemi(KotlinParser.SemiContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSemi(KotlinParser.SemiContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnysemi(KotlinParser.AnysemiContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnysemi(KotlinParser.AnysemiContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEveryRule(ParserRuleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEveryRule(ParserRuleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void visitTerminal(TerminalNode node) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void visitErrorNode(ErrorNode node) { + } +} \ No newline at end of file diff --git a/src/main/java/KotlinParserListener.java b/src/main/java/KotlinParserListener.java new file mode 100644 index 0000000..79af7d1 --- /dev/null +++ b/src/main/java/KotlinParserListener.java @@ -0,0 +1,2067 @@ +// Generated from KotlinParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link KotlinParser}. + */ +public interface KotlinParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link KotlinParser#kotlinFile}. + * + * @param ctx the parse tree + */ + void enterKotlinFile(KotlinParser.KotlinFileContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#kotlinFile}. + * + * @param ctx the parse tree + */ + void exitKotlinFile(KotlinParser.KotlinFileContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#script}. + * + * @param ctx the parse tree + */ + void enterScript(KotlinParser.ScriptContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#script}. + * + * @param ctx the parse tree + */ + void exitScript(KotlinParser.ScriptContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#preamble}. + * + * @param ctx the parse tree + */ + void enterPreamble(KotlinParser.PreambleContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#preamble}. + * + * @param ctx the parse tree + */ + void exitPreamble(KotlinParser.PreambleContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#fileAnnotations}. + * + * @param ctx the parse tree + */ + void enterFileAnnotations(KotlinParser.FileAnnotationsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#fileAnnotations}. + * + * @param ctx the parse tree + */ + void exitFileAnnotations(KotlinParser.FileAnnotationsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#fileAnnotation}. + * + * @param ctx the parse tree + */ + void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#fileAnnotation}. + * + * @param ctx the parse tree + */ + void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#packageHeader}. + * + * @param ctx the parse tree + */ + void enterPackageHeader(KotlinParser.PackageHeaderContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#packageHeader}. + * + * @param ctx the parse tree + */ + void exitPackageHeader(KotlinParser.PackageHeaderContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#importList}. + * + * @param ctx the parse tree + */ + void enterImportList(KotlinParser.ImportListContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#importList}. + * + * @param ctx the parse tree + */ + void exitImportList(KotlinParser.ImportListContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#importHeader}. + * + * @param ctx the parse tree + */ + void enterImportHeader(KotlinParser.ImportHeaderContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#importHeader}. + * + * @param ctx the parse tree + */ + void exitImportHeader(KotlinParser.ImportHeaderContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#importAlias}. + * + * @param ctx the parse tree + */ + void enterImportAlias(KotlinParser.ImportAliasContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#importAlias}. + * + * @param ctx the parse tree + */ + void exitImportAlias(KotlinParser.ImportAliasContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#topLevelObject}. + * + * @param ctx the parse tree + */ + void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#topLevelObject}. + * + * @param ctx the parse tree + */ + void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classDeclaration}. + * + * @param ctx the parse tree + */ + void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classDeclaration}. + * + * @param ctx the parse tree + */ + void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#primaryConstructor}. + * + * @param ctx the parse tree + */ + void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#primaryConstructor}. + * + * @param ctx the parse tree + */ + void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classParameters}. + * + * @param ctx the parse tree + */ + void enterClassParameters(KotlinParser.ClassParametersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classParameters}. + * + * @param ctx the parse tree + */ + void exitClassParameters(KotlinParser.ClassParametersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classParameter}. + * + * @param ctx the parse tree + */ + void enterClassParameter(KotlinParser.ClassParameterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classParameter}. + * + * @param ctx the parse tree + */ + void exitClassParameter(KotlinParser.ClassParameterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#delegationSpecifiers}. + * + * @param ctx the parse tree + */ + void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#delegationSpecifiers}. + * + * @param ctx the parse tree + */ + void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#delegationSpecifier}. + * + * @param ctx the parse tree + */ + void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#delegationSpecifier}. + * + * @param ctx the parse tree + */ + void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#constructorInvocation}. + * + * @param ctx the parse tree + */ + void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#constructorInvocation}. + * + * @param ctx the parse tree + */ + void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#explicitDelegation}. + * + * @param ctx the parse tree + */ + void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#explicitDelegation}. + * + * @param ctx the parse tree + */ + void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classBody}. + * + * @param ctx the parse tree + */ + void enterClassBody(KotlinParser.ClassBodyContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classBody}. + * + * @param ctx the parse tree + */ + void exitClassBody(KotlinParser.ClassBodyContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classMemberDeclaration}. + * + * @param ctx the parse tree + */ + void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classMemberDeclaration}. + * + * @param ctx the parse tree + */ + void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#anonymousInitializer}. + * + * @param ctx the parse tree + */ + void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#anonymousInitializer}. + * + * @param ctx the parse tree + */ + void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#secondaryConstructor}. + * + * @param ctx the parse tree + */ + void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#secondaryConstructor}. + * + * @param ctx the parse tree + */ + void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#constructorDelegationCall}. + * + * @param ctx the parse tree + */ + void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#constructorDelegationCall}. + * + * @param ctx the parse tree + */ + void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#enumClassBody}. + * + * @param ctx the parse tree + */ + void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#enumClassBody}. + * + * @param ctx the parse tree + */ + void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#enumEntries}. + * + * @param ctx the parse tree + */ + void enterEnumEntries(KotlinParser.EnumEntriesContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#enumEntries}. + * + * @param ctx the parse tree + */ + void exitEnumEntries(KotlinParser.EnumEntriesContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#enumEntry}. + * + * @param ctx the parse tree + */ + void enterEnumEntry(KotlinParser.EnumEntryContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#enumEntry}. + * + * @param ctx the parse tree + */ + void exitEnumEntry(KotlinParser.EnumEntryContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionDeclaration}. + * + * @param ctx the parse tree + */ + void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionDeclaration}. + * + * @param ctx the parse tree + */ + void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionValueParameters}. + * + * @param ctx the parse tree + */ + void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionValueParameters}. + * + * @param ctx the parse tree + */ + void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionValueParameter}. + * + * @param ctx the parse tree + */ + void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionValueParameter}. + * + * @param ctx the parse tree + */ + void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#parameter}. + * + * @param ctx the parse tree + */ + void enterParameter(KotlinParser.ParameterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#parameter}. + * + * @param ctx the parse tree + */ + void exitParameter(KotlinParser.ParameterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#receiverType}. + * + * @param ctx the parse tree + */ + void enterReceiverType(KotlinParser.ReceiverTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#receiverType}. + * + * @param ctx the parse tree + */ + void exitReceiverType(KotlinParser.ReceiverTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionBody}. + * + * @param ctx the parse tree + */ + void enterFunctionBody(KotlinParser.FunctionBodyContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionBody}. + * + * @param ctx the parse tree + */ + void exitFunctionBody(KotlinParser.FunctionBodyContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#objectDeclaration}. + * + * @param ctx the parse tree + */ + void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#objectDeclaration}. + * + * @param ctx the parse tree + */ + void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#companionObject}. + * + * @param ctx the parse tree + */ + void enterCompanionObject(KotlinParser.CompanionObjectContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#companionObject}. + * + * @param ctx the parse tree + */ + void exitCompanionObject(KotlinParser.CompanionObjectContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#propertyDeclaration}. + * + * @param ctx the parse tree + */ + void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#propertyDeclaration}. + * + * @param ctx the parse tree + */ + void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. + * + * @param ctx the parse tree + */ + void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. + * + * @param ctx the parse tree + */ + void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#variableDeclaration}. + * + * @param ctx the parse tree + */ + void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#variableDeclaration}. + * + * @param ctx the parse tree + */ + void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#getter}. + * + * @param ctx the parse tree + */ + void enterGetter(KotlinParser.GetterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#getter}. + * + * @param ctx the parse tree + */ + void exitGetter(KotlinParser.GetterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#setter}. + * + * @param ctx the parse tree + */ + void enterSetter(KotlinParser.SetterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#setter}. + * + * @param ctx the parse tree + */ + void exitSetter(KotlinParser.SetterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeAlias}. + * + * @param ctx the parse tree + */ + void enterTypeAlias(KotlinParser.TypeAliasContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeAlias}. + * + * @param ctx the parse tree + */ + void exitTypeAlias(KotlinParser.TypeAliasContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameters}. + * + * @param ctx the parse tree + */ + void enterTypeParameters(KotlinParser.TypeParametersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameters}. + * + * @param ctx the parse tree + */ + void exitTypeParameters(KotlinParser.TypeParametersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameter}. + * + * @param ctx the parse tree + */ + void enterTypeParameter(KotlinParser.TypeParameterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameter}. + * + * @param ctx the parse tree + */ + void exitTypeParameter(KotlinParser.TypeParameterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#type}. + * + * @param ctx the parse tree + */ + void enterType(KotlinParser.TypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#type}. + * + * @param ctx the parse tree + */ + void exitType(KotlinParser.TypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeModifierList}. + * + * @param ctx the parse tree + */ + void enterTypeModifierList(KotlinParser.TypeModifierListContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeModifierList}. + * + * @param ctx the parse tree + */ + void exitTypeModifierList(KotlinParser.TypeModifierListContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedType}. + * + * @param ctx the parse tree + */ + void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedType}. + * + * @param ctx the parse tree + */ + void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#nullableType}. + * + * @param ctx the parse tree + */ + void enterNullableType(KotlinParser.NullableTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#nullableType}. + * + * @param ctx the parse tree + */ + void exitNullableType(KotlinParser.NullableTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeReference}. + * + * @param ctx the parse tree + */ + void enterTypeReference(KotlinParser.TypeReferenceContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeReference}. + * + * @param ctx the parse tree + */ + void exitTypeReference(KotlinParser.TypeReferenceContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionType}. + * + * @param ctx the parse tree + */ + void enterFunctionType(KotlinParser.FunctionTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionType}. + * + * @param ctx the parse tree + */ + void exitFunctionType(KotlinParser.FunctionTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionTypeReceiver}. + * + * @param ctx the parse tree + */ + void enterFunctionTypeReceiver(KotlinParser.FunctionTypeReceiverContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionTypeReceiver}. + * + * @param ctx the parse tree + */ + void exitFunctionTypeReceiver(KotlinParser.FunctionTypeReceiverContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#userType}. + * + * @param ctx the parse tree + */ + void enterUserType(KotlinParser.UserTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#userType}. + * + * @param ctx the parse tree + */ + void exitUserType(KotlinParser.UserTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#simpleUserType}. + * + * @param ctx the parse tree + */ + void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#simpleUserType}. + * + * @param ctx the parse tree + */ + void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionTypeParameters}. + * + * @param ctx the parse tree + */ + void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionTypeParameters}. + * + * @param ctx the parse tree + */ + void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeConstraints}. + * + * @param ctx the parse tree + */ + void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeConstraints}. + * + * @param ctx the parse tree + */ + void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeConstraint}. + * + * @param ctx the parse tree + */ + void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeConstraint}. + * + * @param ctx the parse tree + */ + void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#block}. + * + * @param ctx the parse tree + */ + void enterBlock(KotlinParser.BlockContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#block}. + * + * @param ctx the parse tree + */ + void exitBlock(KotlinParser.BlockContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#statements}. + * + * @param ctx the parse tree + */ + void enterStatements(KotlinParser.StatementsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#statements}. + * + * @param ctx the parse tree + */ + void exitStatements(KotlinParser.StatementsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#statement}. + * + * @param ctx the parse tree + */ + void enterStatement(KotlinParser.StatementContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#statement}. + * + * @param ctx the parse tree + */ + void exitStatement(KotlinParser.StatementContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#blockLevelExpression}. + * + * @param ctx the parse tree + */ + void enterBlockLevelExpression(KotlinParser.BlockLevelExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#blockLevelExpression}. + * + * @param ctx the parse tree + */ + void exitBlockLevelExpression(KotlinParser.BlockLevelExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#declaration}. + * + * @param ctx the parse tree + */ + void enterDeclaration(KotlinParser.DeclarationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#declaration}. + * + * @param ctx the parse tree + */ + void exitDeclaration(KotlinParser.DeclarationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#expression}. + * + * @param ctx the parse tree + */ + void enterExpression(KotlinParser.ExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#expression}. + * + * @param ctx the parse tree + */ + void exitExpression(KotlinParser.ExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#disjunction}. + * + * @param ctx the parse tree + */ + void enterDisjunction(KotlinParser.DisjunctionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#disjunction}. + * + * @param ctx the parse tree + */ + void exitDisjunction(KotlinParser.DisjunctionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#conjunction}. + * + * @param ctx the parse tree + */ + void enterConjunction(KotlinParser.ConjunctionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#conjunction}. + * + * @param ctx the parse tree + */ + void exitConjunction(KotlinParser.ConjunctionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#equalityComparison}. + * + * @param ctx the parse tree + */ + void enterEqualityComparison(KotlinParser.EqualityComparisonContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#equalityComparison}. + * + * @param ctx the parse tree + */ + void exitEqualityComparison(KotlinParser.EqualityComparisonContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#comparison}. + * + * @param ctx the parse tree + */ + void enterComparison(KotlinParser.ComparisonContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#comparison}. + * + * @param ctx the parse tree + */ + void exitComparison(KotlinParser.ComparisonContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#namedInfix}. + * + * @param ctx the parse tree + */ + void enterNamedInfix(KotlinParser.NamedInfixContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#namedInfix}. + * + * @param ctx the parse tree + */ + void exitNamedInfix(KotlinParser.NamedInfixContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#elvisExpression}. + * + * @param ctx the parse tree + */ + void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#elvisExpression}. + * + * @param ctx the parse tree + */ + void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#infixFunctionCall}. + * + * @param ctx the parse tree + */ + void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#infixFunctionCall}. + * + * @param ctx the parse tree + */ + void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#rangeExpression}. + * + * @param ctx the parse tree + */ + void enterRangeExpression(KotlinParser.RangeExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#rangeExpression}. + * + * @param ctx the parse tree + */ + void exitRangeExpression(KotlinParser.RangeExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#additiveExpression}. + * + * @param ctx the parse tree + */ + void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#additiveExpression}. + * + * @param ctx the parse tree + */ + void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeRHS}. + * + * @param ctx the parse tree + */ + void enterTypeRHS(KotlinParser.TypeRHSContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeRHS}. + * + * @param ctx the parse tree + */ + void exitTypeRHS(KotlinParser.TypeRHSContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. + * + * @param ctx the parse tree + */ + void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. + * + * @param ctx the parse tree + */ + void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. + * + * @param ctx the parse tree + */ + void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. + * + * @param ctx the parse tree + */ + void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#atomicExpression}. + * + * @param ctx the parse tree + */ + void enterAtomicExpression(KotlinParser.AtomicExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#atomicExpression}. + * + * @param ctx the parse tree + */ + void exitAtomicExpression(KotlinParser.AtomicExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedExpression}. + * + * @param ctx the parse tree + */ + void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedExpression}. + * + * @param ctx the parse tree + */ + void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#callSuffix}. + * + * @param ctx the parse tree + */ + void enterCallSuffix(KotlinParser.CallSuffixContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#callSuffix}. + * + * @param ctx the parse tree + */ + void exitCallSuffix(KotlinParser.CallSuffixContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#annotatedLambda}. + * + * @param ctx the parse tree + */ + void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#annotatedLambda}. + * + * @param ctx the parse tree + */ + void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#arrayAccess}. + * + * @param ctx the parse tree + */ + void enterArrayAccess(KotlinParser.ArrayAccessContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#arrayAccess}. + * + * @param ctx the parse tree + */ + void exitArrayAccess(KotlinParser.ArrayAccessContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#valueArguments}. + * + * @param ctx the parse tree + */ + void enterValueArguments(KotlinParser.ValueArgumentsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#valueArguments}. + * + * @param ctx the parse tree + */ + void exitValueArguments(KotlinParser.ValueArgumentsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeArguments}. + * + * @param ctx the parse tree + */ + void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeArguments}. + * + * @param ctx the parse tree + */ + void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeProjection}. + * + * @param ctx the parse tree + */ + void enterTypeProjection(KotlinParser.TypeProjectionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeProjection}. + * + * @param ctx the parse tree + */ + void exitTypeProjection(KotlinParser.TypeProjectionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifierList}. + * + * @param ctx the parse tree + */ + void enterTypeProjectionModifierList(KotlinParser.TypeProjectionModifierListContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifierList}. + * + * @param ctx the parse tree + */ + void exitTypeProjectionModifierList(KotlinParser.TypeProjectionModifierListContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#valueArgument}. + * + * @param ctx the parse tree + */ + void enterValueArgument(KotlinParser.ValueArgumentContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#valueArgument}. + * + * @param ctx the parse tree + */ + void exitValueArgument(KotlinParser.ValueArgumentContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#literalConstant}. + * + * @param ctx the parse tree + */ + void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#literalConstant}. + * + * @param ctx the parse tree + */ + void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#stringLiteral}. + * + * @param ctx the parse tree + */ + void enterStringLiteral(KotlinParser.StringLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#stringLiteral}. + * + * @param ctx the parse tree + */ + void exitStringLiteral(KotlinParser.StringLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringLiteral}. + * + * @param ctx the parse tree + */ + void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringLiteral}. + * + * @param ctx the parse tree + */ + void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringContent}. + * + * @param ctx the parse tree + */ + void enterLineStringContent(KotlinParser.LineStringContentContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringContent}. + * + * @param ctx the parse tree + */ + void exitLineStringContent(KotlinParser.LineStringContentContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringExpression}. + * + * @param ctx the parse tree + */ + void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringExpression}. + * + * @param ctx the parse tree + */ + void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringContent}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringContent}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringExpression}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringExpression}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionLiteral}. + * + * @param ctx the parse tree + */ + void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionLiteral}. + * + * @param ctx the parse tree + */ + void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#lambdaParameters}. + * + * @param ctx the parse tree + */ + void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#lambdaParameters}. + * + * @param ctx the parse tree + */ + void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#lambdaParameter}. + * + * @param ctx the parse tree + */ + void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#lambdaParameter}. + * + * @param ctx the parse tree + */ + void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#objectLiteral}. + * + * @param ctx the parse tree + */ + void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#objectLiteral}. + * + * @param ctx the parse tree + */ + void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#collectionLiteral}. + * + * @param ctx the parse tree + */ + void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#collectionLiteral}. + * + * @param ctx the parse tree + */ + void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#thisExpression}. + * + * @param ctx the parse tree + */ + void enterThisExpression(KotlinParser.ThisExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#thisExpression}. + * + * @param ctx the parse tree + */ + void exitThisExpression(KotlinParser.ThisExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#superExpression}. + * + * @param ctx the parse tree + */ + void enterSuperExpression(KotlinParser.SuperExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#superExpression}. + * + * @param ctx the parse tree + */ + void exitSuperExpression(KotlinParser.SuperExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#conditionalExpression}. + * + * @param ctx the parse tree + */ + void enterConditionalExpression(KotlinParser.ConditionalExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#conditionalExpression}. + * + * @param ctx the parse tree + */ + void exitConditionalExpression(KotlinParser.ConditionalExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#ifExpression}. + * + * @param ctx the parse tree + */ + void enterIfExpression(KotlinParser.IfExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#ifExpression}. + * + * @param ctx the parse tree + */ + void exitIfExpression(KotlinParser.IfExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#controlStructureBody}. + * + * @param ctx the parse tree + */ + void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#controlStructureBody}. + * + * @param ctx the parse tree + */ + void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#whenExpression}. + * + * @param ctx the parse tree + */ + void enterWhenExpression(KotlinParser.WhenExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#whenExpression}. + * + * @param ctx the parse tree + */ + void exitWhenExpression(KotlinParser.WhenExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#whenEntry}. + * + * @param ctx the parse tree + */ + void enterWhenEntry(KotlinParser.WhenEntryContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#whenEntry}. + * + * @param ctx the parse tree + */ + void exitWhenEntry(KotlinParser.WhenEntryContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#whenCondition}. + * + * @param ctx the parse tree + */ + void enterWhenCondition(KotlinParser.WhenConditionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#whenCondition}. + * + * @param ctx the parse tree + */ + void exitWhenCondition(KotlinParser.WhenConditionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#rangeTest}. + * + * @param ctx the parse tree + */ + void enterRangeTest(KotlinParser.RangeTestContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#rangeTest}. + * + * @param ctx the parse tree + */ + void exitRangeTest(KotlinParser.RangeTestContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeTest}. + * + * @param ctx the parse tree + */ + void enterTypeTest(KotlinParser.TypeTestContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeTest}. + * + * @param ctx the parse tree + */ + void exitTypeTest(KotlinParser.TypeTestContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#tryExpression}. + * + * @param ctx the parse tree + */ + void enterTryExpression(KotlinParser.TryExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#tryExpression}. + * + * @param ctx the parse tree + */ + void exitTryExpression(KotlinParser.TryExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#catchBlock}. + * + * @param ctx the parse tree + */ + void enterCatchBlock(KotlinParser.CatchBlockContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#catchBlock}. + * + * @param ctx the parse tree + */ + void exitCatchBlock(KotlinParser.CatchBlockContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#finallyBlock}. + * + * @param ctx the parse tree + */ + void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#finallyBlock}. + * + * @param ctx the parse tree + */ + void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#loopExpression}. + * + * @param ctx the parse tree + */ + void enterLoopExpression(KotlinParser.LoopExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#loopExpression}. + * + * @param ctx the parse tree + */ + void exitLoopExpression(KotlinParser.LoopExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#forExpression}. + * + * @param ctx the parse tree + */ + void enterForExpression(KotlinParser.ForExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#forExpression}. + * + * @param ctx the parse tree + */ + void exitForExpression(KotlinParser.ForExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#whileExpression}. + * + * @param ctx the parse tree + */ + void enterWhileExpression(KotlinParser.WhileExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#whileExpression}. + * + * @param ctx the parse tree + */ + void exitWhileExpression(KotlinParser.WhileExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#doWhileExpression}. + * + * @param ctx the parse tree + */ + void enterDoWhileExpression(KotlinParser.DoWhileExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#doWhileExpression}. + * + * @param ctx the parse tree + */ + void exitDoWhileExpression(KotlinParser.DoWhileExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#jumpExpression}. + * + * @param ctx the parse tree + */ + void enterJumpExpression(KotlinParser.JumpExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#jumpExpression}. + * + * @param ctx the parse tree + */ + void exitJumpExpression(KotlinParser.JumpExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#callableReference}. + * + * @param ctx the parse tree + */ + void enterCallableReference(KotlinParser.CallableReferenceContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#callableReference}. + * + * @param ctx the parse tree + */ + void exitCallableReference(KotlinParser.CallableReferenceContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#assignmentOperator}. + * + * @param ctx the parse tree + */ + void enterAssignmentOperator(KotlinParser.AssignmentOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#assignmentOperator}. + * + * @param ctx the parse tree + */ + void exitAssignmentOperator(KotlinParser.AssignmentOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#equalityOperation}. + * + * @param ctx the parse tree + */ + void enterEqualityOperation(KotlinParser.EqualityOperationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#equalityOperation}. + * + * @param ctx the parse tree + */ + void exitEqualityOperation(KotlinParser.EqualityOperationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#comparisonOperator}. + * + * @param ctx the parse tree + */ + void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#comparisonOperator}. + * + * @param ctx the parse tree + */ + void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#inOperator}. + * + * @param ctx the parse tree + */ + void enterInOperator(KotlinParser.InOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#inOperator}. + * + * @param ctx the parse tree + */ + void exitInOperator(KotlinParser.InOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#isOperator}. + * + * @param ctx the parse tree + */ + void enterIsOperator(KotlinParser.IsOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#isOperator}. + * + * @param ctx the parse tree + */ + void exitIsOperator(KotlinParser.IsOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#additiveOperator}. + * + * @param ctx the parse tree + */ + void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#additiveOperator}. + * + * @param ctx the parse tree + */ + void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#multiplicativeOperation}. + * + * @param ctx the parse tree + */ + void enterMultiplicativeOperation(KotlinParser.MultiplicativeOperationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#multiplicativeOperation}. + * + * @param ctx the parse tree + */ + void exitMultiplicativeOperation(KotlinParser.MultiplicativeOperationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeOperation}. + * + * @param ctx the parse tree + */ + void enterTypeOperation(KotlinParser.TypeOperationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeOperation}. + * + * @param ctx the parse tree + */ + void exitTypeOperation(KotlinParser.TypeOperationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#prefixUnaryOperation}. + * + * @param ctx the parse tree + */ + void enterPrefixUnaryOperation(KotlinParser.PrefixUnaryOperationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#prefixUnaryOperation}. + * + * @param ctx the parse tree + */ + void exitPrefixUnaryOperation(KotlinParser.PrefixUnaryOperationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#postfixUnaryOperation}. + * + * @param ctx the parse tree + */ + void enterPostfixUnaryOperation(KotlinParser.PostfixUnaryOperationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#postfixUnaryOperation}. + * + * @param ctx the parse tree + */ + void exitPostfixUnaryOperation(KotlinParser.PostfixUnaryOperationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#memberAccessOperator}. + * + * @param ctx the parse tree + */ + void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#memberAccessOperator}. + * + * @param ctx the parse tree + */ + void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#modifierList}. + * + * @param ctx the parse tree + */ + void enterModifierList(KotlinParser.ModifierListContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#modifierList}. + * + * @param ctx the parse tree + */ + void exitModifierList(KotlinParser.ModifierListContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#modifier}. + * + * @param ctx the parse tree + */ + void enterModifier(KotlinParser.ModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#modifier}. + * + * @param ctx the parse tree + */ + void exitModifier(KotlinParser.ModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#classModifier}. + * + * @param ctx the parse tree + */ + void enterClassModifier(KotlinParser.ClassModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#classModifier}. + * + * @param ctx the parse tree + */ + void exitClassModifier(KotlinParser.ClassModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#memberModifier}. + * + * @param ctx the parse tree + */ + void enterMemberModifier(KotlinParser.MemberModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#memberModifier}. + * + * @param ctx the parse tree + */ + void exitMemberModifier(KotlinParser.MemberModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#visibilityModifier}. + * + * @param ctx the parse tree + */ + void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#visibilityModifier}. + * + * @param ctx the parse tree + */ + void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#varianceAnnotation}. + * + * @param ctx the parse tree + */ + void enterVarianceAnnotation(KotlinParser.VarianceAnnotationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#varianceAnnotation}. + * + * @param ctx the parse tree + */ + void exitVarianceAnnotation(KotlinParser.VarianceAnnotationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#functionModifier}. + * + * @param ctx the parse tree + */ + void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#functionModifier}. + * + * @param ctx the parse tree + */ + void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#propertyModifier}. + * + * @param ctx the parse tree + */ + void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#propertyModifier}. + * + * @param ctx the parse tree + */ + void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#inheritanceModifier}. + * + * @param ctx the parse tree + */ + void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#inheritanceModifier}. + * + * @param ctx the parse tree + */ + void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#parameterModifier}. + * + * @param ctx the parse tree + */ + void enterParameterModifier(KotlinParser.ParameterModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#parameterModifier}. + * + * @param ctx the parse tree + */ + void exitParameterModifier(KotlinParser.ParameterModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameterModifier}. + * + * @param ctx the parse tree + */ + void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameterModifier}. + * + * @param ctx the parse tree + */ + void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#labelDefinition}. + * + * @param ctx the parse tree + */ + void enterLabelDefinition(KotlinParser.LabelDefinitionContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#labelDefinition}. + * + * @param ctx the parse tree + */ + void exitLabelDefinition(KotlinParser.LabelDefinitionContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#annotations}. + * + * @param ctx the parse tree + */ + void enterAnnotations(KotlinParser.AnnotationsContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#annotations}. + * + * @param ctx the parse tree + */ + void exitAnnotations(KotlinParser.AnnotationsContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#annotation}. + * + * @param ctx the parse tree + */ + void enterAnnotation(KotlinParser.AnnotationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#annotation}. + * + * @param ctx the parse tree + */ + void exitAnnotation(KotlinParser.AnnotationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#annotationList}. + * + * @param ctx the parse tree + */ + void enterAnnotationList(KotlinParser.AnnotationListContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#annotationList}. + * + * @param ctx the parse tree + */ + void exitAnnotationList(KotlinParser.AnnotationListContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. + * + * @param ctx the parse tree + */ + void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. + * + * @param ctx the parse tree + */ + void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#unescapedAnnotation}. + * + * @param ctx the parse tree + */ + void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#unescapedAnnotation}. + * + * @param ctx the parse tree + */ + void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#identifier}. + * + * @param ctx the parse tree + */ + void enterIdentifier(KotlinParser.IdentifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#identifier}. + * + * @param ctx the parse tree + */ + void exitIdentifier(KotlinParser.IdentifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#simpleIdentifier}. + * + * @param ctx the parse tree + */ + void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#simpleIdentifier}. + * + * @param ctx the parse tree + */ + void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#semi}. + * + * @param ctx the parse tree + */ + void enterSemi(KotlinParser.SemiContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#semi}. + * + * @param ctx the parse tree + */ + void exitSemi(KotlinParser.SemiContext ctx); + + /** + * Enter a parse tree produced by {@link KotlinParser#anysemi}. + * + * @param ctx the parse tree + */ + void enterAnysemi(KotlinParser.AnysemiContext ctx); + + /** + * Exit a parse tree produced by {@link KotlinParser#anysemi}. + * + * @param ctx the parse tree + */ + void exitAnysemi(KotlinParser.AnysemiContext ctx); +} \ No newline at end of file diff --git a/src/main/java/PythonLexer.interp b/src/main/java/PythonLexer.interp new file mode 100644 index 0000000..4437fb1 --- /dev/null +++ b/src/main/java/PythonLexer.interp @@ -0,0 +1,378 @@ +token literal names: +null +null +null +null +null +null +null +'False' +'await' +'else' +'import' +'pass' +'None' +'break' +'except' +'in' +'raise' +'True' +'class' +'finally' +'is' +'return' +'and' +'continue' +'for' +'lambda' +'try' +'as' +'def' +'from' +'nonlocal' +'while' +'assert' +'del' +'global' +'not' +'with' +'async' +'elif' +'if' +'or' +'yield' +'(' +'[' +null +')' +']' +null +'.' +':' +',' +';' +'+' +'-' +'*' +'/' +'|' +'&' +'<' +'>' +'=' +'%' +'==' +'!=' +'<=' +'>=' +'~' +'^' +'<<' +'>>' +'**' +'+=' +'-=' +'*=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<=' +'>>=' +'**=' +'//' +'//=' +'@' +'@=' +'->' +'...' +':=' +'!' +null +null +null +null +null +null +null +null + +token symbolic names: +null +INDENT +DEDENT +TYPE_COMMENT +FSTRING_START +FSTRING_MIDDLE +FSTRING_END +FALSE +AWAIT +ELSE +IMPORT +PASS +NONE +BREAK +EXCEPT +IN +RAISE +TRUE +CLASS +FINALLY +IS +RETURN +AND +CONTINUE +FOR +LAMBDA +TRY +AS +DEF +FROM +NONLOCAL +WHILE +ASSERT +DEL +GLOBAL +NOT +WITH +ASYNC +ELIF +IF +OR +YIELD +LPAR +LSQB +LBRACE +RPAR +RSQB +RBRACE +DOT +COLON +COMMA +SEMI +PLUS +MINUS +STAR +SLASH +VBAR +AMPER +LESS +GREATER +EQUAL +PERCENT +EQEQUAL +NOTEQUAL +LESSEQUAL +GREATEREQUAL +TILDE +CIRCUMFLEX +LEFTSHIFT +RIGHTSHIFT +DOUBLESTAR +PLUSEQUAL +MINEQUAL +STAREQUAL +SLASHEQUAL +PERCENTEQUAL +AMPEREQUAL +VBAREQUAL +CIRCUMFLEXEQUAL +LEFTSHIFTEQUAL +RIGHTSHIFTEQUAL +DOUBLESTAREQUAL +DOUBLESLASH +DOUBLESLASHEQUAL +AT +ATEQUAL +RARROW +ELLIPSIS +COLONEQUAL +EXCLAMATION +NAME +NUMBER +STRING +NEWLINE +COMMENT +WS +EXPLICIT_LINE_JOINING +ERRORTOKEN + +rule names: +FALSE +AWAIT +ELSE +IMPORT +PASS +NONE +BREAK +EXCEPT +IN +RAISE +TRUE +CLASS +FINALLY +IS +RETURN +AND +CONTINUE +FOR +LAMBDA +TRY +AS +DEF +FROM +NONLOCAL +WHILE +ASSERT +DEL +GLOBAL +NOT +WITH +ASYNC +ELIF +IF +OR +YIELD +LPAR +LSQB +LBRACE +RPAR +RSQB +RBRACE +DOT +COLON +COMMA +SEMI +PLUS +MINUS +STAR +SLASH +VBAR +AMPER +LESS +GREATER +EQUAL +PERCENT +EQEQUAL +NOTEQUAL +LESSEQUAL +GREATEREQUAL +TILDE +CIRCUMFLEX +LEFTSHIFT +RIGHTSHIFT +DOUBLESTAR +PLUSEQUAL +MINEQUAL +STAREQUAL +SLASHEQUAL +PERCENTEQUAL +AMPEREQUAL +VBAREQUAL +CIRCUMFLEXEQUAL +LEFTSHIFTEQUAL +RIGHTSHIFTEQUAL +DOUBLESTAREQUAL +DOUBLESLASH +DOUBLESLASHEQUAL +AT +ATEQUAL +RARROW +ELLIPSIS +COLONEQUAL +EXCLAMATION +NAME +NUMBER +STRING +NEWLINE +COMMENT +WS +EXPLICIT_LINE_JOINING +SINGLE_QUOTE_FSTRING_START +DOUBLE_QUOTE_FSTRING_START +LONG_SINGLE_QUOTE_FSTRING_START +LONG_DOUBLE_QUOTE_FSTRING_START +ERRORTOKEN +SINGLE_QUOTE_FSTRING_END +SINGLE_QUOTE_FSTRING_MIDDLE +SINGLE_QUOTE_FSTRING_LBRACE +DOUBLE_QUOTE_FSTRING_END +DOUBLE_QUOTE_FSTRING_MIDDLE +DOUBLE_QUOTE_FSTRING_LBRACE +LONG_SINGLE_QUOTE_FSTRING_END +LONG_SINGLE_QUOTE_FSTRING_MIDDLE +LONG_SINGLE_QUOTE_FSTRING_LBRACE +LONG_DOUBLE_QUOTE_FSTRING_END +LONG_DOUBLE_QUOTE_FSTRING_MIDDLE +LONG_DOUBLE_QUOTE_FSTRING_LBRACE +SINGLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE +SINGLE_QUOTE_FORMAT_SPECIFICATION_LBRACE +SINGLE_QUOTE_FORMAT_SPECIFICATION_RBRACE +DOUBLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE +DOUBLE_QUOTE_FORMAT_SPECIFICATION_LBRACE +DOUBLE_QUOTE_FORMAT_SPECIFICATION_RBRACE +IGNORE +STRING_LITERAL +STRING_PREFIX +SHORT_STRING +LONG_STRING +SHORT_STRING_ITEM_FOR_SINGLE_QUOTE +SHORT_STRING_ITEM_FOR_DOUBLE_QUOTE +LONG_STRING_ITEM +SHORT_STRING_CHAR_NO_SINGLE_QUOTE +SHORT_STRING_CHAR_NO_DOUBLE_QUOTE +LONG_STRING_CHAR +STRING_ESCAPE_SEQ +BYTES_LITERAL +BYTES_PREFIX +SHORT_BYTES +LONG_BYTES +SHORT_BYTES_ITEM_FOR_SINGLE_QUOTE +SHORT_BYTES_ITEM_FOR_DOUBLE_QUOTE +LONG_BYTES_ITEM +SHORT_BYTES_CHAR_NO_SINGLE_QUOTE +SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE +LONG_BYTES_CHAR +BYTES_ESCAPE_SEQ +SINGLE_QUOTE_FSTRING_LITERAL +DOUBLE_QUOTE_FSTRING_LITERAL +F_STRING_PREFIX +FORMAT_SPEC_CHAR_NO_SINGLE_QUOTE +FORMAT_SPEC_CHAR_NO_DOUBLE_QUOTE +DOUBLE_BRACES +INTEGER +DEC_INTEGER +BIN_INTEGER +OCT_INTEGER +HEX_INTEGER +NON_ZERO_DIGIT +DIGIT +BIN_DIGIT +OCT_DIGIT +HEX_DIGIT +FLOAT_NUMBER +POINT_FLOAT +EXPONENT_FLOAT +DIGIT_PART +FRACTION +EXPONENT +IMAG_NUMBER +ID_CONTINUE +ID_START + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +SINGLE_QUOTE_FSTRING_MODE +DOUBLE_QUOTE_FSTRING_MODE +LONG_SINGLE_QUOTE_FSTRING_MODE +LONG_DOUBLE_QUOTE_FSTRING_MODE +SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE +DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE + +atn: +[4, 0, 97, 1148, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 5, 83, 647, 8, 83, 10, 83, 12, 83, 650, 9, 83, 1, 84, 1, 84, 1, 84, 3, 84, 655, 8, 84, 1, 85, 1, 85, 3, 85, 659, 8, 85, 1, 86, 3, 86, 662, 8, 86, 1, 86, 1, 86, 1, 87, 1, 87, 5, 87, 668, 8, 87, 10, 87, 12, 87, 671, 9, 87, 1, 87, 1, 87, 1, 88, 4, 88, 676, 8, 88, 11, 88, 12, 88, 677, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 4, 107, 774, 8, 107, 11, 107, 12, 107, 775, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 4, 110, 789, 8, 110, 11, 110, 12, 110, 790, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 3, 114, 811, 8, 114, 1, 114, 1, 114, 3, 114, 815, 8, 114, 1, 115, 1, 115, 1, 116, 1, 116, 5, 116, 821, 8, 116, 10, 116, 12, 116, 824, 9, 116, 1, 116, 1, 116, 1, 116, 5, 116, 829, 8, 116, 10, 116, 12, 116, 832, 9, 116, 1, 116, 3, 116, 835, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 842, 8, 117, 10, 117, 12, 117, 845, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 855, 8, 117, 10, 117, 12, 117, 858, 9, 117, 1, 117, 1, 117, 1, 117, 3, 117, 863, 8, 117, 1, 118, 1, 118, 3, 118, 867, 8, 118, 1, 119, 1, 119, 3, 119, 871, 8, 119, 1, 120, 1, 120, 3, 120, 875, 8, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 888, 8, 124, 1, 125, 1, 125, 1, 125, 3, 125, 893, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 912, 8, 126, 1, 127, 1, 127, 5, 127, 916, 8, 127, 10, 127, 12, 127, 919, 9, 127, 1, 127, 1, 127, 1, 127, 5, 127, 924, 8, 127, 10, 127, 12, 127, 927, 9, 127, 1, 127, 3, 127, 930, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 937, 8, 128, 10, 128, 12, 128, 940, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 950, 8, 128, 10, 128, 12, 128, 953, 9, 128, 1, 128, 1, 128, 1, 128, 3, 128, 958, 8, 128, 1, 129, 1, 129, 3, 129, 962, 8, 129, 1, 130, 1, 130, 3, 130, 966, 8, 130, 1, 131, 1, 131, 3, 131, 970, 8, 131, 1, 132, 3, 132, 973, 8, 132, 1, 133, 3, 133, 976, 8, 133, 1, 134, 3, 134, 979, 8, 134, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 4, 136, 986, 8, 136, 11, 136, 12, 136, 987, 1, 137, 1, 137, 4, 137, 992, 8, 137, 11, 137, 12, 137, 993, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 1013, 8, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 1023, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 1029, 8, 142, 1, 143, 1, 143, 3, 143, 1033, 8, 143, 1, 143, 5, 143, 1036, 8, 143, 10, 143, 12, 143, 1039, 9, 143, 1, 143, 4, 143, 1042, 8, 143, 11, 143, 12, 143, 1043, 1, 143, 3, 143, 1047, 8, 143, 1, 143, 5, 143, 1050, 8, 143, 10, 143, 12, 143, 1053, 9, 143, 3, 143, 1055, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 1060, 8, 144, 1, 144, 4, 144, 1063, 8, 144, 11, 144, 12, 144, 1064, 1, 145, 1, 145, 1, 145, 3, 145, 1070, 8, 145, 1, 145, 4, 145, 1073, 8, 145, 11, 145, 12, 145, 1074, 1, 146, 1, 146, 1, 146, 3, 146, 1080, 8, 146, 1, 146, 4, 146, 1083, 8, 146, 11, 146, 12, 146, 1084, 1, 147, 1, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 150, 1, 150, 1, 151, 1, 151, 3, 151, 1097, 8, 151, 1, 152, 1, 152, 3, 152, 1101, 8, 152, 1, 153, 3, 153, 1104, 8, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 1110, 8, 153, 1, 154, 1, 154, 3, 154, 1114, 8, 154, 1, 154, 1, 154, 1, 155, 1, 155, 3, 155, 1120, 8, 155, 1, 155, 5, 155, 1123, 8, 155, 10, 155, 12, 155, 1126, 9, 155, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 3, 157, 1133, 8, 157, 1, 157, 1, 157, 1, 158, 1, 158, 3, 158, 1139, 8, 158, 1, 158, 1, 158, 1, 159, 1, 159, 3, 159, 1145, 8, 159, 1, 160, 1, 160, 4, 843, 856, 938, 951, 0, 161, 7, 7, 9, 8, 11, 9, 13, 10, 15, 11, 17, 12, 19, 13, 21, 14, 23, 15, 25, 16, 27, 17, 29, 18, 31, 19, 33, 20, 35, 21, 37, 22, 39, 23, 41, 24, 43, 25, 45, 26, 47, 27, 49, 28, 51, 29, 53, 30, 55, 31, 57, 32, 59, 33, 61, 34, 63, 35, 65, 36, 67, 37, 69, 38, 71, 39, 73, 40, 75, 41, 77, 42, 79, 43, 81, 44, 83, 45, 85, 46, 87, 47, 89, 48, 91, 49, 93, 50, 95, 51, 97, 52, 99, 53, 101, 54, 103, 55, 105, 56, 107, 57, 109, 58, 111, 59, 113, 60, 115, 61, 117, 62, 119, 63, 121, 64, 123, 65, 125, 66, 127, 67, 129, 68, 131, 69, 133, 70, 135, 71, 137, 72, 139, 73, 141, 74, 143, 75, 145, 76, 147, 77, 149, 78, 151, 79, 153, 80, 155, 81, 157, 82, 159, 83, 161, 84, 163, 85, 165, 86, 167, 87, 169, 88, 171, 89, 173, 90, 175, 91, 177, 92, 179, 93, 181, 94, 183, 95, 185, 96, 187, 0, 189, 0, 191, 0, 193, 0, 195, 97, 197, 0, 199, 0, 201, 0, 203, 0, 205, 0, 207, 0, 209, 0, 211, 0, 213, 0, 215, 0, 217, 0, 219, 0, 221, 0, 223, 0, 225, 0, 227, 0, 229, 0, 231, 0, 233, 0, 235, 0, 237, 0, 239, 0, 241, 0, 243, 0, 245, 0, 247, 0, 249, 0, 251, 0, 253, 0, 255, 0, 257, 0, 259, 0, 261, 0, 263, 0, 265, 0, 267, 0, 269, 0, 271, 0, 273, 0, 275, 0, 277, 0, 279, 0, 281, 0, 283, 0, 285, 0, 287, 0, 289, 0, 291, 0, 293, 0, 295, 0, 297, 0, 299, 0, 301, 0, 303, 0, 305, 0, 307, 0, 309, 0, 311, 0, 313, 0, 315, 0, 317, 0, 319, 0, 321, 0, 323, 0, 325, 0, 327, 0, 7, 0, 1, 2, 3, 4, 5, 6, 27, 2, 0, 10, 10, 13, 13, 3, 0, 9, 9, 12, 12, 32, 32, 1, 0, 39, 39, 1, 0, 34, 34, 4, 0, 82, 82, 85, 85, 114, 114, 117, 117, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 1, 0, 92, 92, 2, 0, 66, 66, 98, 98, 5, 0, 0, 9, 11, 12, 14, 38, 40, 91, 93, 127, 5, 0, 0, 9, 11, 12, 14, 33, 35, 91, 93, 127, 2, 0, 0, 91, 93, 127, 1, 0, 0, 127, 2, 0, 70, 70, 102, 102, 3, 0, 39, 39, 123, 123, 125, 125, 3, 0, 34, 34, 123, 123, 125, 125, 2, 0, 79, 79, 111, 111, 2, 0, 88, 88, 120, 120, 1, 0, 49, 57, 1, 0, 48, 57, 1, 0, 48, 55, 2, 0, 65, 70, 97, 102, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 74, 74, 106, 106, 374, 0, 48, 57, 183, 183, 768, 879, 903, 903, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2045, 2045, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2200, 2207, 2250, 2273, 2275, 2307, 2362, 2364, 2366, 2383, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2435, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2558, 2558, 2561, 2563, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2673, 2677, 2677, 2689, 2691, 2748, 2748, 2750, 2757, 2759, 2761, 2763, 2765, 2786, 2787, 2790, 2799, 2810, 2815, 2817, 2819, 2876, 2876, 2878, 2884, 2887, 2888, 2891, 2893, 2901, 2903, 2914, 2915, 2918, 2927, 2946, 2946, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3046, 3055, 3072, 3076, 3132, 3132, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3201, 3203, 3260, 3260, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 3315, 3315, 3328, 3331, 3387, 3388, 3390, 3396, 3398, 3400, 3402, 3405, 3415, 3415, 3426, 3427, 3430, 3439, 3457, 3459, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3633, 3633, 3635, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3763, 3772, 3784, 3790, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4139, 4158, 4160, 4169, 4182, 4185, 4190, 4192, 4194, 4196, 4199, 4205, 4209, 4212, 4226, 4237, 4239, 4253, 4957, 4959, 4969, 4977, 5906, 5909, 5938, 5940, 5970, 5971, 6002, 6003, 6068, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6159, 6169, 6313, 6313, 6432, 6443, 6448, 6459, 6470, 6479, 6608, 6618, 6679, 6683, 6741, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6832, 6845, 6847, 6862, 6912, 6916, 6964, 6980, 6992, 7001, 7019, 7027, 7040, 7042, 7073, 7085, 7088, 7097, 7142, 7155, 7204, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7400, 7405, 7405, 7412, 7412, 7415, 7417, 7616, 7679, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12335, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42654, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43043, 43047, 43052, 43052, 43136, 43137, 43188, 43205, 43216, 43225, 43232, 43249, 43263, 43273, 43302, 43309, 43335, 43347, 43392, 43395, 43443, 43456, 43472, 43481, 43493, 43493, 43504, 43513, 43561, 43574, 43587, 43587, 43596, 43597, 43600, 43609, 43643, 43645, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43755, 43759, 43765, 43766, 44003, 44010, 44012, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 65438, 65439, 66045, 66045, 66272, 66272, 66422, 66426, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 68325, 68326, 68900, 68903, 68912, 68921, 69291, 69292, 69373, 69375, 69446, 69456, 69506, 69509, 69632, 69634, 69688, 69702, 69734, 69744, 69747, 69748, 69759, 69762, 69808, 69818, 69826, 69826, 69872, 69881, 69888, 69890, 69927, 69940, 69942, 69951, 69957, 69958, 70003, 70003, 70016, 70018, 70067, 70080, 70089, 70092, 70094, 70105, 70188, 70199, 70206, 70206, 70209, 70209, 70367, 70378, 70384, 70393, 70400, 70403, 70459, 70460, 70462, 70468, 70471, 70472, 70475, 70477, 70487, 70487, 70498, 70499, 70502, 70508, 70512, 70516, 70709, 70726, 70736, 70745, 70750, 70750, 70832, 70851, 70864, 70873, 71087, 71093, 71096, 71104, 71132, 71133, 71216, 71232, 71248, 71257, 71339, 71351, 71360, 71369, 71453, 71467, 71472, 71481, 71724, 71738, 71904, 71913, 71984, 71989, 71991, 71992, 71995, 71998, 72000, 72000, 72002, 72003, 72016, 72025, 72145, 72151, 72154, 72160, 72164, 72164, 72193, 72202, 72243, 72249, 72251, 72254, 72263, 72263, 72273, 72283, 72330, 72345, 72751, 72758, 72760, 72767, 72784, 72793, 72850, 72871, 72873, 72886, 73009, 73014, 73018, 73018, 73020, 73021, 73023, 73029, 73031, 73031, 73040, 73049, 73098, 73102, 73104, 73105, 73107, 73111, 73120, 73129, 73459, 73462, 73472, 73473, 73475, 73475, 73524, 73530, 73534, 73538, 73552, 73561, 78912, 78912, 78919, 78933, 92768, 92777, 92864, 92873, 92912, 92916, 92976, 92982, 93008, 93017, 94031, 94031, 94033, 94087, 94095, 94098, 94180, 94180, 94192, 94193, 113821, 113822, 118528, 118573, 118576, 118598, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123023, 123023, 123184, 123190, 123200, 123209, 123566, 123566, 123628, 123641, 124140, 124153, 125136, 125142, 125252, 125258, 125264, 125273, 130032, 130041, 917760, 917999, 667, 0, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 891, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2160, 2183, 2185, 2190, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3165, 3165, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3293, 3294, 3296, 3297, 3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3634, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3762, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5905, 5919, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64605, 64612, 64829, 64848, 64911, 64914, 64967, 65008, 65017, 65137, 65137, 65139, 65139, 65143, 65143, 65145, 65145, 65147, 65147, 65149, 65149, 65151, 65276, 65313, 65338, 65345, 65370, 65382, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69248, 69289, 69296, 69297, 69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746, 69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70753, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73474, 73474, 73476, 73488, 73490, 73523, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197, 123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 196608, 201546, 201552, 205743, 1170, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 1, 197, 1, 0, 0, 0, 1, 199, 1, 0, 0, 0, 1, 201, 1, 0, 0, 0, 2, 203, 1, 0, 0, 0, 2, 205, 1, 0, 0, 0, 2, 207, 1, 0, 0, 0, 3, 209, 1, 0, 0, 0, 3, 211, 1, 0, 0, 0, 3, 213, 1, 0, 0, 0, 4, 215, 1, 0, 0, 0, 4, 217, 1, 0, 0, 0, 4, 219, 1, 0, 0, 0, 5, 221, 1, 0, 0, 0, 5, 223, 1, 0, 0, 0, 5, 225, 1, 0, 0, 0, 6, 227, 1, 0, 0, 0, 6, 229, 1, 0, 0, 0, 6, 231, 1, 0, 0, 0, 7, 329, 1, 0, 0, 0, 9, 335, 1, 0, 0, 0, 11, 341, 1, 0, 0, 0, 13, 346, 1, 0, 0, 0, 15, 353, 1, 0, 0, 0, 17, 358, 1, 0, 0, 0, 19, 363, 1, 0, 0, 0, 21, 369, 1, 0, 0, 0, 23, 376, 1, 0, 0, 0, 25, 379, 1, 0, 0, 0, 27, 385, 1, 0, 0, 0, 29, 390, 1, 0, 0, 0, 31, 396, 1, 0, 0, 0, 33, 404, 1, 0, 0, 0, 35, 407, 1, 0, 0, 0, 37, 414, 1, 0, 0, 0, 39, 418, 1, 0, 0, 0, 41, 427, 1, 0, 0, 0, 43, 431, 1, 0, 0, 0, 45, 438, 1, 0, 0, 0, 47, 442, 1, 0, 0, 0, 49, 445, 1, 0, 0, 0, 51, 449, 1, 0, 0, 0, 53, 454, 1, 0, 0, 0, 55, 463, 1, 0, 0, 0, 57, 469, 1, 0, 0, 0, 59, 476, 1, 0, 0, 0, 61, 480, 1, 0, 0, 0, 63, 487, 1, 0, 0, 0, 65, 491, 1, 0, 0, 0, 67, 496, 1, 0, 0, 0, 69, 502, 1, 0, 0, 0, 71, 507, 1, 0, 0, 0, 73, 510, 1, 0, 0, 0, 75, 513, 1, 0, 0, 0, 77, 519, 1, 0, 0, 0, 79, 521, 1, 0, 0, 0, 81, 523, 1, 0, 0, 0, 83, 525, 1, 0, 0, 0, 85, 527, 1, 0, 0, 0, 87, 529, 1, 0, 0, 0, 89, 531, 1, 0, 0, 0, 91, 533, 1, 0, 0, 0, 93, 535, 1, 0, 0, 0, 95, 537, 1, 0, 0, 0, 97, 539, 1, 0, 0, 0, 99, 541, 1, 0, 0, 0, 101, 543, 1, 0, 0, 0, 103, 545, 1, 0, 0, 0, 105, 547, 1, 0, 0, 0, 107, 549, 1, 0, 0, 0, 109, 551, 1, 0, 0, 0, 111, 553, 1, 0, 0, 0, 113, 555, 1, 0, 0, 0, 115, 557, 1, 0, 0, 0, 117, 559, 1, 0, 0, 0, 119, 562, 1, 0, 0, 0, 121, 565, 1, 0, 0, 0, 123, 568, 1, 0, 0, 0, 125, 571, 1, 0, 0, 0, 127, 573, 1, 0, 0, 0, 129, 575, 1, 0, 0, 0, 131, 578, 1, 0, 0, 0, 133, 581, 1, 0, 0, 0, 135, 584, 1, 0, 0, 0, 137, 587, 1, 0, 0, 0, 139, 590, 1, 0, 0, 0, 141, 593, 1, 0, 0, 0, 143, 596, 1, 0, 0, 0, 145, 599, 1, 0, 0, 0, 147, 602, 1, 0, 0, 0, 149, 605, 1, 0, 0, 0, 151, 608, 1, 0, 0, 0, 153, 612, 1, 0, 0, 0, 155, 616, 1, 0, 0, 0, 157, 620, 1, 0, 0, 0, 159, 623, 1, 0, 0, 0, 161, 627, 1, 0, 0, 0, 163, 629, 1, 0, 0, 0, 165, 632, 1, 0, 0, 0, 167, 635, 1, 0, 0, 0, 169, 639, 1, 0, 0, 0, 171, 642, 1, 0, 0, 0, 173, 644, 1, 0, 0, 0, 175, 654, 1, 0, 0, 0, 177, 658, 1, 0, 0, 0, 179, 661, 1, 0, 0, 0, 181, 665, 1, 0, 0, 0, 183, 675, 1, 0, 0, 0, 185, 681, 1, 0, 0, 0, 187, 686, 1, 0, 0, 0, 189, 692, 1, 0, 0, 0, 191, 698, 1, 0, 0, 0, 193, 706, 1, 0, 0, 0, 195, 714, 1, 0, 0, 0, 197, 716, 1, 0, 0, 0, 199, 721, 1, 0, 0, 0, 201, 725, 1, 0, 0, 0, 203, 729, 1, 0, 0, 0, 205, 734, 1, 0, 0, 0, 207, 738, 1, 0, 0, 0, 209, 742, 1, 0, 0, 0, 211, 749, 1, 0, 0, 0, 213, 753, 1, 0, 0, 0, 215, 757, 1, 0, 0, 0, 217, 764, 1, 0, 0, 0, 219, 768, 1, 0, 0, 0, 221, 773, 1, 0, 0, 0, 223, 779, 1, 0, 0, 0, 225, 783, 1, 0, 0, 0, 227, 788, 1, 0, 0, 0, 229, 794, 1, 0, 0, 0, 231, 798, 1, 0, 0, 0, 233, 802, 1, 0, 0, 0, 235, 810, 1, 0, 0, 0, 237, 816, 1, 0, 0, 0, 239, 834, 1, 0, 0, 0, 241, 862, 1, 0, 0, 0, 243, 866, 1, 0, 0, 0, 245, 870, 1, 0, 0, 0, 247, 874, 1, 0, 0, 0, 249, 876, 1, 0, 0, 0, 251, 878, 1, 0, 0, 0, 253, 880, 1, 0, 0, 0, 255, 887, 1, 0, 0, 0, 257, 889, 1, 0, 0, 0, 259, 911, 1, 0, 0, 0, 261, 929, 1, 0, 0, 0, 263, 957, 1, 0, 0, 0, 265, 961, 1, 0, 0, 0, 267, 965, 1, 0, 0, 0, 269, 969, 1, 0, 0, 0, 271, 972, 1, 0, 0, 0, 273, 975, 1, 0, 0, 0, 275, 978, 1, 0, 0, 0, 277, 980, 1, 0, 0, 0, 279, 985, 1, 0, 0, 0, 281, 991, 1, 0, 0, 0, 283, 1012, 1, 0, 0, 0, 285, 1014, 1, 0, 0, 0, 287, 1016, 1, 0, 0, 0, 289, 1022, 1, 0, 0, 0, 291, 1028, 1, 0, 0, 0, 293, 1054, 1, 0, 0, 0, 295, 1056, 1, 0, 0, 0, 297, 1066, 1, 0, 0, 0, 299, 1076, 1, 0, 0, 0, 301, 1086, 1, 0, 0, 0, 303, 1088, 1, 0, 0, 0, 305, 1090, 1, 0, 0, 0, 307, 1092, 1, 0, 0, 0, 309, 1096, 1, 0, 0, 0, 311, 1100, 1, 0, 0, 0, 313, 1109, 1, 0, 0, 0, 315, 1113, 1, 0, 0, 0, 317, 1117, 1, 0, 0, 0, 319, 1127, 1, 0, 0, 0, 321, 1130, 1, 0, 0, 0, 323, 1138, 1, 0, 0, 0, 325, 1144, 1, 0, 0, 0, 327, 1146, 1, 0, 0, 0, 329, 330, 5, 70, 0, 0, 330, 331, 5, 97, 0, 0, 331, 332, 5, 108, 0, 0, 332, 333, 5, 115, 0, 0, 333, 334, 5, 101, 0, 0, 334, 8, 1, 0, 0, 0, 335, 336, 5, 97, 0, 0, 336, 337, 5, 119, 0, 0, 337, 338, 5, 97, 0, 0, 338, 339, 5, 105, 0, 0, 339, 340, 5, 116, 0, 0, 340, 10, 1, 0, 0, 0, 341, 342, 5, 101, 0, 0, 342, 343, 5, 108, 0, 0, 343, 344, 5, 115, 0, 0, 344, 345, 5, 101, 0, 0, 345, 12, 1, 0, 0, 0, 346, 347, 5, 105, 0, 0, 347, 348, 5, 109, 0, 0, 348, 349, 5, 112, 0, 0, 349, 350, 5, 111, 0, 0, 350, 351, 5, 114, 0, 0, 351, 352, 5, 116, 0, 0, 352, 14, 1, 0, 0, 0, 353, 354, 5, 112, 0, 0, 354, 355, 5, 97, 0, 0, 355, 356, 5, 115, 0, 0, 356, 357, 5, 115, 0, 0, 357, 16, 1, 0, 0, 0, 358, 359, 5, 78, 0, 0, 359, 360, 5, 111, 0, 0, 360, 361, 5, 110, 0, 0, 361, 362, 5, 101, 0, 0, 362, 18, 1, 0, 0, 0, 363, 364, 5, 98, 0, 0, 364, 365, 5, 114, 0, 0, 365, 366, 5, 101, 0, 0, 366, 367, 5, 97, 0, 0, 367, 368, 5, 107, 0, 0, 368, 20, 1, 0, 0, 0, 369, 370, 5, 101, 0, 0, 370, 371, 5, 120, 0, 0, 371, 372, 5, 99, 0, 0, 372, 373, 5, 101, 0, 0, 373, 374, 5, 112, 0, 0, 374, 375, 5, 116, 0, 0, 375, 22, 1, 0, 0, 0, 376, 377, 5, 105, 0, 0, 377, 378, 5, 110, 0, 0, 378, 24, 1, 0, 0, 0, 379, 380, 5, 114, 0, 0, 380, 381, 5, 97, 0, 0, 381, 382, 5, 105, 0, 0, 382, 383, 5, 115, 0, 0, 383, 384, 5, 101, 0, 0, 384, 26, 1, 0, 0, 0, 385, 386, 5, 84, 0, 0, 386, 387, 5, 114, 0, 0, 387, 388, 5, 117, 0, 0, 388, 389, 5, 101, 0, 0, 389, 28, 1, 0, 0, 0, 390, 391, 5, 99, 0, 0, 391, 392, 5, 108, 0, 0, 392, 393, 5, 97, 0, 0, 393, 394, 5, 115, 0, 0, 394, 395, 5, 115, 0, 0, 395, 30, 1, 0, 0, 0, 396, 397, 5, 102, 0, 0, 397, 398, 5, 105, 0, 0, 398, 399, 5, 110, 0, 0, 399, 400, 5, 97, 0, 0, 400, 401, 5, 108, 0, 0, 401, 402, 5, 108, 0, 0, 402, 403, 5, 121, 0, 0, 403, 32, 1, 0, 0, 0, 404, 405, 5, 105, 0, 0, 405, 406, 5, 115, 0, 0, 406, 34, 1, 0, 0, 0, 407, 408, 5, 114, 0, 0, 408, 409, 5, 101, 0, 0, 409, 410, 5, 116, 0, 0, 410, 411, 5, 117, 0, 0, 411, 412, 5, 114, 0, 0, 412, 413, 5, 110, 0, 0, 413, 36, 1, 0, 0, 0, 414, 415, 5, 97, 0, 0, 415, 416, 5, 110, 0, 0, 416, 417, 5, 100, 0, 0, 417, 38, 1, 0, 0, 0, 418, 419, 5, 99, 0, 0, 419, 420, 5, 111, 0, 0, 420, 421, 5, 110, 0, 0, 421, 422, 5, 116, 0, 0, 422, 423, 5, 105, 0, 0, 423, 424, 5, 110, 0, 0, 424, 425, 5, 117, 0, 0, 425, 426, 5, 101, 0, 0, 426, 40, 1, 0, 0, 0, 427, 428, 5, 102, 0, 0, 428, 429, 5, 111, 0, 0, 429, 430, 5, 114, 0, 0, 430, 42, 1, 0, 0, 0, 431, 432, 5, 108, 0, 0, 432, 433, 5, 97, 0, 0, 433, 434, 5, 109, 0, 0, 434, 435, 5, 98, 0, 0, 435, 436, 5, 100, 0, 0, 436, 437, 5, 97, 0, 0, 437, 44, 1, 0, 0, 0, 438, 439, 5, 116, 0, 0, 439, 440, 5, 114, 0, 0, 440, 441, 5, 121, 0, 0, 441, 46, 1, 0, 0, 0, 442, 443, 5, 97, 0, 0, 443, 444, 5, 115, 0, 0, 444, 48, 1, 0, 0, 0, 445, 446, 5, 100, 0, 0, 446, 447, 5, 101, 0, 0, 447, 448, 5, 102, 0, 0, 448, 50, 1, 0, 0, 0, 449, 450, 5, 102, 0, 0, 450, 451, 5, 114, 0, 0, 451, 452, 5, 111, 0, 0, 452, 453, 5, 109, 0, 0, 453, 52, 1, 0, 0, 0, 454, 455, 5, 110, 0, 0, 455, 456, 5, 111, 0, 0, 456, 457, 5, 110, 0, 0, 457, 458, 5, 108, 0, 0, 458, 459, 5, 111, 0, 0, 459, 460, 5, 99, 0, 0, 460, 461, 5, 97, 0, 0, 461, 462, 5, 108, 0, 0, 462, 54, 1, 0, 0, 0, 463, 464, 5, 119, 0, 0, 464, 465, 5, 104, 0, 0, 465, 466, 5, 105, 0, 0, 466, 467, 5, 108, 0, 0, 467, 468, 5, 101, 0, 0, 468, 56, 1, 0, 0, 0, 469, 470, 5, 97, 0, 0, 470, 471, 5, 115, 0, 0, 471, 472, 5, 115, 0, 0, 472, 473, 5, 101, 0, 0, 473, 474, 5, 114, 0, 0, 474, 475, 5, 116, 0, 0, 475, 58, 1, 0, 0, 0, 476, 477, 5, 100, 0, 0, 477, 478, 5, 101, 0, 0, 478, 479, 5, 108, 0, 0, 479, 60, 1, 0, 0, 0, 480, 481, 5, 103, 0, 0, 481, 482, 5, 108, 0, 0, 482, 483, 5, 111, 0, 0, 483, 484, 5, 98, 0, 0, 484, 485, 5, 97, 0, 0, 485, 486, 5, 108, 0, 0, 486, 62, 1, 0, 0, 0, 487, 488, 5, 110, 0, 0, 488, 489, 5, 111, 0, 0, 489, 490, 5, 116, 0, 0, 490, 64, 1, 0, 0, 0, 491, 492, 5, 119, 0, 0, 492, 493, 5, 105, 0, 0, 493, 494, 5, 116, 0, 0, 494, 495, 5, 104, 0, 0, 495, 66, 1, 0, 0, 0, 496, 497, 5, 97, 0, 0, 497, 498, 5, 115, 0, 0, 498, 499, 5, 121, 0, 0, 499, 500, 5, 110, 0, 0, 500, 501, 5, 99, 0, 0, 501, 68, 1, 0, 0, 0, 502, 503, 5, 101, 0, 0, 503, 504, 5, 108, 0, 0, 504, 505, 5, 105, 0, 0, 505, 506, 5, 102, 0, 0, 506, 70, 1, 0, 0, 0, 507, 508, 5, 105, 0, 0, 508, 509, 5, 102, 0, 0, 509, 72, 1, 0, 0, 0, 510, 511, 5, 111, 0, 0, 511, 512, 5, 114, 0, 0, 512, 74, 1, 0, 0, 0, 513, 514, 5, 121, 0, 0, 514, 515, 5, 105, 0, 0, 515, 516, 5, 101, 0, 0, 516, 517, 5, 108, 0, 0, 517, 518, 5, 100, 0, 0, 518, 76, 1, 0, 0, 0, 519, 520, 5, 40, 0, 0, 520, 78, 1, 0, 0, 0, 521, 522, 5, 91, 0, 0, 522, 80, 1, 0, 0, 0, 523, 524, 5, 123, 0, 0, 524, 82, 1, 0, 0, 0, 525, 526, 5, 41, 0, 0, 526, 84, 1, 0, 0, 0, 527, 528, 5, 93, 0, 0, 528, 86, 1, 0, 0, 0, 529, 530, 5, 125, 0, 0, 530, 88, 1, 0, 0, 0, 531, 532, 5, 46, 0, 0, 532, 90, 1, 0, 0, 0, 533, 534, 5, 58, 0, 0, 534, 92, 1, 0, 0, 0, 535, 536, 5, 44, 0, 0, 536, 94, 1, 0, 0, 0, 537, 538, 5, 59, 0, 0, 538, 96, 1, 0, 0, 0, 539, 540, 5, 43, 0, 0, 540, 98, 1, 0, 0, 0, 541, 542, 5, 45, 0, 0, 542, 100, 1, 0, 0, 0, 543, 544, 5, 42, 0, 0, 544, 102, 1, 0, 0, 0, 545, 546, 5, 47, 0, 0, 546, 104, 1, 0, 0, 0, 547, 548, 5, 124, 0, 0, 548, 106, 1, 0, 0, 0, 549, 550, 5, 38, 0, 0, 550, 108, 1, 0, 0, 0, 551, 552, 5, 60, 0, 0, 552, 110, 1, 0, 0, 0, 553, 554, 5, 62, 0, 0, 554, 112, 1, 0, 0, 0, 555, 556, 5, 61, 0, 0, 556, 114, 1, 0, 0, 0, 557, 558, 5, 37, 0, 0, 558, 116, 1, 0, 0, 0, 559, 560, 5, 61, 0, 0, 560, 561, 5, 61, 0, 0, 561, 118, 1, 0, 0, 0, 562, 563, 5, 33, 0, 0, 563, 564, 5, 61, 0, 0, 564, 120, 1, 0, 0, 0, 565, 566, 5, 60, 0, 0, 566, 567, 5, 61, 0, 0, 567, 122, 1, 0, 0, 0, 568, 569, 5, 62, 0, 0, 569, 570, 5, 61, 0, 0, 570, 124, 1, 0, 0, 0, 571, 572, 5, 126, 0, 0, 572, 126, 1, 0, 0, 0, 573, 574, 5, 94, 0, 0, 574, 128, 1, 0, 0, 0, 575, 576, 5, 60, 0, 0, 576, 577, 5, 60, 0, 0, 577, 130, 1, 0, 0, 0, 578, 579, 5, 62, 0, 0, 579, 580, 5, 62, 0, 0, 580, 132, 1, 0, 0, 0, 581, 582, 5, 42, 0, 0, 582, 583, 5, 42, 0, 0, 583, 134, 1, 0, 0, 0, 584, 585, 5, 43, 0, 0, 585, 586, 5, 61, 0, 0, 586, 136, 1, 0, 0, 0, 587, 588, 5, 45, 0, 0, 588, 589, 5, 61, 0, 0, 589, 138, 1, 0, 0, 0, 590, 591, 5, 42, 0, 0, 591, 592, 5, 61, 0, 0, 592, 140, 1, 0, 0, 0, 593, 594, 5, 47, 0, 0, 594, 595, 5, 61, 0, 0, 595, 142, 1, 0, 0, 0, 596, 597, 5, 37, 0, 0, 597, 598, 5, 61, 0, 0, 598, 144, 1, 0, 0, 0, 599, 600, 5, 38, 0, 0, 600, 601, 5, 61, 0, 0, 601, 146, 1, 0, 0, 0, 602, 603, 5, 124, 0, 0, 603, 604, 5, 61, 0, 0, 604, 148, 1, 0, 0, 0, 605, 606, 5, 94, 0, 0, 606, 607, 5, 61, 0, 0, 607, 150, 1, 0, 0, 0, 608, 609, 5, 60, 0, 0, 609, 610, 5, 60, 0, 0, 610, 611, 5, 61, 0, 0, 611, 152, 1, 0, 0, 0, 612, 613, 5, 62, 0, 0, 613, 614, 5, 62, 0, 0, 614, 615, 5, 61, 0, 0, 615, 154, 1, 0, 0, 0, 616, 617, 5, 42, 0, 0, 617, 618, 5, 42, 0, 0, 618, 619, 5, 61, 0, 0, 619, 156, 1, 0, 0, 0, 620, 621, 5, 47, 0, 0, 621, 622, 5, 47, 0, 0, 622, 158, 1, 0, 0, 0, 623, 624, 5, 47, 0, 0, 624, 625, 5, 47, 0, 0, 625, 626, 5, 61, 0, 0, 626, 160, 1, 0, 0, 0, 627, 628, 5, 64, 0, 0, 628, 162, 1, 0, 0, 0, 629, 630, 5, 64, 0, 0, 630, 631, 5, 61, 0, 0, 631, 164, 1, 0, 0, 0, 632, 633, 5, 45, 0, 0, 633, 634, 5, 62, 0, 0, 634, 166, 1, 0, 0, 0, 635, 636, 5, 46, 0, 0, 636, 637, 5, 46, 0, 0, 637, 638, 5, 46, 0, 0, 638, 168, 1, 0, 0, 0, 639, 640, 5, 58, 0, 0, 640, 641, 5, 61, 0, 0, 641, 170, 1, 0, 0, 0, 642, 643, 5, 33, 0, 0, 643, 172, 1, 0, 0, 0, 644, 648, 3, 327, 160, 0, 645, 647, 3, 325, 159, 0, 646, 645, 1, 0, 0, 0, 647, 650, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 174, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 651, 655, 3, 291, 142, 0, 652, 655, 3, 311, 152, 0, 653, 655, 3, 323, 158, 0, 654, 651, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 653, 1, 0, 0, 0, 655, 176, 1, 0, 0, 0, 656, 659, 3, 235, 114, 0, 657, 659, 3, 257, 125, 0, 658, 656, 1, 0, 0, 0, 658, 657, 1, 0, 0, 0, 659, 178, 1, 0, 0, 0, 660, 662, 5, 13, 0, 0, 661, 660, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 664, 5, 10, 0, 0, 664, 180, 1, 0, 0, 0, 665, 669, 5, 35, 0, 0, 666, 668, 8, 0, 0, 0, 667, 666, 1, 0, 0, 0, 668, 671, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 669, 670, 1, 0, 0, 0, 670, 672, 1, 0, 0, 0, 671, 669, 1, 0, 0, 0, 672, 673, 6, 87, 0, 0, 673, 182, 1, 0, 0, 0, 674, 676, 7, 1, 0, 0, 675, 674, 1, 0, 0, 0, 676, 677, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 677, 678, 1, 0, 0, 0, 678, 679, 1, 0, 0, 0, 679, 680, 6, 88, 0, 0, 680, 184, 1, 0, 0, 0, 681, 682, 5, 92, 0, 0, 682, 683, 3, 179, 86, 0, 683, 684, 1, 0, 0, 0, 684, 685, 6, 89, 0, 0, 685, 186, 1, 0, 0, 0, 686, 687, 3, 283, 138, 0, 687, 688, 7, 2, 0, 0, 688, 689, 1, 0, 0, 0, 689, 690, 6, 90, 1, 0, 690, 691, 6, 90, 2, 0, 691, 188, 1, 0, 0, 0, 692, 693, 3, 283, 138, 0, 693, 694, 7, 3, 0, 0, 694, 695, 1, 0, 0, 0, 695, 696, 6, 91, 1, 0, 696, 697, 6, 91, 3, 0, 697, 190, 1, 0, 0, 0, 698, 699, 3, 283, 138, 0, 699, 700, 7, 2, 0, 0, 700, 701, 7, 2, 0, 0, 701, 702, 7, 2, 0, 0, 702, 703, 1, 0, 0, 0, 703, 704, 6, 92, 1, 0, 704, 705, 6, 92, 4, 0, 705, 192, 1, 0, 0, 0, 706, 707, 3, 283, 138, 0, 707, 708, 7, 3, 0, 0, 708, 709, 7, 3, 0, 0, 709, 710, 7, 3, 0, 0, 710, 711, 1, 0, 0, 0, 711, 712, 6, 93, 1, 0, 712, 713, 6, 93, 5, 0, 713, 194, 1, 0, 0, 0, 714, 715, 9, 0, 0, 0, 715, 196, 1, 0, 0, 0, 716, 717, 7, 2, 0, 0, 717, 718, 1, 0, 0, 0, 718, 719, 6, 95, 6, 0, 719, 720, 6, 95, 7, 0, 720, 198, 1, 0, 0, 0, 721, 722, 3, 279, 136, 0, 722, 723, 1, 0, 0, 0, 723, 724, 6, 96, 8, 0, 724, 200, 1, 0, 0, 0, 725, 726, 5, 123, 0, 0, 726, 727, 1, 0, 0, 0, 727, 728, 6, 97, 9, 0, 728, 202, 1, 0, 0, 0, 729, 730, 7, 3, 0, 0, 730, 731, 1, 0, 0, 0, 731, 732, 6, 98, 6, 0, 732, 733, 6, 98, 7, 0, 733, 204, 1, 0, 0, 0, 734, 735, 3, 281, 137, 0, 735, 736, 1, 0, 0, 0, 736, 737, 6, 99, 8, 0, 737, 206, 1, 0, 0, 0, 738, 739, 5, 123, 0, 0, 739, 740, 1, 0, 0, 0, 740, 741, 6, 100, 9, 0, 741, 208, 1, 0, 0, 0, 742, 743, 7, 2, 0, 0, 743, 744, 7, 2, 0, 0, 744, 745, 7, 2, 0, 0, 745, 746, 1, 0, 0, 0, 746, 747, 6, 101, 6, 0, 747, 748, 6, 101, 7, 0, 748, 210, 1, 0, 0, 0, 749, 750, 3, 279, 136, 0, 750, 751, 1, 0, 0, 0, 751, 752, 6, 102, 8, 0, 752, 212, 1, 0, 0, 0, 753, 754, 5, 123, 0, 0, 754, 755, 1, 0, 0, 0, 755, 756, 6, 103, 9, 0, 756, 214, 1, 0, 0, 0, 757, 758, 7, 3, 0, 0, 758, 759, 7, 3, 0, 0, 759, 760, 7, 3, 0, 0, 760, 761, 1, 0, 0, 0, 761, 762, 6, 104, 6, 0, 762, 763, 6, 104, 7, 0, 763, 216, 1, 0, 0, 0, 764, 765, 3, 281, 137, 0, 765, 766, 1, 0, 0, 0, 766, 767, 6, 105, 8, 0, 767, 218, 1, 0, 0, 0, 768, 769, 5, 123, 0, 0, 769, 770, 1, 0, 0, 0, 770, 771, 6, 106, 9, 0, 771, 220, 1, 0, 0, 0, 772, 774, 3, 285, 139, 0, 773, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 773, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 778, 6, 107, 8, 0, 778, 222, 1, 0, 0, 0, 779, 780, 5, 123, 0, 0, 780, 781, 1, 0, 0, 0, 781, 782, 6, 108, 9, 0, 782, 224, 1, 0, 0, 0, 783, 784, 5, 125, 0, 0, 784, 785, 1, 0, 0, 0, 785, 786, 6, 109, 10, 0, 786, 226, 1, 0, 0, 0, 787, 789, 3, 287, 140, 0, 788, 787, 1, 0, 0, 0, 789, 790, 1, 0, 0, 0, 790, 788, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 793, 6, 110, 8, 0, 793, 228, 1, 0, 0, 0, 794, 795, 5, 123, 0, 0, 795, 796, 1, 0, 0, 0, 796, 797, 6, 111, 9, 0, 797, 230, 1, 0, 0, 0, 798, 799, 5, 125, 0, 0, 799, 800, 1, 0, 0, 0, 800, 801, 6, 112, 10, 0, 801, 232, 1, 0, 0, 0, 802, 803, 5, 105, 0, 0, 803, 804, 5, 103, 0, 0, 804, 805, 5, 110, 0, 0, 805, 806, 5, 111, 0, 0, 806, 807, 5, 114, 0, 0, 807, 808, 5, 101, 0, 0, 808, 234, 1, 0, 0, 0, 809, 811, 3, 237, 115, 0, 810, 809, 1, 0, 0, 0, 810, 811, 1, 0, 0, 0, 811, 814, 1, 0, 0, 0, 812, 815, 3, 239, 116, 0, 813, 815, 3, 241, 117, 0, 814, 812, 1, 0, 0, 0, 814, 813, 1, 0, 0, 0, 815, 236, 1, 0, 0, 0, 816, 817, 7, 4, 0, 0, 817, 238, 1, 0, 0, 0, 818, 822, 5, 39, 0, 0, 819, 821, 3, 243, 118, 0, 820, 819, 1, 0, 0, 0, 821, 824, 1, 0, 0, 0, 822, 820, 1, 0, 0, 0, 822, 823, 1, 0, 0, 0, 823, 825, 1, 0, 0, 0, 824, 822, 1, 0, 0, 0, 825, 835, 5, 39, 0, 0, 826, 830, 5, 34, 0, 0, 827, 829, 3, 245, 119, 0, 828, 827, 1, 0, 0, 0, 829, 832, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 833, 1, 0, 0, 0, 832, 830, 1, 0, 0, 0, 833, 835, 5, 34, 0, 0, 834, 818, 1, 0, 0, 0, 834, 826, 1, 0, 0, 0, 835, 240, 1, 0, 0, 0, 836, 837, 5, 39, 0, 0, 837, 838, 5, 39, 0, 0, 838, 839, 5, 39, 0, 0, 839, 843, 1, 0, 0, 0, 840, 842, 3, 247, 120, 0, 841, 840, 1, 0, 0, 0, 842, 845, 1, 0, 0, 0, 843, 844, 1, 0, 0, 0, 843, 841, 1, 0, 0, 0, 844, 846, 1, 0, 0, 0, 845, 843, 1, 0, 0, 0, 846, 847, 5, 39, 0, 0, 847, 848, 5, 39, 0, 0, 848, 863, 5, 39, 0, 0, 849, 850, 5, 34, 0, 0, 850, 851, 5, 34, 0, 0, 851, 852, 5, 34, 0, 0, 852, 856, 1, 0, 0, 0, 853, 855, 3, 247, 120, 0, 854, 853, 1, 0, 0, 0, 855, 858, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 856, 854, 1, 0, 0, 0, 857, 859, 1, 0, 0, 0, 858, 856, 1, 0, 0, 0, 859, 860, 5, 34, 0, 0, 860, 861, 5, 34, 0, 0, 861, 863, 5, 34, 0, 0, 862, 836, 1, 0, 0, 0, 862, 849, 1, 0, 0, 0, 863, 242, 1, 0, 0, 0, 864, 867, 3, 249, 121, 0, 865, 867, 3, 255, 124, 0, 866, 864, 1, 0, 0, 0, 866, 865, 1, 0, 0, 0, 867, 244, 1, 0, 0, 0, 868, 871, 3, 251, 122, 0, 869, 871, 3, 255, 124, 0, 870, 868, 1, 0, 0, 0, 870, 869, 1, 0, 0, 0, 871, 246, 1, 0, 0, 0, 872, 875, 3, 253, 123, 0, 873, 875, 3, 255, 124, 0, 874, 872, 1, 0, 0, 0, 874, 873, 1, 0, 0, 0, 875, 248, 1, 0, 0, 0, 876, 877, 8, 5, 0, 0, 877, 250, 1, 0, 0, 0, 878, 879, 8, 6, 0, 0, 879, 252, 1, 0, 0, 0, 880, 881, 8, 7, 0, 0, 881, 254, 1, 0, 0, 0, 882, 883, 5, 92, 0, 0, 883, 884, 5, 13, 0, 0, 884, 888, 5, 10, 0, 0, 885, 886, 5, 92, 0, 0, 886, 888, 9, 0, 0, 0, 887, 882, 1, 0, 0, 0, 887, 885, 1, 0, 0, 0, 888, 256, 1, 0, 0, 0, 889, 892, 3, 259, 126, 0, 890, 893, 3, 261, 127, 0, 891, 893, 3, 263, 128, 0, 892, 890, 1, 0, 0, 0, 892, 891, 1, 0, 0, 0, 893, 258, 1, 0, 0, 0, 894, 912, 7, 8, 0, 0, 895, 896, 5, 98, 0, 0, 896, 912, 5, 114, 0, 0, 897, 898, 5, 66, 0, 0, 898, 912, 5, 114, 0, 0, 899, 900, 5, 98, 0, 0, 900, 912, 5, 82, 0, 0, 901, 902, 5, 66, 0, 0, 902, 912, 5, 82, 0, 0, 903, 904, 5, 114, 0, 0, 904, 912, 5, 98, 0, 0, 905, 906, 5, 114, 0, 0, 906, 912, 5, 66, 0, 0, 907, 908, 5, 82, 0, 0, 908, 912, 5, 98, 0, 0, 909, 910, 5, 82, 0, 0, 910, 912, 5, 66, 0, 0, 911, 894, 1, 0, 0, 0, 911, 895, 1, 0, 0, 0, 911, 897, 1, 0, 0, 0, 911, 899, 1, 0, 0, 0, 911, 901, 1, 0, 0, 0, 911, 903, 1, 0, 0, 0, 911, 905, 1, 0, 0, 0, 911, 907, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 912, 260, 1, 0, 0, 0, 913, 917, 5, 39, 0, 0, 914, 916, 3, 265, 129, 0, 915, 914, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 920, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 920, 930, 5, 39, 0, 0, 921, 925, 5, 34, 0, 0, 922, 924, 3, 267, 130, 0, 923, 922, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 928, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 928, 930, 5, 34, 0, 0, 929, 913, 1, 0, 0, 0, 929, 921, 1, 0, 0, 0, 930, 262, 1, 0, 0, 0, 931, 932, 5, 39, 0, 0, 932, 933, 5, 39, 0, 0, 933, 934, 5, 39, 0, 0, 934, 938, 1, 0, 0, 0, 935, 937, 3, 269, 131, 0, 936, 935, 1, 0, 0, 0, 937, 940, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 938, 936, 1, 0, 0, 0, 939, 941, 1, 0, 0, 0, 940, 938, 1, 0, 0, 0, 941, 942, 5, 39, 0, 0, 942, 943, 5, 39, 0, 0, 943, 958, 5, 39, 0, 0, 944, 945, 5, 34, 0, 0, 945, 946, 5, 34, 0, 0, 946, 947, 5, 34, 0, 0, 947, 951, 1, 0, 0, 0, 948, 950, 3, 269, 131, 0, 949, 948, 1, 0, 0, 0, 950, 953, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 951, 949, 1, 0, 0, 0, 952, 954, 1, 0, 0, 0, 953, 951, 1, 0, 0, 0, 954, 955, 5, 34, 0, 0, 955, 956, 5, 34, 0, 0, 956, 958, 5, 34, 0, 0, 957, 931, 1, 0, 0, 0, 957, 944, 1, 0, 0, 0, 958, 264, 1, 0, 0, 0, 959, 962, 3, 271, 132, 0, 960, 962, 3, 277, 135, 0, 961, 959, 1, 0, 0, 0, 961, 960, 1, 0, 0, 0, 962, 266, 1, 0, 0, 0, 963, 966, 3, 273, 133, 0, 964, 966, 3, 277, 135, 0, 965, 963, 1, 0, 0, 0, 965, 964, 1, 0, 0, 0, 966, 268, 1, 0, 0, 0, 967, 970, 3, 275, 134, 0, 968, 970, 3, 277, 135, 0, 969, 967, 1, 0, 0, 0, 969, 968, 1, 0, 0, 0, 970, 270, 1, 0, 0, 0, 971, 973, 7, 9, 0, 0, 972, 971, 1, 0, 0, 0, 973, 272, 1, 0, 0, 0, 974, 976, 7, 10, 0, 0, 975, 974, 1, 0, 0, 0, 976, 274, 1, 0, 0, 0, 977, 979, 7, 11, 0, 0, 978, 977, 1, 0, 0, 0, 979, 276, 1, 0, 0, 0, 980, 981, 5, 92, 0, 0, 981, 982, 7, 12, 0, 0, 982, 278, 1, 0, 0, 0, 983, 986, 3, 285, 139, 0, 984, 986, 3, 289, 141, 0, 985, 983, 1, 0, 0, 0, 985, 984, 1, 0, 0, 0, 986, 987, 1, 0, 0, 0, 987, 985, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 280, 1, 0, 0, 0, 989, 992, 3, 287, 140, 0, 990, 992, 3, 289, 141, 0, 991, 989, 1, 0, 0, 0, 991, 990, 1, 0, 0, 0, 992, 993, 1, 0, 0, 0, 993, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 282, 1, 0, 0, 0, 995, 1013, 7, 13, 0, 0, 996, 997, 5, 102, 0, 0, 997, 1013, 5, 114, 0, 0, 998, 999, 5, 70, 0, 0, 999, 1013, 5, 114, 0, 0, 1000, 1001, 5, 102, 0, 0, 1001, 1013, 5, 82, 0, 0, 1002, 1003, 5, 70, 0, 0, 1003, 1013, 5, 82, 0, 0, 1004, 1005, 5, 114, 0, 0, 1005, 1013, 5, 102, 0, 0, 1006, 1007, 5, 114, 0, 0, 1007, 1013, 5, 70, 0, 0, 1008, 1009, 5, 82, 0, 0, 1009, 1013, 5, 102, 0, 0, 1010, 1011, 5, 82, 0, 0, 1011, 1013, 5, 70, 0, 0, 1012, 995, 1, 0, 0, 0, 1012, 996, 1, 0, 0, 0, 1012, 998, 1, 0, 0, 0, 1012, 1000, 1, 0, 0, 0, 1012, 1002, 1, 0, 0, 0, 1012, 1004, 1, 0, 0, 0, 1012, 1006, 1, 0, 0, 0, 1012, 1008, 1, 0, 0, 0, 1012, 1010, 1, 0, 0, 0, 1013, 284, 1, 0, 0, 0, 1014, 1015, 8, 14, 0, 0, 1015, 286, 1, 0, 0, 0, 1016, 1017, 8, 15, 0, 0, 1017, 288, 1, 0, 0, 0, 1018, 1019, 5, 123, 0, 0, 1019, 1023, 5, 123, 0, 0, 1020, 1021, 5, 125, 0, 0, 1021, 1023, 5, 125, 0, 0, 1022, 1018, 1, 0, 0, 0, 1022, 1020, 1, 0, 0, 0, 1023, 290, 1, 0, 0, 0, 1024, 1029, 3, 293, 143, 0, 1025, 1029, 3, 295, 144, 0, 1026, 1029, 3, 297, 145, 0, 1027, 1029, 3, 299, 146, 0, 1028, 1024, 1, 0, 0, 0, 1028, 1025, 1, 0, 0, 0, 1028, 1026, 1, 0, 0, 0, 1028, 1027, 1, 0, 0, 0, 1029, 292, 1, 0, 0, 0, 1030, 1037, 3, 301, 147, 0, 1031, 1033, 5, 95, 0, 0, 1032, 1031, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1034, 1, 0, 0, 0, 1034, 1036, 3, 303, 148, 0, 1035, 1032, 1, 0, 0, 0, 1036, 1039, 1, 0, 0, 0, 1037, 1035, 1, 0, 0, 0, 1037, 1038, 1, 0, 0, 0, 1038, 1055, 1, 0, 0, 0, 1039, 1037, 1, 0, 0, 0, 1040, 1042, 5, 48, 0, 0, 1041, 1040, 1, 0, 0, 0, 1042, 1043, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1051, 1, 0, 0, 0, 1045, 1047, 5, 95, 0, 0, 1046, 1045, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1048, 1, 0, 0, 0, 1048, 1050, 5, 48, 0, 0, 1049, 1046, 1, 0, 0, 0, 1050, 1053, 1, 0, 0, 0, 1051, 1049, 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1055, 1, 0, 0, 0, 1053, 1051, 1, 0, 0, 0, 1054, 1030, 1, 0, 0, 0, 1054, 1041, 1, 0, 0, 0, 1055, 294, 1, 0, 0, 0, 1056, 1057, 5, 48, 0, 0, 1057, 1062, 7, 8, 0, 0, 1058, 1060, 5, 95, 0, 0, 1059, 1058, 1, 0, 0, 0, 1059, 1060, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1063, 3, 305, 149, 0, 1062, 1059, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, 1064, 1062, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, 296, 1, 0, 0, 0, 1066, 1067, 5, 48, 0, 0, 1067, 1072, 7, 16, 0, 0, 1068, 1070, 5, 95, 0, 0, 1069, 1068, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1073, 3, 307, 150, 0, 1072, 1069, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1072, 1, 0, 0, 0, 1074, 1075, 1, 0, 0, 0, 1075, 298, 1, 0, 0, 0, 1076, 1077, 5, 48, 0, 0, 1077, 1082, 7, 17, 0, 0, 1078, 1080, 5, 95, 0, 0, 1079, 1078, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 1081, 1, 0, 0, 0, 1081, 1083, 3, 309, 151, 0, 1082, 1079, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1082, 1, 0, 0, 0, 1084, 1085, 1, 0, 0, 0, 1085, 300, 1, 0, 0, 0, 1086, 1087, 7, 18, 0, 0, 1087, 302, 1, 0, 0, 0, 1088, 1089, 7, 19, 0, 0, 1089, 304, 1, 0, 0, 0, 1090, 1091, 2, 48, 49, 0, 1091, 306, 1, 0, 0, 0, 1092, 1093, 7, 20, 0, 0, 1093, 308, 1, 0, 0, 0, 1094, 1097, 3, 303, 148, 0, 1095, 1097, 7, 21, 0, 0, 1096, 1094, 1, 0, 0, 0, 1096, 1095, 1, 0, 0, 0, 1097, 310, 1, 0, 0, 0, 1098, 1101, 3, 313, 153, 0, 1099, 1101, 3, 315, 154, 0, 1100, 1098, 1, 0, 0, 0, 1100, 1099, 1, 0, 0, 0, 1101, 312, 1, 0, 0, 0, 1102, 1104, 3, 317, 155, 0, 1103, 1102, 1, 0, 0, 0, 1103, 1104, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 1110, 3, 319, 156, 0, 1106, 1107, 3, 317, 155, 0, 1107, 1108, 5, 46, 0, 0, 1108, 1110, 1, 0, 0, 0, 1109, 1103, 1, 0, 0, 0, 1109, 1106, 1, 0, 0, 0, 1110, 314, 1, 0, 0, 0, 1111, 1114, 3, 317, 155, 0, 1112, 1114, 3, 313, 153, 0, 1113, 1111, 1, 0, 0, 0, 1113, 1112, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1116, 3, 321, 157, 0, 1116, 316, 1, 0, 0, 0, 1117, 1124, 3, 303, 148, 0, 1118, 1120, 5, 95, 0, 0, 1119, 1118, 1, 0, 0, 0, 1119, 1120, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1123, 3, 303, 148, 0, 1122, 1119, 1, 0, 0, 0, 1123, 1126, 1, 0, 0, 0, 1124, 1122, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, 1125, 318, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1127, 1128, 5, 46, 0, 0, 1128, 1129, 3, 317, 155, 0, 1129, 320, 1, 0, 0, 0, 1130, 1132, 7, 22, 0, 0, 1131, 1133, 7, 23, 0, 0, 1132, 1131, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, 1134, 1, 0, 0, 0, 1134, 1135, 3, 317, 155, 0, 1135, 322, 1, 0, 0, 0, 1136, 1139, 3, 311, 152, 0, 1137, 1139, 3, 317, 155, 0, 1138, 1136, 1, 0, 0, 0, 1138, 1137, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1141, 7, 24, 0, 0, 1141, 324, 1, 0, 0, 0, 1142, 1145, 3, 327, 160, 0, 1143, 1145, 7, 25, 0, 0, 1144, 1142, 1, 0, 0, 0, 1144, 1143, 1, 0, 0, 0, 1145, 326, 1, 0, 0, 0, 1146, 1147, 7, 26, 0, 0, 1147, 328, 1, 0, 0, 0, 70, 0, 1, 2, 3, 4, 5, 6, 648, 654, 658, 661, 669, 677, 775, 790, 810, 814, 822, 830, 834, 843, 856, 862, 866, 870, 874, 887, 892, 911, 917, 925, 929, 938, 951, 957, 961, 965, 969, 972, 975, 978, 985, 987, 991, 993, 1012, 1022, 1028, 1032, 1037, 1043, 1046, 1051, 1054, 1059, 1064, 1069, 1074, 1079, 1084, 1096, 1100, 1103, 1109, 1113, 1119, 1124, 1132, 1138, 1144, 11, 0, 1, 0, 7, 4, 0, 5, 1, 0, 5, 2, 0, 5, 3, 0, 5, 4, 0, 7, 6, 0, 4, 0, 0, 7, 5, 0, 7, 44, 0, 7, 47, 0] \ No newline at end of file diff --git a/src/main/java/PythonLexer.java b/src/main/java/PythonLexer.java new file mode 100644 index 0000000..20dbd8f --- /dev/null +++ b/src/main/java/PythonLexer.java @@ -0,0 +1,1209 @@ +// Generated from PythonLexer.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class PythonLexer extends PythonLexerBase { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + INDENT = 1, DEDENT = 2, TYPE_COMMENT = 3, FSTRING_START = 4, FSTRING_MIDDLE = 5, + FSTRING_END = 6, FALSE = 7, AWAIT = 8, ELSE = 9, IMPORT = 10, PASS = 11, NONE = 12, + BREAK = 13, EXCEPT = 14, IN = 15, RAISE = 16, TRUE = 17, CLASS = 18, FINALLY = 19, IS = 20, + RETURN = 21, AND = 22, CONTINUE = 23, FOR = 24, LAMBDA = 25, TRY = 26, AS = 27, DEF = 28, + FROM = 29, NONLOCAL = 30, WHILE = 31, ASSERT = 32, DEL = 33, GLOBAL = 34, NOT = 35, + WITH = 36, ASYNC = 37, ELIF = 38, IF = 39, OR = 40, YIELD = 41, LPAR = 42, LSQB = 43, + LBRACE = 44, RPAR = 45, RSQB = 46, RBRACE = 47, DOT = 48, COLON = 49, COMMA = 50, SEMI = 51, + PLUS = 52, MINUS = 53, STAR = 54, SLASH = 55, VBAR = 56, AMPER = 57, LESS = 58, GREATER = 59, + EQUAL = 60, PERCENT = 61, EQEQUAL = 62, NOTEQUAL = 63, LESSEQUAL = 64, GREATEREQUAL = 65, + TILDE = 66, CIRCUMFLEX = 67, LEFTSHIFT = 68, RIGHTSHIFT = 69, DOUBLESTAR = 70, PLUSEQUAL = 71, + MINEQUAL = 72, STAREQUAL = 73, SLASHEQUAL = 74, PERCENTEQUAL = 75, AMPEREQUAL = 76, + VBAREQUAL = 77, CIRCUMFLEXEQUAL = 78, LEFTSHIFTEQUAL = 79, RIGHTSHIFTEQUAL = 80, + DOUBLESTAREQUAL = 81, DOUBLESLASH = 82, DOUBLESLASHEQUAL = 83, AT = 84, ATEQUAL = 85, + RARROW = 86, ELLIPSIS = 87, COLONEQUAL = 88, EXCLAMATION = 89, NAME = 90, NUMBER = 91, + STRING = 92, NEWLINE = 93, COMMENT = 94, WS = 95, EXPLICIT_LINE_JOINING = 96, ERRORTOKEN = 97; + public static final int + SINGLE_QUOTE_FSTRING_MODE = 1, DOUBLE_QUOTE_FSTRING_MODE = 2, LONG_SINGLE_QUOTE_FSTRING_MODE = 3, + LONG_DOUBLE_QUOTE_FSTRING_MODE = 4, SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE = 5, + DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE = 6; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE", "SINGLE_QUOTE_FSTRING_MODE", "DOUBLE_QUOTE_FSTRING_MODE", + "LONG_SINGLE_QUOTE_FSTRING_MODE", "LONG_DOUBLE_QUOTE_FSTRING_MODE", "SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE", + "DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE" + }; + + private static String[] makeRuleNames() { + return new String[]{ + "FALSE", "AWAIT", "ELSE", "IMPORT", "PASS", "NONE", "BREAK", "EXCEPT", + "IN", "RAISE", "TRUE", "CLASS", "FINALLY", "IS", "RETURN", "AND", "CONTINUE", + "FOR", "LAMBDA", "TRY", "AS", "DEF", "FROM", "NONLOCAL", "WHILE", "ASSERT", + "DEL", "GLOBAL", "NOT", "WITH", "ASYNC", "ELIF", "IF", "OR", "YIELD", + "LPAR", "LSQB", "LBRACE", "RPAR", "RSQB", "RBRACE", "DOT", "COLON", "COMMA", + "SEMI", "PLUS", "MINUS", "STAR", "SLASH", "VBAR", "AMPER", "LESS", "GREATER", + "EQUAL", "PERCENT", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", "GREATEREQUAL", + "TILDE", "CIRCUMFLEX", "LEFTSHIFT", "RIGHTSHIFT", "DOUBLESTAR", "PLUSEQUAL", + "MINEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", + "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", + "DOUBLESTAREQUAL", "DOUBLESLASH", "DOUBLESLASHEQUAL", "AT", "ATEQUAL", + "RARROW", "ELLIPSIS", "COLONEQUAL", "EXCLAMATION", "NAME", "NUMBER", + "STRING", "NEWLINE", "COMMENT", "WS", "EXPLICIT_LINE_JOINING", "SINGLE_QUOTE_FSTRING_START", + "DOUBLE_QUOTE_FSTRING_START", "LONG_SINGLE_QUOTE_FSTRING_START", "LONG_DOUBLE_QUOTE_FSTRING_START", + "ERRORTOKEN", "SINGLE_QUOTE_FSTRING_END", "SINGLE_QUOTE_FSTRING_MIDDLE", + "SINGLE_QUOTE_FSTRING_LBRACE", "DOUBLE_QUOTE_FSTRING_END", "DOUBLE_QUOTE_FSTRING_MIDDLE", + "DOUBLE_QUOTE_FSTRING_LBRACE", "LONG_SINGLE_QUOTE_FSTRING_END", "LONG_SINGLE_QUOTE_FSTRING_MIDDLE", + "LONG_SINGLE_QUOTE_FSTRING_LBRACE", "LONG_DOUBLE_QUOTE_FSTRING_END", + "LONG_DOUBLE_QUOTE_FSTRING_MIDDLE", "LONG_DOUBLE_QUOTE_FSTRING_LBRACE", + "SINGLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE", "SINGLE_QUOTE_FORMAT_SPECIFICATION_LBRACE", + "SINGLE_QUOTE_FORMAT_SPECIFICATION_RBRACE", "DOUBLE_QUOTE_FORMAT_SPECIFICATION_FSTRING_MIDDLE", + "DOUBLE_QUOTE_FORMAT_SPECIFICATION_LBRACE", "DOUBLE_QUOTE_FORMAT_SPECIFICATION_RBRACE", + "IGNORE", "STRING_LITERAL", "STRING_PREFIX", "SHORT_STRING", "LONG_STRING", + "SHORT_STRING_ITEM_FOR_SINGLE_QUOTE", "SHORT_STRING_ITEM_FOR_DOUBLE_QUOTE", + "LONG_STRING_ITEM", "SHORT_STRING_CHAR_NO_SINGLE_QUOTE", "SHORT_STRING_CHAR_NO_DOUBLE_QUOTE", + "LONG_STRING_CHAR", "STRING_ESCAPE_SEQ", "BYTES_LITERAL", "BYTES_PREFIX", + "SHORT_BYTES", "LONG_BYTES", "SHORT_BYTES_ITEM_FOR_SINGLE_QUOTE", "SHORT_BYTES_ITEM_FOR_DOUBLE_QUOTE", + "LONG_BYTES_ITEM", "SHORT_BYTES_CHAR_NO_SINGLE_QUOTE", "SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE", + "LONG_BYTES_CHAR", "BYTES_ESCAPE_SEQ", "SINGLE_QUOTE_FSTRING_LITERAL", + "DOUBLE_QUOTE_FSTRING_LITERAL", "F_STRING_PREFIX", "FORMAT_SPEC_CHAR_NO_SINGLE_QUOTE", + "FORMAT_SPEC_CHAR_NO_DOUBLE_QUOTE", "DOUBLE_BRACES", "INTEGER", "DEC_INTEGER", + "BIN_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "NON_ZERO_DIGIT", "DIGIT", + "BIN_DIGIT", "OCT_DIGIT", "HEX_DIGIT", "FLOAT_NUMBER", "POINT_FLOAT", + "EXPONENT_FLOAT", "DIGIT_PART", "FRACTION", "EXPONENT", "IMAG_NUMBER", + "ID_CONTINUE", "ID_START" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, null, null, null, null, null, null, "'False'", "'await'", "'else'", + "'import'", "'pass'", "'None'", "'break'", "'except'", "'in'", "'raise'", + "'True'", "'class'", "'finally'", "'is'", "'return'", "'and'", "'continue'", + "'for'", "'lambda'", "'try'", "'as'", "'def'", "'from'", "'nonlocal'", + "'while'", "'assert'", "'del'", "'global'", "'not'", "'with'", "'async'", + "'elif'", "'if'", "'or'", "'yield'", "'('", "'['", null, "')'", "']'", + null, "'.'", "':'", "','", "';'", "'+'", "'-'", "'*'", "'/'", "'|'", + "'&'", "'<'", "'>'", "'='", "'%'", "'=='", "'!='", "'<='", "'>='", "'~'", + "'^'", "'<<'", "'>>'", "'**'", "'+='", "'-='", "'*='", "'/='", "'%='", + "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//'", "'//='", "'@'", + "'@='", "'->'", "'...'", "':='", "'!'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "INDENT", "DEDENT", "TYPE_COMMENT", "FSTRING_START", "FSTRING_MIDDLE", + "FSTRING_END", "FALSE", "AWAIT", "ELSE", "IMPORT", "PASS", "NONE", "BREAK", + "EXCEPT", "IN", "RAISE", "TRUE", "CLASS", "FINALLY", "IS", "RETURN", + "AND", "CONTINUE", "FOR", "LAMBDA", "TRY", "AS", "DEF", "FROM", "NONLOCAL", + "WHILE", "ASSERT", "DEL", "GLOBAL", "NOT", "WITH", "ASYNC", "ELIF", "IF", + "OR", "YIELD", "LPAR", "LSQB", "LBRACE", "RPAR", "RSQB", "RBRACE", "DOT", + "COLON", "COMMA", "SEMI", "PLUS", "MINUS", "STAR", "SLASH", "VBAR", "AMPER", + "LESS", "GREATER", "EQUAL", "PERCENT", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", + "GREATEREQUAL", "TILDE", "CIRCUMFLEX", "LEFTSHIFT", "RIGHTSHIFT", "DOUBLESTAR", + "PLUSEQUAL", "MINEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", + "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", + "DOUBLESTAREQUAL", "DOUBLESLASH", "DOUBLESLASHEQUAL", "AT", "ATEQUAL", + "RARROW", "ELLIPSIS", "COLONEQUAL", "EXCLAMATION", "NAME", "NUMBER", + "STRING", "NEWLINE", "COMMENT", "WS", "EXPLICIT_LINE_JOINING", "ERRORTOKEN" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public PythonLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @Override + public String getGrammarFileName() { + return "PythonLexer.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public static final String _serializedATN = + "\u0004\u0000a\u047c\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff\uffff" + + "\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff\uffff" + + "\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002\u0007\u0002" + + "\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002\u0005\u0007\u0005" + + "\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002\b\u0007\b\u0002" + + "\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002\f\u0007\f\u0002" + + "\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f\u0002\u0010" + + "\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012\u0002\u0013" + + "\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015\u0002\u0016" + + "\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018\u0002\u0019" + + "\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b\u0002\u001c" + + "\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e\u0002\u001f" + + "\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002#\u0007" + + "#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002(\u0007" + + "(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002-\u0007" + + "-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u00022\u0007" + + "2\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u00027\u0007" + + "7\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002<\u0007" + + "<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002A\u0007" + + "A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002F\u0007" + + "F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002K\u0007" + + "K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002P\u0007" + + "P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002U\u0007" + + "U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002Z\u0007" + + "Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002_\u0007" + + "_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002d\u0007" + + "d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002i\u0007" + + "i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002n\u0007" + + "n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002s\u0007" + + "s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002x\u0007" + + "x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002}\u0007" + + "}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007\u0080\u0002" + + "\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007\u0083\u0002" + + "\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007\u0086\u0002" + + "\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007\u0089\u0002" + + "\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007\u008c\u0002" + + "\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007\u008f\u0002" + + "\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007\u0092\u0002" + + "\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007\u0095\u0002" + + "\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007\u0098\u0002" + + "\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007\u009b\u0002" + + "\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007\u009e\u0002" + + "\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0001\u0000\u0001\u0000\u0001" + + "\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001" + + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001" + + "\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001" + + "\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001" + + "\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001" + + "\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001" + + "\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t" + + "\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001" + + "\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b" + + "\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001" + + "\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001" + + "\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001" + + "\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001" + + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001" + + "\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001" + + "\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001" + + "\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001" + + "\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001" + + "\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001" + + "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001" + + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001" + + "\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001" + + "\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001" + + "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001" + + "\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001" + + "\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001" + + "\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001" + + " \u0001 \u0001 \u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001" + + "\"\u0001\"\u0001#\u0001#\u0001$\u0001$\u0001%\u0001%\u0001&\u0001&\u0001" + + "\'\u0001\'\u0001(\u0001(\u0001)\u0001)\u0001*\u0001*\u0001+\u0001+\u0001" + + ",\u0001,\u0001-\u0001-\u0001.\u0001.\u0001/\u0001/\u00010\u00010\u0001" + + "1\u00011\u00012\u00012\u00013\u00013\u00014\u00014\u00015\u00015\u0001" + + "6\u00016\u00017\u00017\u00017\u00018\u00018\u00018\u00019\u00019\u0001" + + "9\u0001:\u0001:\u0001:\u0001;\u0001;\u0001<\u0001<\u0001=\u0001=\u0001" + + "=\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001" + + "A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001D\u0001" + + "D\u0001D\u0001E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001G\u0001G\u0001" + + "G\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001J\u0001" + + "J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001" + + "M\u0001M\u0001N\u0001N\u0001N\u0001O\u0001O\u0001O\u0001P\u0001P\u0001" + + "P\u0001P\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001S\u0001S\u0005S\u0287" + + "\bS\nS\fS\u028a\tS\u0001T\u0001T\u0001T\u0003T\u028f\bT\u0001U\u0001U" + + "\u0003U\u0293\bU\u0001V\u0003V\u0296\bV\u0001V\u0001V\u0001W\u0001W\u0005" + + "W\u029c\bW\nW\fW\u029f\tW\u0001W\u0001W\u0001X\u0004X\u02a4\bX\u000bX" + + "\fX\u02a5\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001" + + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0001" + + "[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001" + + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001" + + "_\u0001_\u0001_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001a\u0001" + + "a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001" + + "c\u0001c\u0001d\u0001d\u0001d\u0001d\u0001e\u0001e\u0001e\u0001e\u0001" + + "e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0001" + + "g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001" + + "i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001k\u0004k\u0306\bk\u000bk\fk" + + "\u0307\u0001k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m" + + "\u0001m\u0001n\u0004n\u0315\bn\u000bn\fn\u0316\u0001n\u0001n\u0001o\u0001" + + "o\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001" + + "q\u0001q\u0001q\u0001q\u0001r\u0003r\u032b\br\u0001r\u0001r\u0003r\u032f" + + "\br\u0001s\u0001s\u0001t\u0001t\u0005t\u0335\bt\nt\ft\u0338\tt\u0001t" + + "\u0001t\u0001t\u0005t\u033d\bt\nt\ft\u0340\tt\u0001t\u0003t\u0343\bt\u0001" + + "u\u0001u\u0001u\u0001u\u0001u\u0005u\u034a\bu\nu\fu\u034d\tu\u0001u\u0001" + + "u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0005u\u0357\bu\nu\fu\u035a" + + "\tu\u0001u\u0001u\u0001u\u0003u\u035f\bu\u0001v\u0001v\u0003v\u0363\b" + + "v\u0001w\u0001w\u0003w\u0367\bw\u0001x\u0001x\u0003x\u036b\bx\u0001y\u0001" + + "y\u0001z\u0001z\u0001{\u0001{\u0001|\u0001|\u0001|\u0001|\u0001|\u0003" + + "|\u0378\b|\u0001}\u0001}\u0001}\u0003}\u037d\b}\u0001~\u0001~\u0001~\u0001" + + "~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001" + + "~\u0001~\u0001~\u0001~\u0003~\u0390\b~\u0001\u007f\u0001\u007f\u0005\u007f" + + "\u0394\b\u007f\n\u007f\f\u007f\u0397\t\u007f\u0001\u007f\u0001\u007f\u0001" + + "\u007f\u0005\u007f\u039c\b\u007f\n\u007f\f\u007f\u039f\t\u007f\u0001\u007f" + + "\u0003\u007f\u03a2\b\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080" + + "\u0001\u0080\u0005\u0080\u03a9\b\u0080\n\u0080\f\u0080\u03ac\t\u0080\u0001" + + "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001" + + "\u0080\u0001\u0080\u0005\u0080\u03b6\b\u0080\n\u0080\f\u0080\u03b9\t\u0080" + + "\u0001\u0080\u0001\u0080\u0001\u0080\u0003\u0080\u03be\b\u0080\u0001\u0081" + + "\u0001\u0081\u0003\u0081\u03c2\b\u0081\u0001\u0082\u0001\u0082\u0003\u0082" + + "\u03c6\b\u0082\u0001\u0083\u0001\u0083\u0003\u0083\u03ca\b\u0083\u0001" + + "\u0084\u0003\u0084\u03cd\b\u0084\u0001\u0085\u0003\u0085\u03d0\b\u0085" + + "\u0001\u0086\u0003\u0086\u03d3\b\u0086\u0001\u0087\u0001\u0087\u0001\u0087" + + "\u0001\u0088\u0001\u0088\u0004\u0088\u03da\b\u0088\u000b\u0088\f\u0088" + + "\u03db\u0001\u0089\u0001\u0089\u0004\u0089\u03e0\b\u0089\u000b\u0089\f" + + "\u0089\u03e1\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a" + + "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a" + + "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a" + + "\u0003\u008a\u03f5\b\u008a\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c" + + "\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u03ff\b\u008d" + + "\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0003\u008e\u0405\b\u008e" + + "\u0001\u008f\u0001\u008f\u0003\u008f\u0409\b\u008f\u0001\u008f\u0005\u008f" + + "\u040c\b\u008f\n\u008f\f\u008f\u040f\t\u008f\u0001\u008f\u0004\u008f\u0412" + + "\b\u008f\u000b\u008f\f\u008f\u0413\u0001\u008f\u0003\u008f\u0417\b\u008f" + + "\u0001\u008f\u0005\u008f\u041a\b\u008f\n\u008f\f\u008f\u041d\t\u008f\u0003" + + "\u008f\u041f\b\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0424" + + "\b\u0090\u0001\u0090\u0004\u0090\u0427\b\u0090\u000b\u0090\f\u0090\u0428" + + "\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u042e\b\u0091\u0001\u0091" + + "\u0004\u0091\u0431\b\u0091\u000b\u0091\f\u0091\u0432\u0001\u0092\u0001" + + "\u0092\u0001\u0092\u0003\u0092\u0438\b\u0092\u0001\u0092\u0004\u0092\u043b" + + "\b\u0092\u000b\u0092\f\u0092\u043c\u0001\u0093\u0001\u0093\u0001\u0094" + + "\u0001\u0094\u0001\u0095\u0001\u0095\u0001\u0096\u0001\u0096\u0001\u0097" + + "\u0001\u0097\u0003\u0097\u0449\b\u0097\u0001\u0098\u0001\u0098\u0003\u0098" + + "\u044d\b\u0098\u0001\u0099\u0003\u0099\u0450\b\u0099\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0456\b\u0099\u0001\u009a\u0001" + + "\u009a\u0003\u009a\u045a\b\u009a\u0001\u009a\u0001\u009a\u0001\u009b\u0001" + + "\u009b\u0003\u009b\u0460\b\u009b\u0001\u009b\u0005\u009b\u0463\b\u009b" + + "\n\u009b\f\u009b\u0466\t\u009b\u0001\u009c\u0001\u009c\u0001\u009c\u0001" + + "\u009d\u0001\u009d\u0003\u009d\u046d\b\u009d\u0001\u009d\u0001\u009d\u0001" + + "\u009e\u0001\u009e\u0003\u009e\u0473\b\u009e\u0001\u009e\u0001\u009e\u0001" + + "\u009f\u0001\u009f\u0003\u009f\u0479\b\u009f\u0001\u00a0\u0001\u00a0\u0004" + + "\u034b\u0358\u03aa\u03b7\u0000\u00a1\u0007\u0007\t\b\u000b\t\r\n\u000f" + + "\u000b\u0011\f\u0013\r\u0015\u000e\u0017\u000f\u0019\u0010\u001b\u0011" + + "\u001d\u0012\u001f\u0013!\u0014#\u0015%\u0016\'\u0017)\u0018+\u0019-\u001a" + + "/\u001b1\u001c3\u001d5\u001e7\u001f9 ;!=\"?#A$C%E&G\'I(K)M*O+Q,S-U.W/" + + "Y0[1]2_3a4c5e6g7i8k9m:o;qw?y@{A}B\u007fC\u0081D\u0083E\u0085F\u0087" + + "G\u0089H\u008bI\u008dJ\u008fK\u0091L\u0093M\u0095N\u0097O\u0099P\u009b" + + "Q\u009dR\u009fS\u00a1T\u00a3U\u00a5V\u00a7W\u00a9X\u00abY\u00adZ\u00af" + + "[\u00b1\\\u00b3]\u00b5^\u00b7_\u00b9`\u00bb\u0000\u00bd\u0000\u00bf\u0000" + + "\u00c1\u0000\u00c3a\u00c5\u0000\u00c7\u0000\u00c9\u0000\u00cb\u0000\u00cd" + + "\u0000\u00cf\u0000\u00d1\u0000\u00d3\u0000\u00d5\u0000\u00d7\u0000\u00d9" + + "\u0000\u00db\u0000\u00dd\u0000\u00df\u0000\u00e1\u0000\u00e3\u0000\u00e5" + + "\u0000\u00e7\u0000\u00e9\u0000\u00eb\u0000\u00ed\u0000\u00ef\u0000\u00f1" + + "\u0000\u00f3\u0000\u00f5\u0000\u00f7\u0000\u00f9\u0000\u00fb\u0000\u00fd" + + "\u0000\u00ff\u0000\u0101\u0000\u0103\u0000\u0105\u0000\u0107\u0000\u0109" + + "\u0000\u010b\u0000\u010d\u0000\u010f\u0000\u0111\u0000\u0113\u0000\u0115" + + "\u0000\u0117\u0000\u0119\u0000\u011b\u0000\u011d\u0000\u011f\u0000\u0121" + + "\u0000\u0123\u0000\u0125\u0000\u0127\u0000\u0129\u0000\u012b\u0000\u012d" + + "\u0000\u012f\u0000\u0131\u0000\u0133\u0000\u0135\u0000\u0137\u0000\u0139" + + "\u0000\u013b\u0000\u013d\u0000\u013f\u0000\u0141\u0000\u0143\u0000\u0145" + + "\u0000\u0147\u0000\u0007\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u001b" + + "\u0002\u0000\n\n\r\r\u0003\u0000\t\t\f\f \u0001\u0000\'\'\u0001\u0000" + + "\"\"\u0004\u0000RRUUrruu\u0004\u0000\n\n\r\r\'\'\\\\\u0004\u0000\n\n\r" + + "\r\"\"\\\\\u0001\u0000\\\\\u0002\u0000BBbb\u0005\u0000\u0000\t\u000b\f" + + "\u000e&([]\u007f\u0005\u0000\u0000\t\u000b\f\u000e!#[]\u007f\u0002\u0000" + + "\u0000[]\u007f\u0001\u0000\u0000\u007f\u0002\u0000FFff\u0003\u0000\'\'" + + "{{}}\u0003\u0000\"\"{{}}\u0002\u0000OOoo\u0002\u0000XXxx\u0001\u00001" + + "9\u0001\u000009\u0001\u000007\u0002\u0000AFaf\u0002\u0000EEee\u0002\u0000" + + "++--\u0002\u0000JJjj\u0176\u000009\u00b7\u00b7\u0300\u036f\u0387\u0387" + + "\u0483\u0487\u0591\u05bd\u05bf\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05c7" + + "\u0610\u061a\u064b\u0669\u0670\u0670\u06d6\u06dc\u06df\u06e4\u06e7\u06e8" + + "\u06ea\u06ed\u06f0\u06f9\u0711\u0711\u0730\u074a\u07a6\u07b0\u07c0\u07c9" + + "\u07eb\u07f3\u07fd\u07fd\u0816\u0819\u081b\u0823\u0825\u0827\u0829\u082d" + + "\u0859\u085b\u0898\u089f\u08ca\u08e1\u08e3\u0903\u093a\u093c\u093e\u094f" + + "\u0951\u0957\u0962\u0963\u0966\u096f\u0981\u0983\u09bc\u09bc\u09be\u09c4" + + "\u09c7\u09c8\u09cb\u09cd\u09d7\u09d7\u09e2\u09e3\u09e6\u09ef\u09fe\u09fe" + + "\u0a01\u0a03\u0a3c\u0a3c\u0a3e\u0a42\u0a47\u0a48\u0a4b\u0a4d\u0a51\u0a51" + + "\u0a66\u0a71\u0a75\u0a75\u0a81\u0a83\u0abc\u0abc\u0abe\u0ac5\u0ac7\u0ac9" + + "\u0acb\u0acd\u0ae2\u0ae3\u0ae6\u0aef\u0afa\u0aff\u0b01\u0b03\u0b3c\u0b3c" + + "\u0b3e\u0b44\u0b47\u0b48\u0b4b\u0b4d\u0b55\u0b57\u0b62\u0b63\u0b66\u0b6f" + + "\u0b82\u0b82\u0bbe\u0bc2\u0bc6\u0bc8\u0bca\u0bcd\u0bd7\u0bd7\u0be6\u0bef" + + "\u0c00\u0c04\u0c3c\u0c3c\u0c3e\u0c44\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56" + + "\u0c62\u0c63\u0c66\u0c6f\u0c81\u0c83\u0cbc\u0cbc\u0cbe\u0cc4\u0cc6\u0cc8" + + "\u0cca\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6\u0cef\u0cf3\u0cf3\u0d00\u0d03" + + "\u0d3b\u0d3c\u0d3e\u0d44\u0d46\u0d48\u0d4a\u0d4d\u0d57\u0d57\u0d62\u0d63" + + "\u0d66\u0d6f\u0d81\u0d83\u0dca\u0dca\u0dcf\u0dd4\u0dd6\u0dd6\u0dd8\u0ddf" + + "\u0de6\u0def\u0df2\u0df3\u0e31\u0e31\u0e33\u0e3a\u0e47\u0e4e\u0e50\u0e59" + + "\u0eb1\u0eb1\u0eb3\u0ebc\u0ec8\u0ece\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29" + + "\u0f35\u0f35\u0f37\u0f37\u0f39\u0f39\u0f3e\u0f3f\u0f71\u0f84\u0f86\u0f87" + + "\u0f8d\u0f97\u0f99\u0fbc\u0fc6\u0fc6\u102b\u103e\u1040\u1049\u1056\u1059" + + "\u105e\u1060\u1062\u1064\u1067\u106d\u1071\u1074\u1082\u108d\u108f\u109d" + + "\u135d\u135f\u1369\u1371\u1712\u1715\u1732\u1734\u1752\u1753\u1772\u1773" + + "\u17b4\u17d3\u17dd\u17dd\u17e0\u17e9\u180b\u180d\u180f\u1819\u18a9\u18a9" + + "\u1920\u192b\u1930\u193b\u1946\u194f\u19d0\u19da\u1a17\u1a1b\u1a55\u1a5e" + + "\u1a60\u1a7c\u1a7f\u1a89\u1a90\u1a99\u1ab0\u1abd\u1abf\u1ace\u1b00\u1b04" + + "\u1b34\u1b44\u1b50\u1b59\u1b6b\u1b73\u1b80\u1b82\u1ba1\u1bad\u1bb0\u1bb9" + + "\u1be6\u1bf3\u1c24\u1c37\u1c40\u1c49\u1c50\u1c59\u1cd0\u1cd2\u1cd4\u1ce8" + + "\u1ced\u1ced\u1cf4\u1cf4\u1cf7\u1cf9\u1dc0\u1dff\u203f\u2040\u2054\u2054" + + "\u20d0\u20dc\u20e1\u20e1\u20e5\u20f0\u2cef\u2cf1\u2d7f\u2d7f\u2de0\u2dff" + + "\u302a\u302f\u3099\u309a\u8000\ua620\u8000\ua629\u8000\ua66f\u8000\ua66f" + + "\u8000\ua674\u8000\ua67d\u8000\ua69e\u8000\ua69f\u8000\ua6f0\u8000\ua6f1" + + "\u8000\ua802\u8000\ua802\u8000\ua806\u8000\ua806\u8000\ua80b\u8000\ua80b" + + "\u8000\ua823\u8000\ua827\u8000\ua82c\u8000\ua82c\u8000\ua880\u8000\ua881" + + "\u8000\ua8b4\u8000\ua8c5\u8000\ua8d0\u8000\ua8d9\u8000\ua8e0\u8000\ua8f1" + + "\u8000\ua8ff\u8000\ua909\u8000\ua926\u8000\ua92d\u8000\ua947\u8000\ua953" + + "\u8000\ua980\u8000\ua983\u8000\ua9b3\u8000\ua9c0\u8000\ua9d0\u8000\ua9d9" + + "\u8000\ua9e5\u8000\ua9e5\u8000\ua9f0\u8000\ua9f9\u8000\uaa29\u8000\uaa36" + + "\u8000\uaa43\u8000\uaa43\u8000\uaa4c\u8000\uaa4d\u8000\uaa50\u8000\uaa59" + + "\u8000\uaa7b\u8000\uaa7d\u8000\uaab0\u8000\uaab0\u8000\uaab2\u8000\uaab4" + + "\u8000\uaab7\u8000\uaab8\u8000\uaabe\u8000\uaabf\u8000\uaac1\u8000\uaac1" + + "\u8000\uaaeb\u8000\uaaef\u8000\uaaf5\u8000\uaaf6\u8000\uabe3\u8000\uabea" + + "\u8000\uabec\u8000\uabed\u8000\uabf0\u8000\uabf9\u8000\ufb1e\u8000\ufb1e" + + "\u8000\ufe00\u8000\ufe0f\u8000\ufe20\u8000\ufe2f\u8000\ufe33\u8000\ufe34" + + "\u8000\ufe4d\u8000\ufe4f\u8000\uff10\u8000\uff19\u8000\uff3f\u8000\uff3f" + + "\u8000\uff9e\u8000\uff9f\u8001\u01fd\u8001\u01fd\u8001\u02e0\u8001\u02e0" + + "\u8001\u0376\u8001\u037a\u8001\u04a0\u8001\u04a9\u8001\u0a01\u8001\u0a03" + + "\u8001\u0a05\u8001\u0a06\u8001\u0a0c\u8001\u0a0f\u8001\u0a38\u8001\u0a3a" + + "\u8001\u0a3f\u8001\u0a3f\u8001\u0ae5\u8001\u0ae6\u8001\u0d24\u8001\u0d27" + + "\u8001\u0d30\u8001\u0d39\u8001\u0eab\u8001\u0eac\u8001\u0efd\u8001\u0eff" + + "\u8001\u0f46\u8001\u0f50\u8001\u0f82\u8001\u0f85\u8001\u1000\u8001\u1002" + + "\u8001\u1038\u8001\u1046\u8001\u1066\u8001\u1070\u8001\u1073\u8001\u1074" + + "\u8001\u107f\u8001\u1082\u8001\u10b0\u8001\u10ba\u8001\u10c2\u8001\u10c2" + + "\u8001\u10f0\u8001\u10f9\u8001\u1100\u8001\u1102\u8001\u1127\u8001\u1134" + + "\u8001\u1136\u8001\u113f\u8001\u1145\u8001\u1146\u8001\u1173\u8001\u1173" + + "\u8001\u1180\u8001\u1182\u8001\u11b3\u8001\u11c0\u8001\u11c9\u8001\u11cc" + + "\u8001\u11ce\u8001\u11d9\u8001\u122c\u8001\u1237\u8001\u123e\u8001\u123e" + + "\u8001\u1241\u8001\u1241\u8001\u12df\u8001\u12ea\u8001\u12f0\u8001\u12f9" + + "\u8001\u1300\u8001\u1303\u8001\u133b\u8001\u133c\u8001\u133e\u8001\u1344" + + "\u8001\u1347\u8001\u1348\u8001\u134b\u8001\u134d\u8001\u1357\u8001\u1357" + + "\u8001\u1362\u8001\u1363\u8001\u1366\u8001\u136c\u8001\u1370\u8001\u1374" + + "\u8001\u1435\u8001\u1446\u8001\u1450\u8001\u1459\u8001\u145e\u8001\u145e" + + "\u8001\u14b0\u8001\u14c3\u8001\u14d0\u8001\u14d9\u8001\u15af\u8001\u15b5" + + "\u8001\u15b8\u8001\u15c0\u8001\u15dc\u8001\u15dd\u8001\u1630\u8001\u1640" + + "\u8001\u1650\u8001\u1659\u8001\u16ab\u8001\u16b7\u8001\u16c0\u8001\u16c9" + + "\u8001\u171d\u8001\u172b\u8001\u1730\u8001\u1739\u8001\u182c\u8001\u183a" + + "\u8001\u18e0\u8001\u18e9\u8001\u1930\u8001\u1935\u8001\u1937\u8001\u1938" + + "\u8001\u193b\u8001\u193e\u8001\u1940\u8001\u1940\u8001\u1942\u8001\u1943" + + "\u8001\u1950\u8001\u1959\u8001\u19d1\u8001\u19d7\u8001\u19da\u8001\u19e0" + + "\u8001\u19e4\u8001\u19e4\u8001\u1a01\u8001\u1a0a\u8001\u1a33\u8001\u1a39" + + "\u8001\u1a3b\u8001\u1a3e\u8001\u1a47\u8001\u1a47\u8001\u1a51\u8001\u1a5b" + + "\u8001\u1a8a\u8001\u1a99\u8001\u1c2f\u8001\u1c36\u8001\u1c38\u8001\u1c3f" + + "\u8001\u1c50\u8001\u1c59\u8001\u1c92\u8001\u1ca7\u8001\u1ca9\u8001\u1cb6" + + "\u8001\u1d31\u8001\u1d36\u8001\u1d3a\u8001\u1d3a\u8001\u1d3c\u8001\u1d3d" + + "\u8001\u1d3f\u8001\u1d45\u8001\u1d47\u8001\u1d47\u8001\u1d50\u8001\u1d59" + + "\u8001\u1d8a\u8001\u1d8e\u8001\u1d90\u8001\u1d91\u8001\u1d93\u8001\u1d97" + + "\u8001\u1da0\u8001\u1da9\u8001\u1ef3\u8001\u1ef6\u8001\u1f00\u8001\u1f01" + + "\u8001\u1f03\u8001\u1f03\u8001\u1f34\u8001\u1f3a\u8001\u1f3e\u8001\u1f42" + + "\u8001\u1f50\u8001\u1f59\u8001\u3440\u8001\u3440\u8001\u3447\u8001\u3455" + + "\u8001\u6a60\u8001\u6a69\u8001\u6ac0\u8001\u6ac9\u8001\u6af0\u8001\u6af4" + + "\u8001\u6b30\u8001\u6b36\u8001\u6b50\u8001\u6b59\u8001\u6f4f\u8001\u6f4f" + + "\u8001\u6f51\u8001\u6f87\u8001\u6f8f\u8001\u6f92\u8001\u6fe4\u8001\u6fe4" + + "\u8001\u6ff0\u8001\u6ff1\u8001\ubc9d\u8001\ubc9e\u8001\ucf00\u8001\ucf2d" + + "\u8001\ucf30\u8001\ucf46\u8001\ud165\u8001\ud169\u8001\ud16d\u8001\ud172" + + "\u8001\ud17b\u8001\ud182\u8001\ud185\u8001\ud18b\u8001\ud1aa\u8001\ud1ad" + + "\u8001\ud242\u8001\ud244\u8001\ud7ce\u8001\ud7ff\u8001\uda00\u8001\uda36" + + "\u8001\uda3b\u8001\uda6c\u8001\uda75\u8001\uda75\u8001\uda84\u8001\uda84" + + "\u8001\uda9b\u8001\uda9f\u8001\udaa1\u8001\udaaf\u8001\ue000\u8001\ue006" + + "\u8001\ue008\u8001\ue018\u8001\ue01b\u8001\ue021\u8001\ue023\u8001\ue024" + + "\u8001\ue026\u8001\ue02a\u8001\ue08f\u8001\ue08f\u8001\ue130\u8001\ue136" + + "\u8001\ue140\u8001\ue149\u8001\ue2ae\u8001\ue2ae\u8001\ue2ec\u8001\ue2f9" + + "\u8001\ue4ec\u8001\ue4f9\u8001\ue8d0\u8001\ue8d6\u8001\ue944\u8001\ue94a" + + "\u8001\ue950\u8001\ue959\u8001\ufbf0\u8001\ufbf9\u800e\u0100\u800e\u01ef" + + "\u029b\u0000AZ__az\u00aa\u00aa\u00b5\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8" + + "\u00f6\u00f8\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ec\u02ee\u02ee\u0370" + + "\u0374\u0376\u0377\u037b\u037d\u037f\u037f\u0386\u0386\u0388\u038a\u038c" + + "\u038c\u038e\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0559" + + "\u0559\u0560\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671" + + "\u06d3\u06d5\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u06ff\u06ff\u0710" + + "\u0710\u0712\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa" + + "\u07fa\u0800\u0815\u081a\u081a\u0824\u0824\u0828\u0828\u0840\u0858\u0860" + + "\u086a\u0870\u0887\u0889\u088e\u08a0\u08c9\u0904\u0939\u093d\u093d\u0950" + + "\u0950\u0958\u0961\u0971\u0980\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa" + + "\u09b0\u09b2\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc\u09dd\u09df" + + "\u09e1\u09f0\u09f1\u09fc\u09fc\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a" + + "\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72" + + "\u0a74\u0a85\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5" + + "\u0ab9\u0abd\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f" + + "\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c" + + "\u0b5d\u0b5f\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92" + + "\u0b95\u0b99\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae" + + "\u0bb9\u0bd0\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d" + + "\u0c3d\u0c58\u0c5a\u0c5d\u0c5d\u0c60\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e" + + "\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0" + + "\u0ce1\u0cf1\u0cf2\u0d04\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e" + + "\u0d4e\u0d54\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3" + + "\u0dbb\u0dbd\u0dbd\u0dc0\u0dc6\u0e01\u0e30\u0e32\u0e32\u0e40\u0e46\u0e81" + + "\u0e82\u0e84\u0e84\u0e86\u0e8a\u0e8c\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2" + + "\u0eb2\u0ebd\u0ebd\u0ec0\u0ec4\u0ec6\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40" + + "\u0f47\u0f49\u0f6c\u0f88\u0f8c\u1000\u102a\u103f\u103f\u1050\u1055\u105a" + + "\u105d\u1061\u1061\u1065\u1066\u106e\u1070\u1075\u1081\u108e\u108e\u10a0" + + "\u10c5\u10c7\u10c7\u10cd\u10cd\u10d0\u10fa\u10fc\u1248\u124a\u124d\u1250" + + "\u1256\u1258\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2" + + "\u12b5\u12b8\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312" + + "\u1315\u1318\u135a\u1380\u138f\u13a0\u13f5\u13f8\u13fd\u1401\u166c\u166f" + + "\u167f\u1681\u169a\u16a0\u16ea\u16ee\u16f8\u1700\u1711\u171f\u1731\u1740" + + "\u1751\u1760\u176c\u176e\u1770\u1780\u17b3\u17d7\u17d7\u17dc\u17dc\u1820" + + "\u1878\u1880\u18a8\u18aa\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970" + + "\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05" + + "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d" + + "\u1c4f\u1c5a\u1c7d\u1c80\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee" + + "\u1cf3\u1cf5\u1cf6\u1cfa\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20" + + "\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f" + + "\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0" + + "\u1fd3\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f" + + "\u207f\u2090\u209c\u2102\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2118" + + "\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u2139\u213c\u213f\u2145" + + "\u2149\u214e\u214e\u2160\u2188\u2c00\u2ce4\u2ceb\u2cee\u2cf2\u2cf3\u2d00" + + "\u2d25\u2d27\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80\u2d96\u2da0" + + "\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0" + + "\u2dd6\u2dd8\u2dde\u3005\u3007\u3021\u3029\u3031\u3035\u3038\u303c\u3041" + + "\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131\u318e\u31a0" + + "\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0\u8000\ua4fd" + + "\u8000\ua500\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a\u8000\ua62b" + + "\u8000\ua640\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0\u8000\ua6ef" + + "\u8000\ua717\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b\u8000\ua7ca" + + "\u8000\ua7d0\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5\u8000\ua7d9" + + "\u8000\ua7f2\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807\u8000\ua80a" + + "\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882\u8000\ua8b3" + + "\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd\u8000\ua8fe" + + "\u8000\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960\u8000\ua97c" + + "\u8000\ua984\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0\u8000\ua9e4" + + "\u8000\ua9e6\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00\u8000\uaa28" + + "\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60\u8000\uaa76" + + "\u8000\uaa7a\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1\u8000\uaab1" + + "\u8000\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0\u8000\uaac0" + + "\u8000\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0\u8000\uaaea" + + "\u8000\uaaf2\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09\u8000\uab0e" + + "\u8000\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28\u8000\uab2e" + + "\u8000\uab30\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70\u8000\uabe2" + + "\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb\u8000\ud7fb" + + "\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00\u8000\ufb06" + + "\u8000\ufb13\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f\u8000\ufb28" + + "\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e\u8000\ufb3e" + + "\u8000\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46\u8000\ufbb1" + + "\u8000\ufbd3\u8000\ufc5d\u8000\ufc64\u8000\ufd3d\u8000\ufd50\u8000\ufd8f" + + "\u8000\ufd92\u8000\ufdc7\u8000\ufdf0\u8000\ufdf9\u8000\ufe71\u8000\ufe71" + + "\u8000\ufe73\u8000\ufe73\u8000\ufe77\u8000\ufe77\u8000\ufe79\u8000\ufe79" + + "\u8000\ufe7b\u8000\ufe7b\u8000\ufe7d\u8000\ufe7d\u8000\ufe7f\u8000\ufefc" + + "\u8000\uff21\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66\u8000\uff9d" + + "\u8000\uffa0\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf" + + "\u8000\uffd2\u8000\uffd7\u8000\uffda\u8000\uffdc\u8001\u0000\u8001\u000b" + + "\u8001\r\u8001&\u8001(\u8001:\u8001<\u8001=\u8001?\u8001M\u8001P\u8001" + + "]\u8001\u0080\u8001\u00fa\u8001\u0140\u8001\u0174\u8001\u0280\u8001\u029c" + + "\u8001\u02a0\u8001\u02d0\u8001\u0300\u8001\u031f\u8001\u032d\u8001\u034a" + + "\u8001\u0350\u8001\u0375\u8001\u0380\u8001\u039d\u8001\u03a0\u8001\u03c3" + + "\u8001\u03c8\u8001\u03cf\u8001\u03d1\u8001\u03d5\u8001\u0400\u8001\u049d" + + "\u8001\u04b0\u8001\u04d3\u8001\u04d8\u8001\u04fb\u8001\u0500\u8001\u0527" + + "\u8001\u0530\u8001\u0563\u8001\u0570\u8001\u057a\u8001\u057c\u8001\u058a" + + "\u8001\u058c\u8001\u0592\u8001\u0594\u8001\u0595\u8001\u0597\u8001\u05a1" + + "\u8001\u05a3\u8001\u05b1\u8001\u05b3\u8001\u05b9\u8001\u05bb\u8001\u05bc" + + "\u8001\u0600\u8001\u0736\u8001\u0740\u8001\u0755\u8001\u0760\u8001\u0767" + + "\u8001\u0780\u8001\u0785\u8001\u0787\u8001\u07b0\u8001\u07b2\u8001\u07ba" + + "\u8001\u0800\u8001\u0805\u8001\u0808\u8001\u0808\u8001\u080a\u8001\u0835" + + "\u8001\u0837\u8001\u0838\u8001\u083c\u8001\u083c\u8001\u083f\u8001\u0855" + + "\u8001\u0860\u8001\u0876\u8001\u0880\u8001\u089e\u8001\u08e0\u8001\u08f2" + + "\u8001\u08f4\u8001\u08f5\u8001\u0900\u8001\u0915\u8001\u0920\u8001\u0939" + + "\u8001\u0980\u8001\u09b7\u8001\u09be\u8001\u09bf\u8001\u0a00\u8001\u0a00" + + "\u8001\u0a10\u8001\u0a13\u8001\u0a15\u8001\u0a17\u8001\u0a19\u8001\u0a35" + + "\u8001\u0a60\u8001\u0a7c\u8001\u0a80\u8001\u0a9c\u8001\u0ac0\u8001\u0ac7" + + "\u8001\u0ac9\u8001\u0ae4\u8001\u0b00\u8001\u0b35\u8001\u0b40\u8001\u0b55" + + "\u8001\u0b60\u8001\u0b72\u8001\u0b80\u8001\u0b91\u8001\u0c00\u8001\u0c48" + + "\u8001\u0c80\u8001\u0cb2\u8001\u0cc0\u8001\u0cf2\u8001\u0d00\u8001\u0d23" + + "\u8001\u0e80\u8001\u0ea9\u8001\u0eb0\u8001\u0eb1\u8001\u0f00\u8001\u0f1c" + + "\u8001\u0f27\u8001\u0f27\u8001\u0f30\u8001\u0f45\u8001\u0f70\u8001\u0f81" + + "\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0\u8001\u0ff6\u8001\u1003\u8001\u1037" + + "\u8001\u1071\u8001\u1072\u8001\u1075\u8001\u1075\u8001\u1083\u8001\u10af" + + "\u8001\u10d0\u8001\u10e8\u8001\u1103\u8001\u1126\u8001\u1144\u8001\u1144" + + "\u8001\u1147\u8001\u1147\u8001\u1150\u8001\u1172\u8001\u1176\u8001\u1176" + + "\u8001\u1183\u8001\u11b2\u8001\u11c1\u8001\u11c4\u8001\u11da\u8001\u11da" + + "\u8001\u11dc\u8001\u11dc\u8001\u1200\u8001\u1211\u8001\u1213\u8001\u122b" + + "\u8001\u123f\u8001\u1240\u8001\u1280\u8001\u1286\u8001\u1288\u8001\u1288" + + "\u8001\u128a\u8001\u128d\u8001\u128f\u8001\u129d\u8001\u129f\u8001\u12a8" + + "\u8001\u12b0\u8001\u12de\u8001\u1305\u8001\u130c\u8001\u130f\u8001\u1310" + + "\u8001\u1313\u8001\u1328\u8001\u132a\u8001\u1330\u8001\u1332\u8001\u1333" + + "\u8001\u1335\u8001\u1339\u8001\u133d\u8001\u133d\u8001\u1350\u8001\u1350" + + "\u8001\u135d\u8001\u1361\u8001\u1400\u8001\u1434\u8001\u1447\u8001\u144a" + + "\u8001\u145f\u8001\u1461\u8001\u1480\u8001\u14af\u8001\u14c4\u8001\u14c5" + + "\u8001\u14c7\u8001\u14c7\u8001\u1580\u8001\u15ae\u8001\u15d8\u8001\u15db" + + "\u8001\u1600\u8001\u162f\u8001\u1644\u8001\u1644\u8001\u1680\u8001\u16aa" + + "\u8001\u16b8\u8001\u16b8\u8001\u1700\u8001\u171a\u8001\u1740\u8001\u1746" + + "\u8001\u1800\u8001\u182b\u8001\u18a0\u8001\u18df\u8001\u18ff\u8001\u1906" + + "\u8001\u1909\u8001\u1909\u8001\u190c\u8001\u1913\u8001\u1915\u8001\u1916" + + "\u8001\u1918\u8001\u192f\u8001\u193f\u8001\u193f\u8001\u1941\u8001\u1941" + + "\u8001\u19a0\u8001\u19a7\u8001\u19aa\u8001\u19d0\u8001\u19e1\u8001\u19e1" + + "\u8001\u19e3\u8001\u19e3\u8001\u1a00\u8001\u1a00\u8001\u1a0b\u8001\u1a32" + + "\u8001\u1a3a\u8001\u1a3a\u8001\u1a50\u8001\u1a50\u8001\u1a5c\u8001\u1a89" + + "\u8001\u1a9d\u8001\u1a9d\u8001\u1ab0\u8001\u1af8\u8001\u1c00\u8001\u1c08" + + "\u8001\u1c0a\u8001\u1c2e\u8001\u1c40\u8001\u1c40\u8001\u1c72\u8001\u1c8f" + + "\u8001\u1d00\u8001\u1d06\u8001\u1d08\u8001\u1d09\u8001\u1d0b\u8001\u1d30" + + "\u8001\u1d46\u8001\u1d46\u8001\u1d60\u8001\u1d65\u8001\u1d67\u8001\u1d68" + + "\u8001\u1d6a\u8001\u1d89\u8001\u1d98\u8001\u1d98\u8001\u1ee0\u8001\u1ef2" + + "\u8001\u1f02\u8001\u1f02\u8001\u1f04\u8001\u1f10\u8001\u1f12\u8001\u1f33" + + "\u8001\u1fb0\u8001\u1fb0\u8001\u2000\u8001\u2399\u8001\u2400\u8001\u246e" + + "\u8001\u2480\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000\u8001\u342f" + + "\u8001\u3441\u8001\u3446\u8001\u4400\u8001\u4646\u8001\u6800\u8001\u6a38" + + "\u8001\u6a40\u8001\u6a5e\u8001\u6a70\u8001\u6abe\u8001\u6ad0\u8001\u6aed" + + "\u8001\u6b00\u8001\u6b2f\u8001\u6b40\u8001\u6b43\u8001\u6b63\u8001\u6b77" + + "\u8001\u6b7d\u8001\u6b8f\u8001\u6e40\u8001\u6e7f\u8001\u6f00\u8001\u6f4a" + + "\u8001\u6f50\u8001\u6f50\u8001\u6f93\u8001\u6f9f\u8001\u6fe0\u8001\u6fe1" + + "\u8001\u6fe3\u8001\u6fe3\u8001\u7000\u8001\u87f7\u8001\u8800\u8001\u8cd5" + + "\u8001\u8d00\u8001\u8d08\u8001\uaff0\u8001\uaff3\u8001\uaff5\u8001\uaffb" + + "\u8001\uaffd\u8001\uaffe\u8001\ub000\u8001\ub122\u8001\ub132\u8001\ub132" + + "\u8001\ub150\u8001\ub152\u8001\ub155\u8001\ub155\u8001\ub164\u8001\ub167" + + "\u8001\ub170\u8001\ub2fb\u8001\ubc00\u8001\ubc6a\u8001\ubc70\u8001\ubc7c" + + "\u8001\ubc80\u8001\ubc88\u8001\ubc90\u8001\ubc99\u8001\ud400\u8001\ud454" + + "\u8001\ud456\u8001\ud49c\u8001\ud49e\u8001\ud49f\u8001\ud4a2\u8001\ud4a2" + + "\u8001\ud4a5\u8001\ud4a6\u8001\ud4a9\u8001\ud4ac\u8001\ud4ae\u8001\ud4b9" + + "\u8001\ud4bb\u8001\ud4bb\u8001\ud4bd\u8001\ud4c3\u8001\ud4c5\u8001\ud505" + + "\u8001\ud507\u8001\ud50a\u8001\ud50d\u8001\ud514\u8001\ud516\u8001\ud51c" + + "\u8001\ud51e\u8001\ud539\u8001\ud53b\u8001\ud53e\u8001\ud540\u8001\ud544" + + "\u8001\ud546\u8001\ud546\u8001\ud54a\u8001\ud550\u8001\ud552\u8001\ud6a5" + + "\u8001\ud6a8\u8001\ud6c0\u8001\ud6c2\u8001\ud6da\u8001\ud6dc\u8001\ud6fa" + + "\u8001\ud6fc\u8001\ud714\u8001\ud716\u8001\ud734\u8001\ud736\u8001\ud74e" + + "\u8001\ud750\u8001\ud76e\u8001\ud770\u8001\ud788\u8001\ud78a\u8001\ud7a8" + + "\u8001\ud7aa\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00\u8001\udf1e" + + "\u8001\udf25\u8001\udf2a\u8001\ue030\u8001\ue06d\u8001\ue100\u8001\ue12c" + + "\u8001\ue137\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290\u8001\ue2ad" + + "\u8001\ue2c0\u8001\ue2eb\u8001\ue4d0\u8001\ue4eb\u8001\ue7e0\u8001\ue7e6" + + "\u8001\ue7e8\u8001\ue7eb\u8001\ue7ed\u8001\ue7ee\u8001\ue7f0\u8001\ue7fe" + + "\u8001\ue800\u8001\ue8c4\u8001\ue900\u8001\ue943\u8001\ue94b\u8001\ue94b" + + "\u8001\uee00\u8001\uee03\u8001\uee05\u8001\uee1f\u8001\uee21\u8001\uee22" + + "\u8001\uee24\u8001\uee24\u8001\uee27\u8001\uee27\u8001\uee29\u8001\uee32" + + "\u8001\uee34\u8001\uee37\u8001\uee39\u8001\uee39\u8001\uee3b\u8001\uee3b" + + "\u8001\uee42\u8001\uee42\u8001\uee47\u8001\uee47\u8001\uee49\u8001\uee49" + + "\u8001\uee4b\u8001\uee4b\u8001\uee4d\u8001\uee4f\u8001\uee51\u8001\uee52" + + "\u8001\uee54\u8001\uee54\u8001\uee57\u8001\uee57\u8001\uee59\u8001\uee59" + + "\u8001\uee5b\u8001\uee5b\u8001\uee5d\u8001\uee5d\u8001\uee5f\u8001\uee5f" + + "\u8001\uee61\u8001\uee62\u8001\uee64\u8001\uee64\u8001\uee67\u8001\uee6a" + + "\u8001\uee6c\u8001\uee72\u8001\uee74\u8001\uee77\u8001\uee79\u8001\uee7c" + + "\u8001\uee7e\u8001\uee7e\u8001\uee80\u8001\uee89\u8001\uee8b\u8001\uee9b" + + "\u8001\ueea1\u8001\ueea3\u8001\ueea5\u8001\ueea9\u8001\ueeab\u8001\ueebb" + + "\u8002\u0000\u8002\ua6df\u8002\ua700\u8002\ub739\u8002\ub740\u8002\ub81d" + + "\u8002\ub820\u8002\ucea1\u8002\uceb0\u8002\uebe0\u8002\uf800\u8002\ufa1d" + + "\u8003\u0000\u8003\u134a\u8003\u1350\u8003\u23af\u0492\u0000\u0007\u0001" + + "\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000" + + "\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000" + + "\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000" + + "\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000" + + "\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000" + + "\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000" + + "\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000" + + "%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001" + + "\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000" + + "\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u0000" + + "3\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001" + + "\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000" + + "\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000" + + "A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001" + + "\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000" + + "\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000" + + "O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001" + + "\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000" + + "\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000" + + "]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001" + + "\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000" + + "\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000" + + "k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001" + + "\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000" + + "\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000" + + "y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001" + + "\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001" + + "\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001" + + "\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001" + + "\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001" + + "\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001" + + "\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001" + + "\u0000\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001" + + "\u0000\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001" + + "\u0000\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001" + + "\u0000\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001" + + "\u0000\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001" + + "\u0000\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001" + + "\u0000\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001" + + "\u0000\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001" + + "\u0000\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001" + + "\u0000\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001" + + "\u0000\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001" + + "\u0000\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0001\u00c5\u0001" + + "\u0000\u0000\u0000\u0001\u00c7\u0001\u0000\u0000\u0000\u0001\u00c9\u0001" + + "\u0000\u0000\u0000\u0002\u00cb\u0001\u0000\u0000\u0000\u0002\u00cd\u0001" + + "\u0000\u0000\u0000\u0002\u00cf\u0001\u0000\u0000\u0000\u0003\u00d1\u0001" + + "\u0000\u0000\u0000\u0003\u00d3\u0001\u0000\u0000\u0000\u0003\u00d5\u0001" + + "\u0000\u0000\u0000\u0004\u00d7\u0001\u0000\u0000\u0000\u0004\u00d9\u0001" + + "\u0000\u0000\u0000\u0004\u00db\u0001\u0000\u0000\u0000\u0005\u00dd\u0001" + + "\u0000\u0000\u0000\u0005\u00df\u0001\u0000\u0000\u0000\u0005\u00e1\u0001" + + "\u0000\u0000\u0000\u0006\u00e3\u0001\u0000\u0000\u0000\u0006\u00e5\u0001" + + "\u0000\u0000\u0000\u0006\u00e7\u0001\u0000\u0000\u0000\u0007\u0149\u0001" + + "\u0000\u0000\u0000\t\u014f\u0001\u0000\u0000\u0000\u000b\u0155\u0001\u0000" + + "\u0000\u0000\r\u015a\u0001\u0000\u0000\u0000\u000f\u0161\u0001\u0000\u0000" + + "\u0000\u0011\u0166\u0001\u0000\u0000\u0000\u0013\u016b\u0001\u0000\u0000" + + "\u0000\u0015\u0171\u0001\u0000\u0000\u0000\u0017\u0178\u0001\u0000\u0000" + + "\u0000\u0019\u017b\u0001\u0000\u0000\u0000\u001b\u0181\u0001\u0000\u0000" + + "\u0000\u001d\u0186\u0001\u0000\u0000\u0000\u001f\u018c\u0001\u0000\u0000" + + "\u0000!\u0194\u0001\u0000\u0000\u0000#\u0197\u0001\u0000\u0000\u0000%" + + "\u019e\u0001\u0000\u0000\u0000\'\u01a2\u0001\u0000\u0000\u0000)\u01ab" + + "\u0001\u0000\u0000\u0000+\u01af\u0001\u0000\u0000\u0000-\u01b6\u0001\u0000" + + "\u0000\u0000/\u01ba\u0001\u0000\u0000\u00001\u01bd\u0001\u0000\u0000\u0000" + + "3\u01c1\u0001\u0000\u0000\u00005\u01c6\u0001\u0000\u0000\u00007\u01cf" + + "\u0001\u0000\u0000\u00009\u01d5\u0001\u0000\u0000\u0000;\u01dc\u0001\u0000" + + "\u0000\u0000=\u01e0\u0001\u0000\u0000\u0000?\u01e7\u0001\u0000\u0000\u0000" + + "A\u01eb\u0001\u0000\u0000\u0000C\u01f0\u0001\u0000\u0000\u0000E\u01f6" + + "\u0001\u0000\u0000\u0000G\u01fb\u0001\u0000\u0000\u0000I\u01fe\u0001\u0000" + + "\u0000\u0000K\u0201\u0001\u0000\u0000\u0000M\u0207\u0001\u0000\u0000\u0000" + + "O\u0209\u0001\u0000\u0000\u0000Q\u020b\u0001\u0000\u0000\u0000S\u020d" + + "\u0001\u0000\u0000\u0000U\u020f\u0001\u0000\u0000\u0000W\u0211\u0001\u0000" + + "\u0000\u0000Y\u0213\u0001\u0000\u0000\u0000[\u0215\u0001\u0000\u0000\u0000" + + "]\u0217\u0001\u0000\u0000\u0000_\u0219\u0001\u0000\u0000\u0000a\u021b" + + "\u0001\u0000\u0000\u0000c\u021d\u0001\u0000\u0000\u0000e\u021f\u0001\u0000" + + "\u0000\u0000g\u0221\u0001\u0000\u0000\u0000i\u0223\u0001\u0000\u0000\u0000" + + "k\u0225\u0001\u0000\u0000\u0000m\u0227\u0001\u0000\u0000\u0000o\u0229" + + "\u0001\u0000\u0000\u0000q\u022b\u0001\u0000\u0000\u0000s\u022d\u0001\u0000" + + "\u0000\u0000u\u022f\u0001\u0000\u0000\u0000w\u0232\u0001\u0000\u0000\u0000" + + "y\u0235\u0001\u0000\u0000\u0000{\u0238\u0001\u0000\u0000\u0000}\u023b" + + "\u0001\u0000\u0000\u0000\u007f\u023d\u0001\u0000\u0000\u0000\u0081\u023f" + + "\u0001\u0000\u0000\u0000\u0083\u0242\u0001\u0000\u0000\u0000\u0085\u0245" + + "\u0001\u0000\u0000\u0000\u0087\u0248\u0001\u0000\u0000\u0000\u0089\u024b" + + "\u0001\u0000\u0000\u0000\u008b\u024e\u0001\u0000\u0000\u0000\u008d\u0251" + + "\u0001\u0000\u0000\u0000\u008f\u0254\u0001\u0000\u0000\u0000\u0091\u0257" + + "\u0001\u0000\u0000\u0000\u0093\u025a\u0001\u0000\u0000\u0000\u0095\u025d" + + "\u0001\u0000\u0000\u0000\u0097\u0260\u0001\u0000\u0000\u0000\u0099\u0264" + + "\u0001\u0000\u0000\u0000\u009b\u0268\u0001\u0000\u0000\u0000\u009d\u026c" + + "\u0001\u0000\u0000\u0000\u009f\u026f\u0001\u0000\u0000\u0000\u00a1\u0273" + + "\u0001\u0000\u0000\u0000\u00a3\u0275\u0001\u0000\u0000\u0000\u00a5\u0278" + + "\u0001\u0000\u0000\u0000\u00a7\u027b\u0001\u0000\u0000\u0000\u00a9\u027f" + + "\u0001\u0000\u0000\u0000\u00ab\u0282\u0001\u0000\u0000\u0000\u00ad\u0284" + + "\u0001\u0000\u0000\u0000\u00af\u028e\u0001\u0000\u0000\u0000\u00b1\u0292" + + "\u0001\u0000\u0000\u0000\u00b3\u0295\u0001\u0000\u0000\u0000\u00b5\u0299" + + "\u0001\u0000\u0000\u0000\u00b7\u02a3\u0001\u0000\u0000\u0000\u00b9\u02a9" + + "\u0001\u0000\u0000\u0000\u00bb\u02ae\u0001\u0000\u0000\u0000\u00bd\u02b4" + + "\u0001\u0000\u0000\u0000\u00bf\u02ba\u0001\u0000\u0000\u0000\u00c1\u02c2" + + "\u0001\u0000\u0000\u0000\u00c3\u02ca\u0001\u0000\u0000\u0000\u00c5\u02cc" + + "\u0001\u0000\u0000\u0000\u00c7\u02d1\u0001\u0000\u0000\u0000\u00c9\u02d5" + + "\u0001\u0000\u0000\u0000\u00cb\u02d9\u0001\u0000\u0000\u0000\u00cd\u02de" + + "\u0001\u0000\u0000\u0000\u00cf\u02e2\u0001\u0000\u0000\u0000\u00d1\u02e6" + + "\u0001\u0000\u0000\u0000\u00d3\u02ed\u0001\u0000\u0000\u0000\u00d5\u02f1" + + "\u0001\u0000\u0000\u0000\u00d7\u02f5\u0001\u0000\u0000\u0000\u00d9\u02fc" + + "\u0001\u0000\u0000\u0000\u00db\u0300\u0001\u0000\u0000\u0000\u00dd\u0305" + + "\u0001\u0000\u0000\u0000\u00df\u030b\u0001\u0000\u0000\u0000\u00e1\u030f" + + "\u0001\u0000\u0000\u0000\u00e3\u0314\u0001\u0000\u0000\u0000\u00e5\u031a" + + "\u0001\u0000\u0000\u0000\u00e7\u031e\u0001\u0000\u0000\u0000\u00e9\u0322" + + "\u0001\u0000\u0000\u0000\u00eb\u032a\u0001\u0000\u0000\u0000\u00ed\u0330" + + "\u0001\u0000\u0000\u0000\u00ef\u0342\u0001\u0000\u0000\u0000\u00f1\u035e" + + "\u0001\u0000\u0000\u0000\u00f3\u0362\u0001\u0000\u0000\u0000\u00f5\u0366" + + "\u0001\u0000\u0000\u0000\u00f7\u036a\u0001\u0000\u0000\u0000\u00f9\u036c" + + "\u0001\u0000\u0000\u0000\u00fb\u036e\u0001\u0000\u0000\u0000\u00fd\u0370" + + "\u0001\u0000\u0000\u0000\u00ff\u0377\u0001\u0000\u0000\u0000\u0101\u0379" + + "\u0001\u0000\u0000\u0000\u0103\u038f\u0001\u0000\u0000\u0000\u0105\u03a1" + + "\u0001\u0000\u0000\u0000\u0107\u03bd\u0001\u0000\u0000\u0000\u0109\u03c1" + + "\u0001\u0000\u0000\u0000\u010b\u03c5\u0001\u0000\u0000\u0000\u010d\u03c9" + + "\u0001\u0000\u0000\u0000\u010f\u03cc\u0001\u0000\u0000\u0000\u0111\u03cf" + + "\u0001\u0000\u0000\u0000\u0113\u03d2\u0001\u0000\u0000\u0000\u0115\u03d4" + + "\u0001\u0000\u0000\u0000\u0117\u03d9\u0001\u0000\u0000\u0000\u0119\u03df" + + "\u0001\u0000\u0000\u0000\u011b\u03f4\u0001\u0000\u0000\u0000\u011d\u03f6" + + "\u0001\u0000\u0000\u0000\u011f\u03f8\u0001\u0000\u0000\u0000\u0121\u03fe" + + "\u0001\u0000\u0000\u0000\u0123\u0404\u0001\u0000\u0000\u0000\u0125\u041e" + + "\u0001\u0000\u0000\u0000\u0127\u0420\u0001\u0000\u0000\u0000\u0129\u042a" + + "\u0001\u0000\u0000\u0000\u012b\u0434\u0001\u0000\u0000\u0000\u012d\u043e" + + "\u0001\u0000\u0000\u0000\u012f\u0440\u0001\u0000\u0000\u0000\u0131\u0442" + + "\u0001\u0000\u0000\u0000\u0133\u0444\u0001\u0000\u0000\u0000\u0135\u0448" + + "\u0001\u0000\u0000\u0000\u0137\u044c\u0001\u0000\u0000\u0000\u0139\u0455" + + "\u0001\u0000\u0000\u0000\u013b\u0459\u0001\u0000\u0000\u0000\u013d\u045d" + + "\u0001\u0000\u0000\u0000\u013f\u0467\u0001\u0000\u0000\u0000\u0141\u046a" + + "\u0001\u0000\u0000\u0000\u0143\u0472\u0001\u0000\u0000\u0000\u0145\u0478" + + "\u0001\u0000\u0000\u0000\u0147\u047a\u0001\u0000\u0000\u0000\u0149\u014a" + + "\u0005F\u0000\u0000\u014a\u014b\u0005a\u0000\u0000\u014b\u014c\u0005l" + + "\u0000\u0000\u014c\u014d\u0005s\u0000\u0000\u014d\u014e\u0005e\u0000\u0000" + + "\u014e\b\u0001\u0000\u0000\u0000\u014f\u0150\u0005a\u0000\u0000\u0150" + + "\u0151\u0005w\u0000\u0000\u0151\u0152\u0005a\u0000\u0000\u0152\u0153\u0005" + + "i\u0000\u0000\u0153\u0154\u0005t\u0000\u0000\u0154\n\u0001\u0000\u0000" + + "\u0000\u0155\u0156\u0005e\u0000\u0000\u0156\u0157\u0005l\u0000\u0000\u0157" + + "\u0158\u0005s\u0000\u0000\u0158\u0159\u0005e\u0000\u0000\u0159\f\u0001" + + "\u0000\u0000\u0000\u015a\u015b\u0005i\u0000\u0000\u015b\u015c\u0005m\u0000" + + "\u0000\u015c\u015d\u0005p\u0000\u0000\u015d\u015e\u0005o\u0000\u0000\u015e" + + "\u015f\u0005r\u0000\u0000\u015f\u0160\u0005t\u0000\u0000\u0160\u000e\u0001" + + "\u0000\u0000\u0000\u0161\u0162\u0005p\u0000\u0000\u0162\u0163\u0005a\u0000" + + "\u0000\u0163\u0164\u0005s\u0000\u0000\u0164\u0165\u0005s\u0000\u0000\u0165" + + "\u0010\u0001\u0000\u0000\u0000\u0166\u0167\u0005N\u0000\u0000\u0167\u0168" + + "\u0005o\u0000\u0000\u0168\u0169\u0005n\u0000\u0000\u0169\u016a\u0005e" + + "\u0000\u0000\u016a\u0012\u0001\u0000\u0000\u0000\u016b\u016c\u0005b\u0000" + + "\u0000\u016c\u016d\u0005r\u0000\u0000\u016d\u016e\u0005e\u0000\u0000\u016e" + + "\u016f\u0005a\u0000\u0000\u016f\u0170\u0005k\u0000\u0000\u0170\u0014\u0001" + + "\u0000\u0000\u0000\u0171\u0172\u0005e\u0000\u0000\u0172\u0173\u0005x\u0000" + + "\u0000\u0173\u0174\u0005c\u0000\u0000\u0174\u0175\u0005e\u0000\u0000\u0175" + + "\u0176\u0005p\u0000\u0000\u0176\u0177\u0005t\u0000\u0000\u0177\u0016\u0001" + + "\u0000\u0000\u0000\u0178\u0179\u0005i\u0000\u0000\u0179\u017a\u0005n\u0000" + + "\u0000\u017a\u0018\u0001\u0000\u0000\u0000\u017b\u017c\u0005r\u0000\u0000" + + "\u017c\u017d\u0005a\u0000\u0000\u017d\u017e\u0005i\u0000\u0000\u017e\u017f" + + "\u0005s\u0000\u0000\u017f\u0180\u0005e\u0000\u0000\u0180\u001a\u0001\u0000" + + "\u0000\u0000\u0181\u0182\u0005T\u0000\u0000\u0182\u0183\u0005r\u0000\u0000" + + "\u0183\u0184\u0005u\u0000\u0000\u0184\u0185\u0005e\u0000\u0000\u0185\u001c" + + "\u0001\u0000\u0000\u0000\u0186\u0187\u0005c\u0000\u0000\u0187\u0188\u0005" + + "l\u0000\u0000\u0188\u0189\u0005a\u0000\u0000\u0189\u018a\u0005s\u0000" + + "\u0000\u018a\u018b\u0005s\u0000\u0000\u018b\u001e\u0001\u0000\u0000\u0000" + + "\u018c\u018d\u0005f\u0000\u0000\u018d\u018e\u0005i\u0000\u0000\u018e\u018f" + + "\u0005n\u0000\u0000\u018f\u0190\u0005a\u0000\u0000\u0190\u0191\u0005l" + + "\u0000\u0000\u0191\u0192\u0005l\u0000\u0000\u0192\u0193\u0005y\u0000\u0000" + + "\u0193 \u0001\u0000\u0000\u0000\u0194\u0195\u0005i\u0000\u0000\u0195\u0196" + + "\u0005s\u0000\u0000\u0196\"\u0001\u0000\u0000\u0000\u0197\u0198\u0005" + + "r\u0000\u0000\u0198\u0199\u0005e\u0000\u0000\u0199\u019a\u0005t\u0000" + + "\u0000\u019a\u019b\u0005u\u0000\u0000\u019b\u019c\u0005r\u0000\u0000\u019c" + + "\u019d\u0005n\u0000\u0000\u019d$\u0001\u0000\u0000\u0000\u019e\u019f\u0005" + + "a\u0000\u0000\u019f\u01a0\u0005n\u0000\u0000\u01a0\u01a1\u0005d\u0000" + + "\u0000\u01a1&\u0001\u0000\u0000\u0000\u01a2\u01a3\u0005c\u0000\u0000\u01a3" + + "\u01a4\u0005o\u0000\u0000\u01a4\u01a5\u0005n\u0000\u0000\u01a5\u01a6\u0005" + + "t\u0000\u0000\u01a6\u01a7\u0005i\u0000\u0000\u01a7\u01a8\u0005n\u0000" + + "\u0000\u01a8\u01a9\u0005u\u0000\u0000\u01a9\u01aa\u0005e\u0000\u0000\u01aa" + + "(\u0001\u0000\u0000\u0000\u01ab\u01ac\u0005f\u0000\u0000\u01ac\u01ad\u0005" + + "o\u0000\u0000\u01ad\u01ae\u0005r\u0000\u0000\u01ae*\u0001\u0000\u0000" + + "\u0000\u01af\u01b0\u0005l\u0000\u0000\u01b0\u01b1\u0005a\u0000\u0000\u01b1" + + "\u01b2\u0005m\u0000\u0000\u01b2\u01b3\u0005b\u0000\u0000\u01b3\u01b4\u0005" + + "d\u0000\u0000\u01b4\u01b5\u0005a\u0000\u0000\u01b5,\u0001\u0000\u0000" + + "\u0000\u01b6\u01b7\u0005t\u0000\u0000\u01b7\u01b8\u0005r\u0000\u0000\u01b8" + + "\u01b9\u0005y\u0000\u0000\u01b9.\u0001\u0000\u0000\u0000\u01ba\u01bb\u0005" + + "a\u0000\u0000\u01bb\u01bc\u0005s\u0000\u0000\u01bc0\u0001\u0000\u0000" + + "\u0000\u01bd\u01be\u0005d\u0000\u0000\u01be\u01bf\u0005e\u0000\u0000\u01bf" + + "\u01c0\u0005f\u0000\u0000\u01c02\u0001\u0000\u0000\u0000\u01c1\u01c2\u0005" + + "f\u0000\u0000\u01c2\u01c3\u0005r\u0000\u0000\u01c3\u01c4\u0005o\u0000" + + "\u0000\u01c4\u01c5\u0005m\u0000\u0000\u01c54\u0001\u0000\u0000\u0000\u01c6" + + "\u01c7\u0005n\u0000\u0000\u01c7\u01c8\u0005o\u0000\u0000\u01c8\u01c9\u0005" + + "n\u0000\u0000\u01c9\u01ca\u0005l\u0000\u0000\u01ca\u01cb\u0005o\u0000" + + "\u0000\u01cb\u01cc\u0005c\u0000\u0000\u01cc\u01cd\u0005a\u0000\u0000\u01cd" + + "\u01ce\u0005l\u0000\u0000\u01ce6\u0001\u0000\u0000\u0000\u01cf\u01d0\u0005" + + "w\u0000\u0000\u01d0\u01d1\u0005h\u0000\u0000\u01d1\u01d2\u0005i\u0000" + + "\u0000\u01d2\u01d3\u0005l\u0000\u0000\u01d3\u01d4\u0005e\u0000\u0000\u01d4" + + "8\u0001\u0000\u0000\u0000\u01d5\u01d6\u0005a\u0000\u0000\u01d6\u01d7\u0005" + + "s\u0000\u0000\u01d7\u01d8\u0005s\u0000\u0000\u01d8\u01d9\u0005e\u0000" + + "\u0000\u01d9\u01da\u0005r\u0000\u0000\u01da\u01db\u0005t\u0000\u0000\u01db" + + ":\u0001\u0000\u0000\u0000\u01dc\u01dd\u0005d\u0000\u0000\u01dd\u01de\u0005" + + "e\u0000\u0000\u01de\u01df\u0005l\u0000\u0000\u01df<\u0001\u0000\u0000" + + "\u0000\u01e0\u01e1\u0005g\u0000\u0000\u01e1\u01e2\u0005l\u0000\u0000\u01e2" + + "\u01e3\u0005o\u0000\u0000\u01e3\u01e4\u0005b\u0000\u0000\u01e4\u01e5\u0005" + + "a\u0000\u0000\u01e5\u01e6\u0005l\u0000\u0000\u01e6>\u0001\u0000\u0000" + + "\u0000\u01e7\u01e8\u0005n\u0000\u0000\u01e8\u01e9\u0005o\u0000\u0000\u01e9" + + "\u01ea\u0005t\u0000\u0000\u01ea@\u0001\u0000\u0000\u0000\u01eb\u01ec\u0005" + + "w\u0000\u0000\u01ec\u01ed\u0005i\u0000\u0000\u01ed\u01ee\u0005t\u0000" + + "\u0000\u01ee\u01ef\u0005h\u0000\u0000\u01efB\u0001\u0000\u0000\u0000\u01f0" + + "\u01f1\u0005a\u0000\u0000\u01f1\u01f2\u0005s\u0000\u0000\u01f2\u01f3\u0005" + + "y\u0000\u0000\u01f3\u01f4\u0005n\u0000\u0000\u01f4\u01f5\u0005c\u0000" + + "\u0000\u01f5D\u0001\u0000\u0000\u0000\u01f6\u01f7\u0005e\u0000\u0000\u01f7" + + "\u01f8\u0005l\u0000\u0000\u01f8\u01f9\u0005i\u0000\u0000\u01f9\u01fa\u0005" + + "f\u0000\u0000\u01faF\u0001\u0000\u0000\u0000\u01fb\u01fc\u0005i\u0000" + + "\u0000\u01fc\u01fd\u0005f\u0000\u0000\u01fdH\u0001\u0000\u0000\u0000\u01fe" + + "\u01ff\u0005o\u0000\u0000\u01ff\u0200\u0005r\u0000\u0000\u0200J\u0001" + + "\u0000\u0000\u0000\u0201\u0202\u0005y\u0000\u0000\u0202\u0203\u0005i\u0000" + + "\u0000\u0203\u0204\u0005e\u0000\u0000\u0204\u0205\u0005l\u0000\u0000\u0205" + + "\u0206\u0005d\u0000\u0000\u0206L\u0001\u0000\u0000\u0000\u0207\u0208\u0005" + + "(\u0000\u0000\u0208N\u0001\u0000\u0000\u0000\u0209\u020a\u0005[\u0000" + + "\u0000\u020aP\u0001\u0000\u0000\u0000\u020b\u020c\u0005{\u0000\u0000\u020c" + + "R\u0001\u0000\u0000\u0000\u020d\u020e\u0005)\u0000\u0000\u020eT\u0001" + + "\u0000\u0000\u0000\u020f\u0210\u0005]\u0000\u0000\u0210V\u0001\u0000\u0000" + + "\u0000\u0211\u0212\u0005}\u0000\u0000\u0212X\u0001\u0000\u0000\u0000\u0213" + + "\u0214\u0005.\u0000\u0000\u0214Z\u0001\u0000\u0000\u0000\u0215\u0216\u0005" + + ":\u0000\u0000\u0216\\\u0001\u0000\u0000\u0000\u0217\u0218\u0005,\u0000" + + "\u0000\u0218^\u0001\u0000\u0000\u0000\u0219\u021a\u0005;\u0000\u0000\u021a" + + "`\u0001\u0000\u0000\u0000\u021b\u021c\u0005+\u0000\u0000\u021cb\u0001" + + "\u0000\u0000\u0000\u021d\u021e\u0005-\u0000\u0000\u021ed\u0001\u0000\u0000" + + "\u0000\u021f\u0220\u0005*\u0000\u0000\u0220f\u0001\u0000\u0000\u0000\u0221" + + "\u0222\u0005/\u0000\u0000\u0222h\u0001\u0000\u0000\u0000\u0223\u0224\u0005" + + "|\u0000\u0000\u0224j\u0001\u0000\u0000\u0000\u0225\u0226\u0005&\u0000" + + "\u0000\u0226l\u0001\u0000\u0000\u0000\u0227\u0228\u0005<\u0000\u0000\u0228" + + "n\u0001\u0000\u0000\u0000\u0229\u022a\u0005>\u0000\u0000\u022ap\u0001" + + "\u0000\u0000\u0000\u022b\u022c\u0005=\u0000\u0000\u022cr\u0001\u0000\u0000" + + "\u0000\u022d\u022e\u0005%\u0000\u0000\u022et\u0001\u0000\u0000\u0000\u022f" + + "\u0230\u0005=\u0000\u0000\u0230\u0231\u0005=\u0000\u0000\u0231v\u0001" + + "\u0000\u0000\u0000\u0232\u0233\u0005!\u0000\u0000\u0233\u0234\u0005=\u0000" + + "\u0000\u0234x\u0001\u0000\u0000\u0000\u0235\u0236\u0005<\u0000\u0000\u0236" + + "\u0237\u0005=\u0000\u0000\u0237z\u0001\u0000\u0000\u0000\u0238\u0239\u0005" + + ">\u0000\u0000\u0239\u023a\u0005=\u0000\u0000\u023a|\u0001\u0000\u0000" + + "\u0000\u023b\u023c\u0005~\u0000\u0000\u023c~\u0001\u0000\u0000\u0000\u023d" + + "\u023e\u0005^\u0000\u0000\u023e\u0080\u0001\u0000\u0000\u0000\u023f\u0240" + + "\u0005<\u0000\u0000\u0240\u0241\u0005<\u0000\u0000\u0241\u0082\u0001\u0000" + + "\u0000\u0000\u0242\u0243\u0005>\u0000\u0000\u0243\u0244\u0005>\u0000\u0000" + + "\u0244\u0084\u0001\u0000\u0000\u0000\u0245\u0246\u0005*\u0000\u0000\u0246" + + "\u0247\u0005*\u0000\u0000\u0247\u0086\u0001\u0000\u0000\u0000\u0248\u0249" + + "\u0005+\u0000\u0000\u0249\u024a\u0005=\u0000\u0000\u024a\u0088\u0001\u0000" + + "\u0000\u0000\u024b\u024c\u0005-\u0000\u0000\u024c\u024d\u0005=\u0000\u0000" + + "\u024d\u008a\u0001\u0000\u0000\u0000\u024e\u024f\u0005*\u0000\u0000\u024f" + + "\u0250\u0005=\u0000\u0000\u0250\u008c\u0001\u0000\u0000\u0000\u0251\u0252" + + "\u0005/\u0000\u0000\u0252\u0253\u0005=\u0000\u0000\u0253\u008e\u0001\u0000" + + "\u0000\u0000\u0254\u0255\u0005%\u0000\u0000\u0255\u0256\u0005=\u0000\u0000" + + "\u0256\u0090\u0001\u0000\u0000\u0000\u0257\u0258\u0005&\u0000\u0000\u0258" + + "\u0259\u0005=\u0000\u0000\u0259\u0092\u0001\u0000\u0000\u0000\u025a\u025b" + + "\u0005|\u0000\u0000\u025b\u025c\u0005=\u0000\u0000\u025c\u0094\u0001\u0000" + + "\u0000\u0000\u025d\u025e\u0005^\u0000\u0000\u025e\u025f\u0005=\u0000\u0000" + + "\u025f\u0096\u0001\u0000\u0000\u0000\u0260\u0261\u0005<\u0000\u0000\u0261" + + "\u0262\u0005<\u0000\u0000\u0262\u0263\u0005=\u0000\u0000\u0263\u0098\u0001" + + "\u0000\u0000\u0000\u0264\u0265\u0005>\u0000\u0000\u0265\u0266\u0005>\u0000" + + "\u0000\u0266\u0267\u0005=\u0000\u0000\u0267\u009a\u0001\u0000\u0000\u0000" + + "\u0268\u0269\u0005*\u0000\u0000\u0269\u026a\u0005*\u0000\u0000\u026a\u026b" + + "\u0005=\u0000\u0000\u026b\u009c\u0001\u0000\u0000\u0000\u026c\u026d\u0005" + + "/\u0000\u0000\u026d\u026e\u0005/\u0000\u0000\u026e\u009e\u0001\u0000\u0000" + + "\u0000\u026f\u0270\u0005/\u0000\u0000\u0270\u0271\u0005/\u0000\u0000\u0271" + + "\u0272\u0005=\u0000\u0000\u0272\u00a0\u0001\u0000\u0000\u0000\u0273\u0274" + + "\u0005@\u0000\u0000\u0274\u00a2\u0001\u0000\u0000\u0000\u0275\u0276\u0005" + + "@\u0000\u0000\u0276\u0277\u0005=\u0000\u0000\u0277\u00a4\u0001\u0000\u0000" + + "\u0000\u0278\u0279\u0005-\u0000\u0000\u0279\u027a\u0005>\u0000\u0000\u027a" + + "\u00a6\u0001\u0000\u0000\u0000\u027b\u027c\u0005.\u0000\u0000\u027c\u027d" + + "\u0005.\u0000\u0000\u027d\u027e\u0005.\u0000\u0000\u027e\u00a8\u0001\u0000" + + "\u0000\u0000\u027f\u0280\u0005:\u0000\u0000\u0280\u0281\u0005=\u0000\u0000" + + "\u0281\u00aa\u0001\u0000\u0000\u0000\u0282\u0283\u0005!\u0000\u0000\u0283" + + "\u00ac\u0001\u0000\u0000\u0000\u0284\u0288\u0003\u0147\u00a0\u0000\u0285" + + "\u0287\u0003\u0145\u009f\u0000\u0286\u0285\u0001\u0000\u0000\u0000\u0287" + + "\u028a\u0001\u0000\u0000\u0000\u0288\u0286\u0001\u0000\u0000\u0000\u0288" + + "\u0289\u0001\u0000\u0000\u0000\u0289\u00ae\u0001\u0000\u0000\u0000\u028a" + + "\u0288\u0001\u0000\u0000\u0000\u028b\u028f\u0003\u0123\u008e\u0000\u028c" + + "\u028f\u0003\u0137\u0098\u0000\u028d\u028f\u0003\u0143\u009e\u0000\u028e" + + "\u028b\u0001\u0000\u0000\u0000\u028e\u028c\u0001\u0000\u0000\u0000\u028e" + + "\u028d\u0001\u0000\u0000\u0000\u028f\u00b0\u0001\u0000\u0000\u0000\u0290" + + "\u0293\u0003\u00ebr\u0000\u0291\u0293\u0003\u0101}\u0000\u0292\u0290\u0001" + + "\u0000\u0000\u0000\u0292\u0291\u0001\u0000\u0000\u0000\u0293\u00b2\u0001" + + "\u0000\u0000\u0000\u0294\u0296\u0005\r\u0000\u0000\u0295\u0294\u0001\u0000" + + "\u0000\u0000\u0295\u0296\u0001\u0000\u0000\u0000\u0296\u0297\u0001\u0000" + + "\u0000\u0000\u0297\u0298\u0005\n\u0000\u0000\u0298\u00b4\u0001\u0000\u0000" + + "\u0000\u0299\u029d\u0005#\u0000\u0000\u029a\u029c\b\u0000\u0000\u0000" + + "\u029b\u029a\u0001\u0000\u0000\u0000\u029c\u029f\u0001\u0000\u0000\u0000" + + "\u029d\u029b\u0001\u0000\u0000\u0000\u029d\u029e\u0001\u0000\u0000\u0000" + + "\u029e\u02a0\u0001\u0000\u0000\u0000\u029f\u029d\u0001\u0000\u0000\u0000" + + "\u02a0\u02a1\u0006W\u0000\u0000\u02a1\u00b6\u0001\u0000\u0000\u0000\u02a2" + + "\u02a4\u0007\u0001\u0000\u0000\u02a3\u02a2\u0001\u0000\u0000\u0000\u02a4" + + "\u02a5\u0001\u0000\u0000\u0000\u02a5\u02a3\u0001\u0000\u0000\u0000\u02a5" + + "\u02a6\u0001\u0000\u0000\u0000\u02a6\u02a7\u0001\u0000\u0000\u0000\u02a7" + + "\u02a8\u0006X\u0000\u0000\u02a8\u00b8\u0001\u0000\u0000\u0000\u02a9\u02aa" + + "\u0005\\\u0000\u0000\u02aa\u02ab\u0003\u00b3V\u0000\u02ab\u02ac\u0001" + + "\u0000\u0000\u0000\u02ac\u02ad\u0006Y\u0000\u0000\u02ad\u00ba\u0001\u0000" + + "\u0000\u0000\u02ae\u02af\u0003\u011b\u008a\u0000\u02af\u02b0\u0007\u0002" + + "\u0000\u0000\u02b0\u02b1\u0001\u0000\u0000\u0000\u02b1\u02b2\u0006Z\u0001" + + "\u0000\u02b2\u02b3\u0006Z\u0002\u0000\u02b3\u00bc\u0001\u0000\u0000\u0000" + + "\u02b4\u02b5\u0003\u011b\u008a\u0000\u02b5\u02b6\u0007\u0003\u0000\u0000" + + "\u02b6\u02b7\u0001\u0000\u0000\u0000\u02b7\u02b8\u0006[\u0001\u0000\u02b8" + + "\u02b9\u0006[\u0003\u0000\u02b9\u00be\u0001\u0000\u0000\u0000\u02ba\u02bb" + + "\u0003\u011b\u008a\u0000\u02bb\u02bc\u0007\u0002\u0000\u0000\u02bc\u02bd" + + "\u0007\u0002\u0000\u0000\u02bd\u02be\u0007\u0002\u0000\u0000\u02be\u02bf" + + "\u0001\u0000\u0000\u0000\u02bf\u02c0\u0006\\\u0001\u0000\u02c0\u02c1\u0006" + + "\\\u0004\u0000\u02c1\u00c0\u0001\u0000\u0000\u0000\u02c2\u02c3\u0003\u011b" + + "\u008a\u0000\u02c3\u02c4\u0007\u0003\u0000\u0000\u02c4\u02c5\u0007\u0003" + + "\u0000\u0000\u02c5\u02c6\u0007\u0003\u0000\u0000\u02c6\u02c7\u0001\u0000" + + "\u0000\u0000\u02c7\u02c8\u0006]\u0001\u0000\u02c8\u02c9\u0006]\u0005\u0000" + + "\u02c9\u00c2\u0001\u0000\u0000\u0000\u02ca\u02cb\t\u0000\u0000\u0000\u02cb" + + "\u00c4\u0001\u0000\u0000\u0000\u02cc\u02cd\u0007\u0002\u0000\u0000\u02cd" + + "\u02ce\u0001\u0000\u0000\u0000\u02ce\u02cf\u0006_\u0006\u0000\u02cf\u02d0" + + "\u0006_\u0007\u0000\u02d0\u00c6\u0001\u0000\u0000\u0000\u02d1\u02d2\u0003" + + "\u0117\u0088\u0000\u02d2\u02d3\u0001\u0000\u0000\u0000\u02d3\u02d4\u0006" + + "`\b\u0000\u02d4\u00c8\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005{\u0000" + + "\u0000\u02d6\u02d7\u0001\u0000\u0000\u0000\u02d7\u02d8\u0006a\t\u0000" + + "\u02d8\u00ca\u0001\u0000\u0000\u0000\u02d9\u02da\u0007\u0003\u0000\u0000" + + "\u02da\u02db\u0001\u0000\u0000\u0000\u02db\u02dc\u0006b\u0006\u0000\u02dc" + + "\u02dd\u0006b\u0007\u0000\u02dd\u00cc\u0001\u0000\u0000\u0000\u02de\u02df" + + "\u0003\u0119\u0089\u0000\u02df\u02e0\u0001\u0000\u0000\u0000\u02e0\u02e1" + + "\u0006c\b\u0000\u02e1\u00ce\u0001\u0000\u0000\u0000\u02e2\u02e3\u0005" + + "{\u0000\u0000\u02e3\u02e4\u0001\u0000\u0000\u0000\u02e4\u02e5\u0006d\t" + + "\u0000\u02e5\u00d0\u0001\u0000\u0000\u0000\u02e6\u02e7\u0007\u0002\u0000" + + "\u0000\u02e7\u02e8\u0007\u0002\u0000\u0000\u02e8\u02e9\u0007\u0002\u0000" + + "\u0000\u02e9\u02ea\u0001\u0000\u0000\u0000\u02ea\u02eb\u0006e\u0006\u0000" + + "\u02eb\u02ec\u0006e\u0007\u0000\u02ec\u00d2\u0001\u0000\u0000\u0000\u02ed" + + "\u02ee\u0003\u0117\u0088\u0000\u02ee\u02ef\u0001\u0000\u0000\u0000\u02ef" + + "\u02f0\u0006f\b\u0000\u02f0\u00d4\u0001\u0000\u0000\u0000\u02f1\u02f2" + + "\u0005{\u0000\u0000\u02f2\u02f3\u0001\u0000\u0000\u0000\u02f3\u02f4\u0006" + + "g\t\u0000\u02f4\u00d6\u0001\u0000\u0000\u0000\u02f5\u02f6\u0007\u0003" + + "\u0000\u0000\u02f6\u02f7\u0007\u0003\u0000\u0000\u02f7\u02f8\u0007\u0003" + + "\u0000\u0000\u02f8\u02f9\u0001\u0000\u0000\u0000\u02f9\u02fa\u0006h\u0006" + + "\u0000\u02fa\u02fb\u0006h\u0007\u0000\u02fb\u00d8\u0001\u0000\u0000\u0000" + + "\u02fc\u02fd\u0003\u0119\u0089\u0000\u02fd\u02fe\u0001\u0000\u0000\u0000" + + "\u02fe\u02ff\u0006i\b\u0000\u02ff\u00da\u0001\u0000\u0000\u0000\u0300" + + "\u0301\u0005{\u0000\u0000\u0301\u0302\u0001\u0000\u0000\u0000\u0302\u0303" + + "\u0006j\t\u0000\u0303\u00dc\u0001\u0000\u0000\u0000\u0304\u0306\u0003" + + "\u011d\u008b\u0000\u0305\u0304\u0001\u0000\u0000\u0000\u0306\u0307\u0001" + + "\u0000\u0000\u0000\u0307\u0305\u0001\u0000\u0000\u0000\u0307\u0308\u0001" + + "\u0000\u0000\u0000\u0308\u0309\u0001\u0000\u0000\u0000\u0309\u030a\u0006" + + "k\b\u0000\u030a\u00de\u0001\u0000\u0000\u0000\u030b\u030c\u0005{\u0000" + + "\u0000\u030c\u030d\u0001\u0000\u0000\u0000\u030d\u030e\u0006l\t\u0000" + + "\u030e\u00e0\u0001\u0000\u0000\u0000\u030f\u0310\u0005}\u0000\u0000\u0310" + + "\u0311\u0001\u0000\u0000\u0000\u0311\u0312\u0006m\n\u0000\u0312\u00e2" + + "\u0001\u0000\u0000\u0000\u0313\u0315\u0003\u011f\u008c\u0000\u0314\u0313" + + "\u0001\u0000\u0000\u0000\u0315\u0316\u0001\u0000\u0000\u0000\u0316\u0314" + + "\u0001\u0000\u0000\u0000\u0316\u0317\u0001\u0000\u0000\u0000\u0317\u0318" + + "\u0001\u0000\u0000\u0000\u0318\u0319\u0006n\b\u0000\u0319\u00e4\u0001" + + "\u0000\u0000\u0000\u031a\u031b\u0005{\u0000\u0000\u031b\u031c\u0001\u0000" + + "\u0000\u0000\u031c\u031d\u0006o\t\u0000\u031d\u00e6\u0001\u0000\u0000" + + "\u0000\u031e\u031f\u0005}\u0000\u0000\u031f\u0320\u0001\u0000\u0000\u0000" + + "\u0320\u0321\u0006p\n\u0000\u0321\u00e8\u0001\u0000\u0000\u0000\u0322" + + "\u0323\u0005i\u0000\u0000\u0323\u0324\u0005g\u0000\u0000\u0324\u0325\u0005" + + "n\u0000\u0000\u0325\u0326\u0005o\u0000\u0000\u0326\u0327\u0005r\u0000" + + "\u0000\u0327\u0328\u0005e\u0000\u0000\u0328\u00ea\u0001\u0000\u0000\u0000" + + "\u0329\u032b\u0003\u00eds\u0000\u032a\u0329\u0001\u0000\u0000\u0000\u032a" + + "\u032b\u0001\u0000\u0000\u0000\u032b\u032e\u0001\u0000\u0000\u0000\u032c" + + "\u032f\u0003\u00eft\u0000\u032d\u032f\u0003\u00f1u\u0000\u032e\u032c\u0001" + + "\u0000\u0000\u0000\u032e\u032d\u0001\u0000\u0000\u0000\u032f\u00ec\u0001" + + "\u0000\u0000\u0000\u0330\u0331\u0007\u0004\u0000\u0000\u0331\u00ee\u0001" + + "\u0000\u0000\u0000\u0332\u0336\u0005\'\u0000\u0000\u0333\u0335\u0003\u00f3" + + "v\u0000\u0334\u0333\u0001\u0000\u0000\u0000\u0335\u0338\u0001\u0000\u0000" + + "\u0000\u0336\u0334\u0001\u0000\u0000\u0000\u0336\u0337\u0001\u0000\u0000" + + "\u0000\u0337\u0339\u0001\u0000\u0000\u0000\u0338\u0336\u0001\u0000\u0000" + + "\u0000\u0339\u0343\u0005\'\u0000\u0000\u033a\u033e\u0005\"\u0000\u0000" + + "\u033b\u033d\u0003\u00f5w\u0000\u033c\u033b\u0001\u0000\u0000\u0000\u033d" + + "\u0340\u0001\u0000\u0000\u0000\u033e\u033c\u0001\u0000\u0000\u0000\u033e" + + "\u033f\u0001\u0000\u0000\u0000\u033f\u0341\u0001\u0000\u0000\u0000\u0340" + + "\u033e\u0001\u0000\u0000\u0000\u0341\u0343\u0005\"\u0000\u0000\u0342\u0332" + + "\u0001\u0000\u0000\u0000\u0342\u033a\u0001\u0000\u0000\u0000\u0343\u00f0" + + "\u0001\u0000\u0000\u0000\u0344\u0345\u0005\'\u0000\u0000\u0345\u0346\u0005" + + "\'\u0000\u0000\u0346\u0347\u0005\'\u0000\u0000\u0347\u034b\u0001\u0000" + + "\u0000\u0000\u0348\u034a\u0003\u00f7x\u0000\u0349\u0348\u0001\u0000\u0000" + + "\u0000\u034a\u034d\u0001\u0000\u0000\u0000\u034b\u034c\u0001\u0000\u0000" + + "\u0000\u034b\u0349\u0001\u0000\u0000\u0000\u034c\u034e\u0001\u0000\u0000" + + "\u0000\u034d\u034b\u0001\u0000\u0000\u0000\u034e\u034f\u0005\'\u0000\u0000" + + "\u034f\u0350\u0005\'\u0000\u0000\u0350\u035f\u0005\'\u0000\u0000\u0351" + + "\u0352\u0005\"\u0000\u0000\u0352\u0353\u0005\"\u0000\u0000\u0353\u0354" + + "\u0005\"\u0000\u0000\u0354\u0358\u0001\u0000\u0000\u0000\u0355\u0357\u0003" + + "\u00f7x\u0000\u0356\u0355\u0001\u0000\u0000\u0000\u0357\u035a\u0001\u0000" + + "\u0000\u0000\u0358\u0359\u0001\u0000\u0000\u0000\u0358\u0356\u0001\u0000" + + "\u0000\u0000\u0359\u035b\u0001\u0000\u0000\u0000\u035a\u0358\u0001\u0000" + + "\u0000\u0000\u035b\u035c\u0005\"\u0000\u0000\u035c\u035d\u0005\"\u0000" + + "\u0000\u035d\u035f\u0005\"\u0000\u0000\u035e\u0344\u0001\u0000\u0000\u0000" + + "\u035e\u0351\u0001\u0000\u0000\u0000\u035f\u00f2\u0001\u0000\u0000\u0000" + + "\u0360\u0363\u0003\u00f9y\u0000\u0361\u0363\u0003\u00ff|\u0000\u0362\u0360" + + "\u0001\u0000\u0000\u0000\u0362\u0361\u0001\u0000\u0000\u0000\u0363\u00f4" + + "\u0001\u0000\u0000\u0000\u0364\u0367\u0003\u00fbz\u0000\u0365\u0367\u0003" + + "\u00ff|\u0000\u0366\u0364\u0001\u0000\u0000\u0000\u0366\u0365\u0001\u0000" + + "\u0000\u0000\u0367\u00f6\u0001\u0000\u0000\u0000\u0368\u036b\u0003\u00fd" + + "{\u0000\u0369\u036b\u0003\u00ff|\u0000\u036a\u0368\u0001\u0000\u0000\u0000" + + "\u036a\u0369\u0001\u0000\u0000\u0000\u036b\u00f8\u0001\u0000\u0000\u0000" + + "\u036c\u036d\b\u0005\u0000\u0000\u036d\u00fa\u0001\u0000\u0000\u0000\u036e" + + "\u036f\b\u0006\u0000\u0000\u036f\u00fc\u0001\u0000\u0000\u0000\u0370\u0371" + + "\b\u0007\u0000\u0000\u0371\u00fe\u0001\u0000\u0000\u0000\u0372\u0373\u0005" + + "\\\u0000\u0000\u0373\u0374\u0005\r\u0000\u0000\u0374\u0378\u0005\n\u0000" + + "\u0000\u0375\u0376\u0005\\\u0000\u0000\u0376\u0378\t\u0000\u0000\u0000" + + "\u0377\u0372\u0001\u0000\u0000\u0000\u0377\u0375\u0001\u0000\u0000\u0000" + + "\u0378\u0100\u0001\u0000\u0000\u0000\u0379\u037c\u0003\u0103~\u0000\u037a" + + "\u037d\u0003\u0105\u007f\u0000\u037b\u037d\u0003\u0107\u0080\u0000\u037c" + + "\u037a\u0001\u0000\u0000\u0000\u037c\u037b\u0001\u0000\u0000\u0000\u037d" + + "\u0102\u0001\u0000\u0000\u0000\u037e\u0390\u0007\b\u0000\u0000\u037f\u0380" + + "\u0005b\u0000\u0000\u0380\u0390\u0005r\u0000\u0000\u0381\u0382\u0005B" + + "\u0000\u0000\u0382\u0390\u0005r\u0000\u0000\u0383\u0384\u0005b\u0000\u0000" + + "\u0384\u0390\u0005R\u0000\u0000\u0385\u0386\u0005B\u0000\u0000\u0386\u0390" + + "\u0005R\u0000\u0000\u0387\u0388\u0005r\u0000\u0000\u0388\u0390\u0005b" + + "\u0000\u0000\u0389\u038a\u0005r\u0000\u0000\u038a\u0390\u0005B\u0000\u0000" + + "\u038b\u038c\u0005R\u0000\u0000\u038c\u0390\u0005b\u0000\u0000\u038d\u038e" + + "\u0005R\u0000\u0000\u038e\u0390\u0005B\u0000\u0000\u038f\u037e\u0001\u0000" + + "\u0000\u0000\u038f\u037f\u0001\u0000\u0000\u0000\u038f\u0381\u0001\u0000" + + "\u0000\u0000\u038f\u0383\u0001\u0000\u0000\u0000\u038f\u0385\u0001\u0000" + + "\u0000\u0000\u038f\u0387\u0001\u0000\u0000\u0000\u038f\u0389\u0001\u0000" + + "\u0000\u0000\u038f\u038b\u0001\u0000\u0000\u0000\u038f\u038d\u0001\u0000" + + "\u0000\u0000\u0390\u0104\u0001\u0000\u0000\u0000\u0391\u0395\u0005\'\u0000" + + "\u0000\u0392\u0394\u0003\u0109\u0081\u0000\u0393\u0392\u0001\u0000\u0000" + + "\u0000\u0394\u0397\u0001\u0000\u0000\u0000\u0395\u0393\u0001\u0000\u0000" + + "\u0000\u0395\u0396\u0001\u0000\u0000\u0000\u0396\u0398\u0001\u0000\u0000" + + "\u0000\u0397\u0395\u0001\u0000\u0000\u0000\u0398\u03a2\u0005\'\u0000\u0000" + + "\u0399\u039d\u0005\"\u0000\u0000\u039a\u039c\u0003\u010b\u0082\u0000\u039b" + + "\u039a\u0001\u0000\u0000\u0000\u039c\u039f\u0001\u0000\u0000\u0000\u039d" + + "\u039b\u0001\u0000\u0000\u0000\u039d\u039e\u0001\u0000\u0000\u0000\u039e" + + "\u03a0\u0001\u0000\u0000\u0000\u039f\u039d\u0001\u0000\u0000\u0000\u03a0" + + "\u03a2\u0005\"\u0000\u0000\u03a1\u0391\u0001\u0000\u0000\u0000\u03a1\u0399" + + "\u0001\u0000\u0000\u0000\u03a2\u0106\u0001\u0000\u0000\u0000\u03a3\u03a4" + + "\u0005\'\u0000\u0000\u03a4\u03a5\u0005\'\u0000\u0000\u03a5\u03a6\u0005" + + "\'\u0000\u0000\u03a6\u03aa\u0001\u0000\u0000\u0000\u03a7\u03a9\u0003\u010d" + + "\u0083\u0000\u03a8\u03a7\u0001\u0000\u0000\u0000\u03a9\u03ac\u0001\u0000" + + "\u0000\u0000\u03aa\u03ab\u0001\u0000\u0000\u0000\u03aa\u03a8\u0001\u0000" + + "\u0000\u0000\u03ab\u03ad\u0001\u0000\u0000\u0000\u03ac\u03aa\u0001\u0000" + + "\u0000\u0000\u03ad\u03ae\u0005\'\u0000\u0000\u03ae\u03af\u0005\'\u0000" + + "\u0000\u03af\u03be\u0005\'\u0000\u0000\u03b0\u03b1\u0005\"\u0000\u0000" + + "\u03b1\u03b2\u0005\"\u0000\u0000\u03b2\u03b3\u0005\"\u0000\u0000\u03b3" + + "\u03b7\u0001\u0000\u0000\u0000\u03b4\u03b6\u0003\u010d\u0083\u0000\u03b5" + + "\u03b4\u0001\u0000\u0000\u0000\u03b6\u03b9\u0001\u0000\u0000\u0000\u03b7" + + "\u03b8\u0001\u0000\u0000\u0000\u03b7\u03b5\u0001\u0000\u0000\u0000\u03b8" + + "\u03ba\u0001\u0000\u0000\u0000\u03b9\u03b7\u0001\u0000\u0000\u0000\u03ba" + + "\u03bb\u0005\"\u0000\u0000\u03bb\u03bc\u0005\"\u0000\u0000\u03bc\u03be" + + "\u0005\"\u0000\u0000\u03bd\u03a3\u0001\u0000\u0000\u0000\u03bd\u03b0\u0001" + + "\u0000\u0000\u0000\u03be\u0108\u0001\u0000\u0000\u0000\u03bf\u03c2\u0003" + + "\u010f\u0084\u0000\u03c0\u03c2\u0003\u0115\u0087\u0000\u03c1\u03bf\u0001" + + "\u0000\u0000\u0000\u03c1\u03c0\u0001\u0000\u0000\u0000\u03c2\u010a\u0001" + + "\u0000\u0000\u0000\u03c3\u03c6\u0003\u0111\u0085\u0000\u03c4\u03c6\u0003" + + "\u0115\u0087\u0000\u03c5\u03c3\u0001\u0000\u0000\u0000\u03c5\u03c4\u0001" + + "\u0000\u0000\u0000\u03c6\u010c\u0001\u0000\u0000\u0000\u03c7\u03ca\u0003" + + "\u0113\u0086\u0000\u03c8\u03ca\u0003\u0115\u0087\u0000\u03c9\u03c7\u0001" + + "\u0000\u0000\u0000\u03c9\u03c8\u0001\u0000\u0000\u0000\u03ca\u010e\u0001" + + "\u0000\u0000\u0000\u03cb\u03cd\u0007\t\u0000\u0000\u03cc\u03cb\u0001\u0000" + + "\u0000\u0000\u03cd\u0110\u0001\u0000\u0000\u0000\u03ce\u03d0\u0007\n\u0000" + + "\u0000\u03cf\u03ce\u0001\u0000\u0000\u0000\u03d0\u0112\u0001\u0000\u0000" + + "\u0000\u03d1\u03d3\u0007\u000b\u0000\u0000\u03d2\u03d1\u0001\u0000\u0000" + + "\u0000\u03d3\u0114\u0001\u0000\u0000\u0000\u03d4\u03d5\u0005\\\u0000\u0000" + + "\u03d5\u03d6\u0007\f\u0000\u0000\u03d6\u0116\u0001\u0000\u0000\u0000\u03d7" + + "\u03da\u0003\u011d\u008b\u0000\u03d8\u03da\u0003\u0121\u008d\u0000\u03d9" + + "\u03d7\u0001\u0000\u0000\u0000\u03d9\u03d8\u0001\u0000\u0000\u0000\u03da" + + "\u03db\u0001\u0000\u0000\u0000\u03db\u03d9\u0001\u0000\u0000\u0000\u03db" + + "\u03dc\u0001\u0000\u0000\u0000\u03dc\u0118\u0001\u0000\u0000\u0000\u03dd" + + "\u03e0\u0003\u011f\u008c\u0000\u03de\u03e0\u0003\u0121\u008d\u0000\u03df" + + "\u03dd\u0001\u0000\u0000\u0000\u03df\u03de\u0001\u0000\u0000\u0000\u03e0" + + "\u03e1\u0001\u0000\u0000\u0000\u03e1\u03df\u0001\u0000\u0000\u0000\u03e1" + + "\u03e2\u0001\u0000\u0000\u0000\u03e2\u011a\u0001\u0000\u0000\u0000\u03e3" + + "\u03f5\u0007\r\u0000\u0000\u03e4\u03e5\u0005f\u0000\u0000\u03e5\u03f5" + + "\u0005r\u0000\u0000\u03e6\u03e7\u0005F\u0000\u0000\u03e7\u03f5\u0005r" + + "\u0000\u0000\u03e8\u03e9\u0005f\u0000\u0000\u03e9\u03f5\u0005R\u0000\u0000" + + "\u03ea\u03eb\u0005F\u0000\u0000\u03eb\u03f5\u0005R\u0000\u0000\u03ec\u03ed" + + "\u0005r\u0000\u0000\u03ed\u03f5\u0005f\u0000\u0000\u03ee\u03ef\u0005r" + + "\u0000\u0000\u03ef\u03f5\u0005F\u0000\u0000\u03f0\u03f1\u0005R\u0000\u0000" + + "\u03f1\u03f5\u0005f\u0000\u0000\u03f2\u03f3\u0005R\u0000\u0000\u03f3\u03f5" + + "\u0005F\u0000\u0000\u03f4\u03e3\u0001\u0000\u0000\u0000\u03f4\u03e4\u0001" + + "\u0000\u0000\u0000\u03f4\u03e6\u0001\u0000\u0000\u0000\u03f4\u03e8\u0001" + + "\u0000\u0000\u0000\u03f4\u03ea\u0001\u0000\u0000\u0000\u03f4\u03ec\u0001" + + "\u0000\u0000\u0000\u03f4\u03ee\u0001\u0000\u0000\u0000\u03f4\u03f0\u0001" + + "\u0000\u0000\u0000\u03f4\u03f2\u0001\u0000\u0000\u0000\u03f5\u011c\u0001" + + "\u0000\u0000\u0000\u03f6\u03f7\b\u000e\u0000\u0000\u03f7\u011e\u0001\u0000" + + "\u0000\u0000\u03f8\u03f9\b\u000f\u0000\u0000\u03f9\u0120\u0001\u0000\u0000" + + "\u0000\u03fa\u03fb\u0005{\u0000\u0000\u03fb\u03ff\u0005{\u0000\u0000\u03fc" + + "\u03fd\u0005}\u0000\u0000\u03fd\u03ff\u0005}\u0000\u0000\u03fe\u03fa\u0001" + + "\u0000\u0000\u0000\u03fe\u03fc\u0001\u0000\u0000\u0000\u03ff\u0122\u0001" + + "\u0000\u0000\u0000\u0400\u0405\u0003\u0125\u008f\u0000\u0401\u0405\u0003" + + "\u0127\u0090\u0000\u0402\u0405\u0003\u0129\u0091\u0000\u0403\u0405\u0003" + + "\u012b\u0092\u0000\u0404\u0400\u0001\u0000\u0000\u0000\u0404\u0401\u0001" + + "\u0000\u0000\u0000\u0404\u0402\u0001\u0000\u0000\u0000\u0404\u0403\u0001" + + "\u0000\u0000\u0000\u0405\u0124\u0001\u0000\u0000\u0000\u0406\u040d\u0003" + + "\u012d\u0093\u0000\u0407\u0409\u0005_\u0000\u0000\u0408\u0407\u0001\u0000" + + "\u0000\u0000\u0408\u0409\u0001\u0000\u0000\u0000\u0409\u040a\u0001\u0000" + + "\u0000\u0000\u040a\u040c\u0003\u012f\u0094\u0000\u040b\u0408\u0001\u0000" + + "\u0000\u0000\u040c\u040f\u0001\u0000\u0000\u0000\u040d\u040b\u0001\u0000" + + "\u0000\u0000\u040d\u040e\u0001\u0000\u0000\u0000\u040e\u041f\u0001\u0000" + + "\u0000\u0000\u040f\u040d\u0001\u0000\u0000\u0000\u0410\u0412\u00050\u0000" + + "\u0000\u0411\u0410\u0001\u0000\u0000\u0000\u0412\u0413\u0001\u0000\u0000" + + "\u0000\u0413\u0411\u0001\u0000\u0000\u0000\u0413\u0414\u0001\u0000\u0000" + + "\u0000\u0414\u041b\u0001\u0000\u0000\u0000\u0415\u0417\u0005_\u0000\u0000" + + "\u0416\u0415\u0001\u0000\u0000\u0000\u0416\u0417\u0001\u0000\u0000\u0000" + + "\u0417\u0418\u0001\u0000\u0000\u0000\u0418\u041a\u00050\u0000\u0000\u0419" + + "\u0416\u0001\u0000\u0000\u0000\u041a\u041d\u0001\u0000\u0000\u0000\u041b" + + "\u0419\u0001\u0000\u0000\u0000\u041b\u041c\u0001\u0000\u0000\u0000\u041c" + + "\u041f\u0001\u0000\u0000\u0000\u041d\u041b\u0001\u0000\u0000\u0000\u041e" + + "\u0406\u0001\u0000\u0000\u0000\u041e\u0411\u0001\u0000\u0000\u0000\u041f" + + "\u0126\u0001\u0000\u0000\u0000\u0420\u0421\u00050\u0000\u0000\u0421\u0426" + + "\u0007\b\u0000\u0000\u0422\u0424\u0005_\u0000\u0000\u0423\u0422\u0001" + + "\u0000\u0000\u0000\u0423\u0424\u0001\u0000\u0000\u0000\u0424\u0425\u0001" + + "\u0000\u0000\u0000\u0425\u0427\u0003\u0131\u0095\u0000\u0426\u0423\u0001" + + "\u0000\u0000\u0000\u0427\u0428\u0001\u0000\u0000\u0000\u0428\u0426\u0001" + + "\u0000\u0000\u0000\u0428\u0429\u0001\u0000\u0000\u0000\u0429\u0128\u0001" + + "\u0000\u0000\u0000\u042a\u042b\u00050\u0000\u0000\u042b\u0430\u0007\u0010" + + "\u0000\u0000\u042c\u042e\u0005_\u0000\u0000\u042d\u042c\u0001\u0000\u0000" + + "\u0000\u042d\u042e\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000" + + "\u0000\u042f\u0431\u0003\u0133\u0096\u0000\u0430\u042d\u0001\u0000\u0000" + + "\u0000\u0431\u0432\u0001\u0000\u0000\u0000\u0432\u0430\u0001\u0000\u0000" + + "\u0000\u0432\u0433\u0001\u0000\u0000\u0000\u0433\u012a\u0001\u0000\u0000" + + "\u0000\u0434\u0435\u00050\u0000\u0000\u0435\u043a\u0007\u0011\u0000\u0000" + + "\u0436\u0438\u0005_\u0000\u0000\u0437\u0436\u0001\u0000\u0000\u0000\u0437" + + "\u0438\u0001\u0000\u0000\u0000\u0438\u0439\u0001\u0000\u0000\u0000\u0439" + + "\u043b\u0003\u0135\u0097\u0000\u043a\u0437\u0001\u0000\u0000\u0000\u043b" + + "\u043c\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000\u0000\u0000\u043c" + + "\u043d\u0001\u0000\u0000\u0000\u043d\u012c\u0001\u0000\u0000\u0000\u043e" + + "\u043f\u0007\u0012\u0000\u0000\u043f\u012e\u0001\u0000\u0000\u0000\u0440" + + "\u0441\u0007\u0013\u0000\u0000\u0441\u0130\u0001\u0000\u0000\u0000\u0442" + + "\u0443\u000201\u0000\u0443\u0132\u0001\u0000\u0000\u0000\u0444\u0445\u0007" + + "\u0014\u0000\u0000\u0445\u0134\u0001\u0000\u0000\u0000\u0446\u0449\u0003" + + "\u012f\u0094\u0000\u0447\u0449\u0007\u0015\u0000\u0000\u0448\u0446\u0001" + + "\u0000\u0000\u0000\u0448\u0447\u0001\u0000\u0000\u0000\u0449\u0136\u0001" + + "\u0000\u0000\u0000\u044a\u044d\u0003\u0139\u0099\u0000\u044b\u044d\u0003" + + "\u013b\u009a\u0000\u044c\u044a\u0001\u0000\u0000\u0000\u044c\u044b\u0001" + + "\u0000\u0000\u0000\u044d\u0138\u0001\u0000\u0000\u0000\u044e\u0450\u0003" + + "\u013d\u009b\u0000\u044f\u044e\u0001\u0000\u0000\u0000\u044f\u0450\u0001" + + "\u0000\u0000\u0000\u0450\u0451\u0001\u0000\u0000\u0000\u0451\u0456\u0003" + + "\u013f\u009c\u0000\u0452\u0453\u0003\u013d\u009b\u0000\u0453\u0454\u0005" + + ".\u0000\u0000\u0454\u0456\u0001\u0000\u0000\u0000\u0455\u044f\u0001\u0000" + + "\u0000\u0000\u0455\u0452\u0001\u0000\u0000\u0000\u0456\u013a\u0001\u0000" + + "\u0000\u0000\u0457\u045a\u0003\u013d\u009b\u0000\u0458\u045a\u0003\u0139" + + "\u0099\u0000\u0459\u0457\u0001\u0000\u0000\u0000\u0459\u0458\u0001\u0000" + + "\u0000\u0000\u045a\u045b\u0001\u0000\u0000\u0000\u045b\u045c\u0003\u0141" + + "\u009d\u0000\u045c\u013c\u0001\u0000\u0000\u0000\u045d\u0464\u0003\u012f" + + "\u0094\u0000\u045e\u0460\u0005_\u0000\u0000\u045f\u045e\u0001\u0000\u0000" + + "\u0000\u045f\u0460\u0001\u0000\u0000\u0000\u0460\u0461\u0001\u0000\u0000" + + "\u0000\u0461\u0463\u0003\u012f\u0094\u0000\u0462\u045f\u0001\u0000\u0000" + + "\u0000\u0463\u0466\u0001\u0000\u0000\u0000\u0464\u0462\u0001\u0000\u0000" + + "\u0000\u0464\u0465\u0001\u0000\u0000\u0000\u0465\u013e\u0001\u0000\u0000" + + "\u0000\u0466\u0464\u0001\u0000\u0000\u0000\u0467\u0468\u0005.\u0000\u0000" + + "\u0468\u0469\u0003\u013d\u009b\u0000\u0469\u0140\u0001\u0000\u0000\u0000" + + "\u046a\u046c\u0007\u0016\u0000\u0000\u046b\u046d\u0007\u0017\u0000\u0000" + + "\u046c\u046b\u0001\u0000\u0000\u0000\u046c\u046d\u0001\u0000\u0000\u0000" + + "\u046d\u046e\u0001\u0000\u0000\u0000\u046e\u046f\u0003\u013d\u009b\u0000" + + "\u046f\u0142\u0001\u0000\u0000\u0000\u0470\u0473\u0003\u0137\u0098\u0000" + + "\u0471\u0473\u0003\u013d\u009b\u0000\u0472\u0470\u0001\u0000\u0000\u0000" + + "\u0472\u0471\u0001\u0000\u0000\u0000\u0473\u0474\u0001\u0000\u0000\u0000" + + "\u0474\u0475\u0007\u0018\u0000\u0000\u0475\u0144\u0001\u0000\u0000\u0000" + + "\u0476\u0479\u0003\u0147\u00a0\u0000\u0477\u0479\u0007\u0019\u0000\u0000" + + "\u0478\u0476\u0001\u0000\u0000\u0000\u0478\u0477\u0001\u0000\u0000\u0000" + + "\u0479\u0146\u0001\u0000\u0000\u0000\u047a\u047b\u0007\u001a\u0000\u0000" + + "\u047b\u0148\u0001\u0000\u0000\u0000F\u0000\u0001\u0002\u0003\u0004\u0005" + + "\u0006\u0288\u028e\u0292\u0295\u029d\u02a5\u0307\u0316\u032a\u032e\u0336" + + "\u033e\u0342\u034b\u0358\u035e\u0362\u0366\u036a\u0377\u037c\u038f\u0395" + + "\u039d\u03a1\u03aa\u03b7\u03bd\u03c1\u03c5\u03c9\u03cc\u03cf\u03d2\u03d9" + + "\u03db\u03df\u03e1\u03f4\u03fe\u0404\u0408\u040d\u0413\u0416\u041b\u041e" + + "\u0423\u0428\u042d\u0432\u0437\u043c\u0448\u044c\u044f\u0455\u0459\u045f" + + "\u0464\u046c\u0472\u0478\u000b\u0000\u0001\u0000\u0007\u0004\u0000\u0005" + + "\u0001\u0000\u0005\u0002\u0000\u0005\u0003\u0000\u0005\u0004\u0000\u0007" + + "\u0006\u0000\u0004\u0000\u0000\u0007\u0005\u0000\u0007,\u0000\u0007/\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/PythonLexer.tokens b/src/main/java/PythonLexer.tokens new file mode 100644 index 0000000..37493cd --- /dev/null +++ b/src/main/java/PythonLexer.tokens @@ -0,0 +1,178 @@ +INDENT=1 +DEDENT=2 +TYPE_COMMENT=3 +FSTRING_START=4 +FSTRING_MIDDLE=5 +FSTRING_END=6 +FALSE=7 +AWAIT=8 +ELSE=9 +IMPORT=10 +PASS=11 +NONE=12 +BREAK=13 +EXCEPT=14 +IN=15 +RAISE=16 +TRUE=17 +CLASS=18 +FINALLY=19 +IS=20 +RETURN=21 +AND=22 +CONTINUE=23 +FOR=24 +LAMBDA=25 +TRY=26 +AS=27 +DEF=28 +FROM=29 +NONLOCAL=30 +WHILE=31 +ASSERT=32 +DEL=33 +GLOBAL=34 +NOT=35 +WITH=36 +ASYNC=37 +ELIF=38 +IF=39 +OR=40 +YIELD=41 +LPAR=42 +LSQB=43 +LBRACE=44 +RPAR=45 +RSQB=46 +RBRACE=47 +DOT=48 +COLON=49 +COMMA=50 +SEMI=51 +PLUS=52 +MINUS=53 +STAR=54 +SLASH=55 +VBAR=56 +AMPER=57 +LESS=58 +GREATER=59 +EQUAL=60 +PERCENT=61 +EQEQUAL=62 +NOTEQUAL=63 +LESSEQUAL=64 +GREATEREQUAL=65 +TILDE=66 +CIRCUMFLEX=67 +LEFTSHIFT=68 +RIGHTSHIFT=69 +DOUBLESTAR=70 +PLUSEQUAL=71 +MINEQUAL=72 +STAREQUAL=73 +SLASHEQUAL=74 +PERCENTEQUAL=75 +AMPEREQUAL=76 +VBAREQUAL=77 +CIRCUMFLEXEQUAL=78 +LEFTSHIFTEQUAL=79 +RIGHTSHIFTEQUAL=80 +DOUBLESTAREQUAL=81 +DOUBLESLASH=82 +DOUBLESLASHEQUAL=83 +AT=84 +ATEQUAL=85 +RARROW=86 +ELLIPSIS=87 +COLONEQUAL=88 +EXCLAMATION=89 +NAME=90 +NUMBER=91 +STRING=92 +NEWLINE=93 +COMMENT=94 +WS=95 +EXPLICIT_LINE_JOINING=96 +ERRORTOKEN=97 +'False'=7 +'await'=8 +'else'=9 +'import'=10 +'pass'=11 +'None'=12 +'break'=13 +'except'=14 +'in'=15 +'raise'=16 +'True'=17 +'class'=18 +'finally'=19 +'is'=20 +'return'=21 +'and'=22 +'continue'=23 +'for'=24 +'lambda'=25 +'try'=26 +'as'=27 +'def'=28 +'from'=29 +'nonlocal'=30 +'while'=31 +'assert'=32 +'del'=33 +'global'=34 +'not'=35 +'with'=36 +'async'=37 +'elif'=38 +'if'=39 +'or'=40 +'yield'=41 +'('=42 +'['=43 +')'=45 +']'=46 +'.'=48 +':'=49 +','=50 +';'=51 +'+'=52 +'-'=53 +'*'=54 +'/'=55 +'|'=56 +'&'=57 +'<'=58 +'>'=59 +'='=60 +'%'=61 +'=='=62 +'!='=63 +'<='=64 +'>='=65 +'~'=66 +'^'=67 +'<<'=68 +'>>'=69 +'**'=70 +'+='=71 +'-='=72 +'*='=73 +'/='=74 +'%='=75 +'&='=76 +'|='=77 +'^='=78 +'<<='=79 +'>>='=80 +'**='=81 +'//'=82 +'//='=83 +'@'=84 +'@='=85 +'->'=86 +'...'=87 +':='=88 +'!'=89 diff --git a/src/main/java/PythonLexerBase.java b/src/main/java/PythonLexerBase.java new file mode 100644 index 0000000..b28e654 --- /dev/null +++ b/src/main/java/PythonLexerBase.java @@ -0,0 +1,402 @@ +/* +The MIT License (MIT) +Copyright (c) 2021 Robert Einhorn + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + */ + +/* + * + * Project : Python Indent/Dedent handler for ANTLR4 grammars + * + * Developed by : Robert Einhorn, robert.einhorn.hu@gmail.com + * + */ + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CommonToken; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.Token; + +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.LinkedList; + +public abstract class PythonLexerBase extends Lexer { + // A stack that keeps track of the indentation lengths + private Deque indentLengthStack; + // A list where tokens are waiting to be loaded into the token stream + private LinkedList pendingTokens; + + // last pending token types + private int previousPendingTokenType; + private int lastPendingTokenTypeFromDefaultChannel; + + // The amount of opened parentheses, square brackets or curly braces + private int opened; + // The amount of opened parentheses and square brackets in the current lexer mode + private Deque paren_or_bracket_openedStack; + + private boolean wasSpaceIndentation; + private boolean wasTabIndentation; + private boolean wasIndentationMixedWithSpacesAndTabs; + + private Token curToken; // current (under processing) token + private Token ffgToken; // following (look ahead) token + + private final int INVALID_LENGTH = -1; + private final String ERR_TXT = " ERROR: "; + + protected PythonLexerBase(CharStream input) { + super(input); + this.init(); + } + + @Override + public Token nextToken() { // reading the input stream until a return EOF + this.checkNextToken(); + return this.pendingTokens.pollFirst(); // add the queued token to the token stream + } + + @Override + public void reset() { + this.init(); + super.reset(); + } + + private void init() { + this.indentLengthStack = new ArrayDeque<>(); + this.pendingTokens = new LinkedList<>(); + this.previousPendingTokenType = 0; + this.lastPendingTokenTypeFromDefaultChannel = 0; + this.opened = 0; + this.paren_or_bracket_openedStack = new ArrayDeque<>(); + this.wasSpaceIndentation = false; + this.wasTabIndentation = false; + this.wasIndentationMixedWithSpacesAndTabs = false; + this.curToken = null; + this.ffgToken = null; + } + + private void checkNextToken() { + if (this.previousPendingTokenType != Token.EOF) { + this.setCurrentAndFollowingTokens(); + if (this.indentLengthStack.isEmpty()) { // We're at the first token + this.handleStartOfInput(); + } + + switch (this.curToken.getType()) { + case PythonLexer.LPAR: + case PythonLexer.LSQB: + case PythonLexer.LBRACE: + this.opened++; + this.addPendingToken(this.curToken); + break; + case PythonLexer.RPAR: + case PythonLexer.RSQB: + case PythonLexer.RBRACE: + this.opened--; + this.addPendingToken(this.curToken); + break; + case PythonLexer.NEWLINE: + this.handleNEWLINEtoken(); + break; + case PythonLexer.FSTRING_MIDDLE: + this.handleFSTRING_MIDDLE_token(); + break; + case PythonLexer.ERRORTOKEN: + this.reportLexerError("token recognition error at: '" + this.curToken.getText() + "'"); + this.addPendingToken(this.curToken); + break; + case Token.EOF: + this.handleEOFtoken(); + break; + default: + this.addPendingToken(this.curToken); + } + this.handleFORMAT_SPECIFICATION_MODE(); + } + } + + private void setCurrentAndFollowingTokens() { + this.curToken = this.ffgToken == null ? + super.nextToken() : + this.ffgToken; + + this.handleFStringLexerModes(); + + this.ffgToken = this.curToken.getType() == Token.EOF ? + this.curToken : + super.nextToken(); + } + + // initialize the indentLengthStack + // hide the leading NEWLINE token(s) + // if exists, find the first statement (not NEWLINE, not EOF token) that comes from the default channel + // insert a leading INDENT token if necessary + private void handleStartOfInput() { + // initialize the stack with a default 0 indentation length + this.indentLengthStack.push(0); // this will never be popped off + while (this.curToken.getType() != Token.EOF) { + if (this.curToken.getChannel() == Token.DEFAULT_CHANNEL) { + if (this.curToken.getType() == PythonLexer.NEWLINE) { + // all the NEWLINE tokens must be ignored before the first statement + this.hideAndAddPendingToken(this.curToken); + } else { // We're at the first statement + this.insertLeadingIndentToken(); + return; // continue the processing of the current token with checkNextToken() + } + } else { + this.addPendingToken(this.curToken); // it can be WS, EXPLICIT_LINE_JOINING or COMMENT token + } + this.setCurrentAndFollowingTokens(); + } + // continue the processing of the EOF token with checkNextToken() + } + + private void insertLeadingIndentToken() { + if (this.previousPendingTokenType == PythonLexer.WS) { + Token prevToken = this.pendingTokens.peekLast(); // WS token + if (this.getIndentationLength(prevToken.getText()) != 0) { // there is an "indentation" before the first statement + final String errMsg = "first statement indented"; + this.reportLexerError(errMsg); + // insert an INDENT token before the first statement to raise an 'unexpected indent' error later by the parser + this.createAndAddPendingToken(PythonLexer.INDENT, Token.DEFAULT_CHANNEL, this.ERR_TXT + errMsg, this.curToken); + } + } + } + + private void handleNEWLINEtoken() { + if (this.opened > 0) { // We're in an implicit line joining, ignore the current NEWLINE token + this.hideAndAddPendingToken(this.curToken); + } else { + final Token nlToken = new CommonToken(this.curToken); // save the current NEWLINE token + final boolean isLookingAhead = this.ffgToken.getType() == PythonLexer.WS; + if (isLookingAhead) { + this.setCurrentAndFollowingTokens(); // set the next two tokens + } + + switch (this.ffgToken.getType()) { + case PythonLexer.NEWLINE: // We're before a blank line + case PythonLexer.COMMENT: // We're before a comment + this.hideAndAddPendingToken(nlToken); + if (isLookingAhead) { + this.addPendingToken(this.curToken); // WS token + } + break; + default: + this.addPendingToken(nlToken); + if (isLookingAhead) { // We're on whitespace(s) followed by a statement + final int indentationLength = this.ffgToken.getType() == Token.EOF ? + 0 : + this.getIndentationLength(this.curToken.getText()); + + if (indentationLength != this.INVALID_LENGTH) { + this.addPendingToken(this.curToken); // WS token + this.insertIndentOrDedentToken(indentationLength); // may insert INDENT token or DEDENT token(s) + } else { + this.reportError("inconsistent use of tabs and spaces in indentation"); + } + } else { // We're at a newline followed by a statement (there is no whitespace before the statement) + this.insertIndentOrDedentToken(0); // may insert DEDENT token(s) + } + } + } + } + + private void insertIndentOrDedentToken(final int indentLength) { + int prevIndentLength = this.indentLengthStack.peek(); + if (indentLength > prevIndentLength) { + this.createAndAddPendingToken(PythonLexer.INDENT, Token.DEFAULT_CHANNEL, null, this.ffgToken); + this.indentLengthStack.push(indentLength); + } else { + while (indentLength < prevIndentLength) { // more than 1 DEDENT token may be inserted to the token stream + this.indentLengthStack.pop(); + prevIndentLength = this.indentLengthStack.peek(); + if (indentLength <= prevIndentLength) { + this.createAndAddPendingToken(PythonLexer.DEDENT, Token.DEFAULT_CHANNEL, null, this.ffgToken); + } else { + this.reportError("inconsistent dedent"); + } + } + } + } + + private void handleFSTRING_MIDDLE_token() { // replace the double braces '{{' or '}}' to single braces and hide the second braces + String fsMid = this.curToken.getText(); + fsMid = fsMid.replaceAll("\\{\\{", "{_").replaceAll("}}", "}_"); // replace: {{ --> {_ and }} --> }_ + String[] arrOfStr = fsMid.split("(?<=[{}])_"); // split by {_ or }_ + for (String s : arrOfStr) { + if (!s.isEmpty()) { + this.createAndAddPendingToken(PythonLexer.FSTRING_MIDDLE, Token.DEFAULT_CHANNEL, s, this.ffgToken); + final String lastCharacter = s.substring(s.length() - 1); + if ("{}".contains(lastCharacter)) { + this.createAndAddPendingToken(PythonLexer.FSTRING_MIDDLE, Token.HIDDEN_CHANNEL, lastCharacter, this.ffgToken); + // this inserted hidden token allows to restore the original f-string literal with the double braces + } + } + } + } + + private void handleFStringLexerModes() { // https://peps.python.org/pep-0498/#specification + if (!this._modeStack.isEmpty()) { + switch (this.curToken.getType()) { + case PythonLexer.LBRACE: + this.pushMode(Lexer.DEFAULT_MODE); + this.paren_or_bracket_openedStack.push(0); + break; + case PythonLexer.LPAR: + case PythonLexer.LSQB: + // https://peps.python.org/pep-0498/#lambdas-inside-expressions + this.paren_or_bracket_openedStack.push(this.paren_or_bracket_openedStack.pop() + 1); // increment the last element + break; + case PythonLexer.RPAR: + case PythonLexer.RSQB: + this.paren_or_bracket_openedStack.push(this.paren_or_bracket_openedStack.pop() - 1); // decrement the last element + break; + case PythonLexer.COLON: // colon can only come from DEFAULT_MODE + if (this.paren_or_bracket_openedStack.peek() == 0) { + switch (_modeStack.peek()) { // check the previous lexer mode (the current is DEFAULT_MODE) + case PythonLexer.SINGLE_QUOTE_FSTRING_MODE: + case PythonLexer.LONG_SINGLE_QUOTE_FSTRING_MODE: + case PythonLexer.SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE: + this.mode(PythonLexer.SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE); // continue in format spec. mode + break; + case PythonLexer.DOUBLE_QUOTE_FSTRING_MODE: + case PythonLexer.LONG_DOUBLE_QUOTE_FSTRING_MODE: + case PythonLexer.DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE: + this.mode(PythonLexer.DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE); // continue in format spec. mode + break; + } + } + break; + case PythonLexer.RBRACE: + switch (this._mode) { + case Lexer.DEFAULT_MODE: + case PythonLexer.SINGLE_QUOTE_FORMAT_SPECIFICATION_MODE: + case PythonLexer.DOUBLE_QUOTE_FORMAT_SPECIFICATION_MODE: + this.popMode(); + this.paren_or_bracket_openedStack.pop(); + break; + default: + this.reportLexerError("f-string: single '}' is not allowed"); + } + break; + } + } + } + + private void handleFORMAT_SPECIFICATION_MODE() { + if (!this._modeStack.isEmpty() && + this.ffgToken.getType() == PythonLexer.RBRACE) { + + switch (this.curToken.getType()) { + case PythonLexer.COLON: + case PythonLexer.RBRACE: + // insert an empty FSTRING_MIDDLE token instead of the missing format specification + this.createAndAddPendingToken(PythonLexer.FSTRING_MIDDLE, Token.DEFAULT_CHANNEL, "", this.ffgToken); + break; + } + } + } + + private void insertTrailingTokens() { + switch (this.lastPendingTokenTypeFromDefaultChannel) { + case PythonLexer.NEWLINE: + case PythonLexer.DEDENT: + break; // no trailing NEWLINE token is needed + default: + // insert an extra trailing NEWLINE token that serves as the end of the last statement + this.createAndAddPendingToken(PythonLexer.NEWLINE, Token.DEFAULT_CHANNEL, null, this.ffgToken); // ffgToken is EOF + } + this.insertIndentOrDedentToken(0); // Now insert as much trailing DEDENT tokens as needed + } + + private void handleEOFtoken() { + if (this.lastPendingTokenTypeFromDefaultChannel > 0) { + // there was statement in the input (leading NEWLINE tokens are hidden) + this.insertTrailingTokens(); + } + this.addPendingToken(this.curToken); + } + + private void hideAndAddPendingToken(final Token tkn) { + CommonToken ctkn = new CommonToken(tkn); + ctkn.setChannel(Token.HIDDEN_CHANNEL); + this.addPendingToken(ctkn); + } + + private void createAndAddPendingToken(final int ttype, final int channel, final String text, Token sampleToken) { + CommonToken ctkn = new CommonToken(sampleToken); + ctkn.setType(ttype); + ctkn.setChannel(channel); + ctkn.setStopIndex(sampleToken.getStartIndex() - 1); + ctkn.setText(text == null + ? "<" + this.getVocabulary().getDisplayName(ttype) + ">" + : text); + + this.addPendingToken(ctkn); + } + + private void addPendingToken(final Token tkn) { + // save the last pending token type because the pendingTokens linked list can be empty by the nextToken() + this.previousPendingTokenType = tkn.getType(); + if (tkn.getChannel() == Token.DEFAULT_CHANNEL) { + this.lastPendingTokenTypeFromDefaultChannel = this.previousPendingTokenType; + } + this.pendingTokens.addLast(tkn); + } + + private int getIndentationLength(final String indentText) { // the indentText may contain spaces, tabs or form feeds + final int TAB_LENGTH = 8; // the standard number of spaces to replace a tab to spaces + int length = 0; + for (char ch : indentText.toCharArray()) { + switch (ch) { + case ' ': + this.wasSpaceIndentation = true; + length += 1; + break; + case '\t': + this.wasTabIndentation = true; + length += TAB_LENGTH - (length % TAB_LENGTH); + break; + case '\f': // form feed + length = 0; + break; + } + } + + if (this.wasTabIndentation && this.wasSpaceIndentation) { + if (!(this.wasIndentationMixedWithSpacesAndTabs)) { + this.wasIndentationMixedWithSpacesAndTabs = true; + length = this.INVALID_LENGTH; // only for the first inconsistent indent + } + } + return length; + } + + private void reportLexerError(final String errMsg) { + this.getErrorListenerDispatch().syntaxError(this, this.curToken, this.curToken.getLine(), this.curToken.getCharPositionInLine(), " LEXER" + this.ERR_TXT + errMsg, null); + } + + private void reportError(final String errMsg) { + this.reportLexerError(errMsg); + + // the ERRORTOKEN will raise an error in the parser + this.createAndAddPendingToken(PythonLexer.ERRORTOKEN, Token.DEFAULT_CHANNEL, this.ERR_TXT + errMsg, this.ffgToken); + } +} diff --git a/src/main/java/PythonParser.interp b/src/main/java/PythonParser.interp new file mode 100644 index 0000000..d2b83b7 --- /dev/null +++ b/src/main/java/PythonParser.interp @@ -0,0 +1,403 @@ +token literal names: +null +null +null +null +null +null +null +'False' +'await' +'else' +'import' +'pass' +'None' +'break' +'except' +'in' +'raise' +'True' +'class' +'finally' +'is' +'return' +'and' +'continue' +'for' +'lambda' +'try' +'as' +'def' +'from' +'nonlocal' +'while' +'assert' +'del' +'global' +'not' +'with' +'async' +'elif' +'if' +'or' +'yield' +'(' +'[' +null +')' +']' +null +'.' +':' +',' +';' +'+' +'-' +'*' +'/' +'|' +'&' +'<' +'>' +'=' +'%' +'==' +'!=' +'<=' +'>=' +'~' +'^' +'<<' +'>>' +'**' +'+=' +'-=' +'*=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<=' +'>>=' +'**=' +'//' +'//=' +'@' +'@=' +'->' +'...' +':=' +'!' +null +null +null +null +null +null +null +null + +token symbolic names: +null +INDENT +DEDENT +TYPE_COMMENT +FSTRING_START +FSTRING_MIDDLE +FSTRING_END +FALSE +AWAIT +ELSE +IMPORT +PASS +NONE +BREAK +EXCEPT +IN +RAISE +TRUE +CLASS +FINALLY +IS +RETURN +AND +CONTINUE +FOR +LAMBDA +TRY +AS +DEF +FROM +NONLOCAL +WHILE +ASSERT +DEL +GLOBAL +NOT +WITH +ASYNC +ELIF +IF +OR +YIELD +LPAR +LSQB +LBRACE +RPAR +RSQB +RBRACE +DOT +COLON +COMMA +SEMI +PLUS +MINUS +STAR +SLASH +VBAR +AMPER +LESS +GREATER +EQUAL +PERCENT +EQEQUAL +NOTEQUAL +LESSEQUAL +GREATEREQUAL +TILDE +CIRCUMFLEX +LEFTSHIFT +RIGHTSHIFT +DOUBLESTAR +PLUSEQUAL +MINEQUAL +STAREQUAL +SLASHEQUAL +PERCENTEQUAL +AMPEREQUAL +VBAREQUAL +CIRCUMFLEXEQUAL +LEFTSHIFTEQUAL +RIGHTSHIFTEQUAL +DOUBLESTAREQUAL +DOUBLESLASH +DOUBLESLASHEQUAL +AT +ATEQUAL +RARROW +ELLIPSIS +COLONEQUAL +EXCLAMATION +NAME +NUMBER +STRING +NEWLINE +COMMENT +WS +EXPLICIT_LINE_JOINING +ERRORTOKEN + +rule names: +file_input +interactive +eval +func_type +fstring_input +statements +statement +statement_newline +simple_stmts +simple_stmt +compound_stmt +assignment +annotated_rhs +augassign +return_stmt +raise_stmt +global_stmt +nonlocal_stmt +del_stmt +yield_stmt +assert_stmt +import_stmt +import_name +import_from +import_from_targets +import_from_as_names +import_from_as_name +dotted_as_names +dotted_as_name +dotted_name +block +decorators +class_def +class_def_raw +function_def +function_def_raw +params +parameters +slash_no_default +slash_with_default +star_etc +kwds +param_no_default +param_no_default_star_annotation +param_with_default +param_maybe_default +param +param_star_annotation +annotation +star_annotation +default_assignment +if_stmt +elif_stmt +else_block +while_stmt +for_stmt +with_stmt +with_item +try_stmt +except_block +except_star_block +finally_block +match_stmt +subject_expr +case_block +guard +patterns +pattern +as_pattern +or_pattern +closed_pattern +literal_pattern +literal_expr +complex_number +signed_number +signed_real_number +real_number +imaginary_number +capture_pattern +pattern_capture_target +wildcard_pattern +value_pattern +attr +name_or_attr +group_pattern +sequence_pattern +open_sequence_pattern +maybe_sequence_pattern +maybe_star_pattern +star_pattern +mapping_pattern +items_pattern +key_value_pattern +double_star_pattern +class_pattern +positional_patterns +keyword_patterns +keyword_pattern +type_alias +type_params +type_param_seq +type_param +type_param_bound +expressions +expression +yield_expr +star_expressions +star_expression +star_named_expressions +star_named_expression +assignment_expression +named_expression +disjunction +conjunction +inversion +comparison +compare_op_bitwise_or_pair +eq_bitwise_or +noteq_bitwise_or +lte_bitwise_or +lt_bitwise_or +gte_bitwise_or +gt_bitwise_or +notin_bitwise_or +in_bitwise_or +isnot_bitwise_or +is_bitwise_or +bitwise_or +bitwise_xor +bitwise_and +shift_expr +sum +term +factor +power +await_primary +primary +slices +slice +atom +group +lambdef +lambda_params +lambda_parameters +lambda_slash_no_default +lambda_slash_with_default +lambda_star_etc +lambda_kwds +lambda_param_no_default +lambda_param_with_default +lambda_param_maybe_default +lambda_param +fstring_middle +fstring_replacement_field +fstring_conversion +fstring_full_format_spec +fstring_format_spec +fstring +string +strings +list +tuple +set +dict +double_starred_kvpairs +double_starred_kvpair +kvpair +for_if_clauses +for_if_clause +listcomp +setcomp +genexp +dictcomp +arguments +args +kwargs +starred_expression +kwarg_or_starred +kwarg_or_double_starred +star_targets +star_targets_list_seq +star_targets_tuple_seq +star_target +target_with_star_atom +star_atom +single_target +single_subscript_attribute_target +t_primary +del_targets +del_target +del_t_atom +type_expressions +func_type_comment +soft_kw_type +soft_kw_match +soft_kw_case +soft_kw_wildcard +soft_kw__not__wildcard + + +atn: +[4, 1, 97, 2176, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 1, 0, 3, 0, 398, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 5, 2, 406, 8, 2, 10, 2, 12, 2, 409, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 3, 3, 415, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 421, 8, 3, 10, 3, 12, 3, 424, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 4, 5, 431, 8, 5, 11, 5, 12, 5, 432, 1, 6, 1, 6, 3, 6, 437, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 445, 8, 7, 1, 8, 1, 8, 1, 8, 5, 8, 450, 8, 8, 10, 8, 12, 8, 453, 9, 8, 1, 8, 3, 8, 456, 8, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 474, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 484, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 491, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 498, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 504, 8, 11, 1, 11, 1, 11, 1, 11, 4, 11, 509, 8, 11, 11, 11, 12, 11, 510, 1, 11, 1, 11, 3, 11, 515, 8, 11, 1, 11, 3, 11, 518, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 524, 8, 11, 3, 11, 526, 8, 11, 1, 12, 1, 12, 3, 12, 530, 8, 12, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 536, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 542, 8, 15, 3, 15, 544, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 5, 16, 550, 8, 16, 10, 16, 12, 16, 553, 9, 16, 1, 17, 1, 17, 1, 17, 1, 17, 5, 17, 559, 8, 17, 10, 17, 12, 17, 562, 9, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 573, 8, 20, 1, 21, 1, 21, 3, 21, 577, 8, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 5, 23, 584, 8, 23, 10, 23, 12, 23, 587, 9, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 4, 23, 595, 8, 23, 11, 23, 12, 23, 596, 1, 23, 1, 23, 3, 23, 601, 8, 23, 1, 24, 1, 24, 1, 24, 3, 24, 606, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 612, 8, 24, 1, 25, 1, 25, 1, 25, 5, 25, 617, 8, 25, 10, 25, 12, 25, 620, 9, 25, 1, 26, 1, 26, 1, 26, 3, 26, 625, 8, 26, 1, 27, 1, 27, 1, 27, 5, 27, 630, 8, 27, 10, 27, 12, 27, 633, 9, 27, 1, 28, 1, 28, 1, 28, 3, 28, 638, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 646, 8, 29, 10, 29, 12, 29, 649, 9, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 657, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 4, 31, 663, 8, 31, 11, 31, 12, 31, 664, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 671, 8, 32, 1, 33, 1, 33, 1, 33, 3, 33, 676, 8, 33, 1, 33, 1, 33, 3, 33, 680, 8, 33, 1, 33, 3, 33, 683, 8, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 692, 8, 34, 1, 35, 1, 35, 1, 35, 3, 35, 697, 8, 35, 1, 35, 1, 35, 3, 35, 701, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 706, 8, 35, 1, 35, 1, 35, 3, 35, 710, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 717, 8, 35, 1, 35, 1, 35, 3, 35, 721, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 726, 8, 35, 1, 35, 1, 35, 3, 35, 730, 8, 35, 1, 35, 3, 35, 733, 8, 35, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 739, 8, 37, 10, 37, 12, 37, 742, 9, 37, 1, 37, 5, 37, 745, 8, 37, 10, 37, 12, 37, 748, 9, 37, 1, 37, 3, 37, 751, 8, 37, 1, 37, 1, 37, 5, 37, 755, 8, 37, 10, 37, 12, 37, 758, 9, 37, 1, 37, 3, 37, 761, 8, 37, 1, 37, 4, 37, 764, 8, 37, 11, 37, 12, 37, 765, 1, 37, 5, 37, 769, 8, 37, 10, 37, 12, 37, 772, 9, 37, 1, 37, 3, 37, 775, 8, 37, 1, 37, 4, 37, 778, 8, 37, 11, 37, 12, 37, 779, 1, 37, 3, 37, 783, 8, 37, 1, 37, 3, 37, 786, 8, 37, 1, 38, 4, 38, 789, 8, 38, 11, 38, 12, 38, 790, 1, 38, 1, 38, 3, 38, 795, 8, 38, 1, 39, 5, 39, 798, 8, 39, 10, 39, 12, 39, 801, 9, 39, 1, 39, 4, 39, 804, 8, 39, 11, 39, 12, 39, 805, 1, 39, 1, 39, 3, 39, 810, 8, 39, 1, 40, 1, 40, 1, 40, 5, 40, 815, 8, 40, 10, 40, 12, 40, 818, 9, 40, 1, 40, 3, 40, 821, 8, 40, 1, 40, 1, 40, 1, 40, 5, 40, 826, 8, 40, 10, 40, 12, 40, 829, 9, 40, 1, 40, 3, 40, 832, 8, 40, 1, 40, 1, 40, 1, 40, 4, 40, 837, 8, 40, 11, 40, 12, 40, 838, 1, 40, 3, 40, 842, 8, 40, 1, 40, 3, 40, 845, 8, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 3, 42, 852, 8, 42, 1, 42, 3, 42, 855, 8, 42, 1, 43, 1, 43, 3, 43, 859, 8, 43, 1, 43, 3, 43, 862, 8, 43, 1, 44, 1, 44, 1, 44, 3, 44, 867, 8, 44, 1, 44, 3, 44, 870, 8, 44, 1, 45, 1, 45, 3, 45, 874, 8, 45, 1, 45, 3, 45, 877, 8, 45, 1, 45, 3, 45, 880, 8, 45, 1, 46, 1, 46, 3, 46, 884, 8, 46, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 904, 8, 51, 3, 51, 906, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 914, 8, 52, 3, 52, 916, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 927, 8, 54, 1, 55, 3, 55, 930, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 938, 8, 55, 1, 55, 1, 55, 3, 55, 942, 8, 55, 1, 56, 3, 56, 945, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 952, 8, 56, 10, 56, 12, 56, 955, 9, 56, 1, 56, 3, 56, 958, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 966, 8, 56, 10, 56, 12, 56, 969, 9, 56, 1, 56, 1, 56, 3, 56, 973, 8, 56, 3, 56, 975, 8, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 3, 57, 982, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 4, 58, 993, 8, 58, 11, 58, 12, 58, 994, 1, 58, 3, 58, 998, 8, 58, 1, 58, 3, 58, 1001, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 4, 58, 1007, 8, 58, 11, 58, 12, 58, 1008, 1, 58, 3, 58, 1012, 8, 58, 1, 58, 3, 58, 1015, 8, 58, 3, 58, 1017, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1023, 8, 59, 3, 59, 1025, 8, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1035, 8, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 4, 62, 1050, 8, 62, 11, 62, 12, 62, 1051, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 3, 63, 1059, 8, 63, 1, 63, 3, 63, 1062, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1067, 8, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 3, 66, 1077, 8, 66, 1, 67, 1, 67, 3, 67, 1081, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 5, 69, 1090, 8, 69, 10, 69, 12, 69, 1093, 9, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1103, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1111, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1119, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 3, 74, 1126, 8, 74, 1, 74, 1, 74, 1, 75, 3, 75, 1131, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 4, 82, 1150, 8, 82, 11, 82, 12, 82, 1151, 1, 83, 1, 83, 1, 83, 5, 83, 1157, 8, 83, 10, 83, 12, 83, 1160, 9, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 3, 85, 1168, 8, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1173, 8, 85, 1, 85, 3, 85, 1176, 8, 85, 1, 86, 1, 86, 1, 86, 3, 86, 1181, 8, 86, 1, 87, 1, 87, 1, 87, 5, 87, 1186, 8, 87, 10, 87, 12, 87, 1189, 9, 87, 1, 87, 3, 87, 1192, 8, 87, 1, 88, 1, 88, 3, 88, 1196, 8, 88, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1206, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1214, 8, 90, 1, 90, 3, 90, 1217, 8, 90, 1, 90, 1, 90, 3, 90, 1221, 8, 90, 1, 91, 1, 91, 1, 91, 5, 91, 1226, 8, 91, 10, 91, 12, 91, 1229, 9, 91, 1, 92, 1, 92, 3, 92, 1233, 8, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 1246, 8, 94, 1, 94, 3, 94, 1249, 8, 94, 1, 94, 3, 94, 1252, 8, 94, 3, 94, 1254, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1261, 8, 95, 10, 95, 12, 95, 1264, 9, 95, 1, 96, 1, 96, 1, 96, 5, 96, 1269, 8, 96, 10, 96, 12, 96, 1272, 9, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 3, 98, 1281, 8, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 5, 100, 1293, 8, 100, 10, 100, 12, 100, 1296, 9, 100, 1, 100, 3, 100, 1299, 8, 100, 1, 101, 1, 101, 3, 101, 1303, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1309, 8, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 5, 103, 1317, 8, 103, 10, 103, 12, 103, 1320, 9, 103, 1, 103, 3, 103, 1323, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1331, 8, 104, 1, 104, 3, 104, 1334, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1340, 8, 105, 3, 105, 1342, 8, 105, 1, 106, 1, 106, 1, 106, 5, 106, 1347, 8, 106, 10, 106, 12, 106, 1350, 9, 106, 1, 106, 3, 106, 1353, 8, 106, 1, 107, 1, 107, 1, 107, 3, 107, 1358, 8, 107, 1, 108, 1, 108, 1, 108, 5, 108, 1363, 8, 108, 10, 108, 12, 108, 1366, 9, 108, 1, 108, 3, 108, 1369, 8, 108, 1, 109, 1, 109, 1, 109, 3, 109, 1374, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 3, 111, 1382, 8, 111, 1, 112, 1, 112, 1, 112, 5, 112, 1387, 8, 112, 10, 112, 12, 112, 1390, 9, 112, 1, 113, 1, 113, 1, 113, 5, 113, 1395, 8, 113, 10, 113, 12, 113, 1398, 9, 113, 1, 114, 1, 114, 1, 114, 3, 114, 1403, 8, 114, 1, 115, 1, 115, 5, 115, 1407, 8, 115, 10, 115, 12, 115, 1410, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1422, 8, 116, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 5, 127, 1462, 8, 127, 10, 127, 12, 127, 1465, 9, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 1473, 8, 128, 10, 128, 12, 128, 1476, 9, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1484, 8, 129, 10, 129, 12, 129, 1487, 9, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 1495, 8, 130, 10, 130, 12, 130, 1498, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1506, 8, 131, 10, 131, 12, 131, 1509, 9, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1517, 8, 132, 10, 132, 12, 132, 1520, 9, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1529, 8, 133, 1, 134, 1, 134, 1, 134, 3, 134, 1534, 8, 134, 1, 135, 1, 135, 1, 135, 3, 135, 1539, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1550, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1557, 8, 136, 5, 136, 1559, 8, 136, 10, 136, 12, 136, 1562, 9, 136, 1, 137, 1, 137, 1, 137, 3, 137, 1567, 8, 137, 1, 137, 1, 137, 1, 137, 3, 137, 1572, 8, 137, 5, 137, 1574, 8, 137, 10, 137, 12, 137, 1577, 9, 137, 1, 137, 3, 137, 1580, 8, 137, 3, 137, 1582, 8, 137, 1, 138, 3, 138, 1585, 8, 138, 1, 138, 1, 138, 3, 138, 1589, 8, 138, 1, 138, 1, 138, 3, 138, 1593, 8, 138, 3, 138, 1595, 8, 138, 1, 138, 3, 138, 1598, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 1609, 8, 139, 1, 139, 1, 139, 3, 139, 1613, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 1619, 8, 139, 1, 139, 3, 139, 1622, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 1627, 8, 140, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 1633, 8, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 5, 143, 1642, 8, 143, 10, 143, 12, 143, 1645, 9, 143, 1, 143, 5, 143, 1648, 8, 143, 10, 143, 12, 143, 1651, 9, 143, 1, 143, 3, 143, 1654, 8, 143, 1, 143, 1, 143, 5, 143, 1658, 8, 143, 10, 143, 12, 143, 1661, 9, 143, 1, 143, 3, 143, 1664, 8, 143, 1, 143, 4, 143, 1667, 8, 143, 11, 143, 12, 143, 1668, 1, 143, 5, 143, 1672, 8, 143, 10, 143, 12, 143, 1675, 9, 143, 1, 143, 3, 143, 1678, 8, 143, 1, 143, 4, 143, 1681, 8, 143, 11, 143, 12, 143, 1682, 1, 143, 3, 143, 1686, 8, 143, 1, 143, 3, 143, 1689, 8, 143, 1, 144, 4, 144, 1692, 8, 144, 11, 144, 12, 144, 1693, 1, 144, 1, 144, 3, 144, 1698, 8, 144, 1, 145, 5, 145, 1701, 8, 145, 10, 145, 12, 145, 1704, 9, 145, 1, 145, 4, 145, 1707, 8, 145, 11, 145, 12, 145, 1708, 1, 145, 1, 145, 3, 145, 1713, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 1718, 8, 146, 10, 146, 12, 146, 1721, 9, 146, 1, 146, 3, 146, 1724, 8, 146, 1, 146, 1, 146, 1, 146, 4, 146, 1729, 8, 146, 11, 146, 12, 146, 1730, 1, 146, 3, 146, 1734, 8, 146, 1, 146, 3, 146, 1737, 8, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 3, 148, 1744, 8, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1749, 8, 149, 1, 150, 1, 150, 3, 150, 1753, 8, 150, 1, 150, 3, 150, 1756, 8, 150, 1, 151, 1, 151, 1, 152, 1, 152, 3, 152, 1762, 8, 152, 1, 153, 1, 153, 1, 153, 3, 153, 1767, 8, 153, 1, 153, 3, 153, 1770, 8, 153, 1, 153, 3, 153, 1773, 8, 153, 1, 153, 3, 153, 1776, 8, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 5, 155, 1785, 8, 155, 10, 155, 12, 155, 1788, 9, 155, 1, 156, 1, 156, 3, 156, 1792, 8, 156, 1, 157, 1, 157, 5, 157, 1796, 8, 157, 10, 157, 12, 157, 1799, 9, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 4, 159, 1807, 8, 159, 11, 159, 12, 159, 1808, 1, 160, 1, 160, 3, 160, 1813, 8, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 1821, 8, 161, 3, 161, 1823, 8, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 3, 163, 1833, 8, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 5, 164, 1840, 8, 164, 10, 164, 12, 164, 1843, 9, 164, 1, 164, 3, 164, 1846, 8, 164, 1, 165, 1, 165, 1, 165, 3, 165, 1851, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 4, 167, 1858, 8, 167, 11, 167, 12, 167, 1859, 1, 168, 3, 168, 1863, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 5, 168, 1871, 8, 168, 10, 168, 12, 168, 1874, 9, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 3, 171, 1889, 8, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 3, 173, 1901, 8, 173, 1, 174, 1, 174, 1, 174, 3, 174, 1906, 8, 174, 3, 174, 1908, 8, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 1914, 8, 174, 3, 174, 1916, 8, 174, 5, 174, 1918, 8, 174, 10, 174, 12, 174, 1921, 9, 174, 1, 174, 1, 174, 3, 174, 1925, 8, 174, 1, 174, 3, 174, 1928, 8, 174, 1, 175, 1, 175, 1, 175, 5, 175, 1933, 8, 175, 10, 175, 12, 175, 1936, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 5, 175, 1942, 8, 175, 10, 175, 12, 175, 1945, 9, 175, 3, 175, 1947, 8, 175, 1, 175, 1, 175, 1, 175, 5, 175, 1952, 8, 175, 10, 175, 12, 175, 1955, 9, 175, 3, 175, 1957, 8, 175, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 1966, 8, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 1973, 8, 178, 1, 179, 1, 179, 1, 179, 5, 179, 1978, 8, 179, 10, 179, 12, 179, 1981, 9, 179, 1, 179, 3, 179, 1984, 8, 179, 1, 180, 1, 180, 1, 180, 4, 180, 1989, 8, 180, 11, 180, 12, 180, 1990, 1, 180, 3, 180, 1994, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 4, 181, 2000, 8, 181, 11, 181, 12, 181, 2001, 1, 181, 3, 181, 2005, 8, 181, 3, 181, 2007, 8, 181, 1, 182, 1, 182, 1, 182, 3, 182, 2012, 8, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 2021, 8, 183, 1, 183, 3, 183, 2024, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2033, 8, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2038, 8, 184, 1, 184, 3, 184, 2041, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 3, 185, 2049, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 2058, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2073, 8, 187, 1, 187, 3, 187, 2076, 8, 187, 5, 187, 2078, 8, 187, 10, 187, 12, 187, 2081, 9, 187, 1, 188, 1, 188, 1, 188, 5, 188, 2086, 8, 188, 10, 188, 12, 188, 2089, 9, 188, 1, 188, 3, 188, 2092, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 2101, 8, 189, 1, 189, 3, 189, 2104, 8, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 2113, 8, 190, 1, 190, 1, 190, 1, 190, 3, 190, 2118, 8, 190, 1, 190, 3, 190, 2121, 8, 190, 1, 191, 1, 191, 1, 191, 5, 191, 2126, 8, 191, 10, 191, 12, 191, 2129, 9, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 2137, 8, 191, 1, 191, 1, 191, 3, 191, 2141, 8, 191, 3, 191, 2143, 8, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 2150, 8, 191, 1, 191, 1, 191, 3, 191, 2154, 8, 191, 1, 192, 1, 192, 1, 192, 3, 192, 2159, 8, 192, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 0, 9, 58, 254, 256, 258, 260, 262, 264, 272, 374, 198, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 0, 5, 3, 0, 71, 81, 83, 83, 85, 85, 2, 0, 48, 48, 87, 87, 1, 0, 52, 53, 1, 0, 68, 69, 4, 0, 54, 55, 61, 61, 82, 82, 84, 84, 2345, 0, 397, 1, 0, 0, 0, 2, 401, 1, 0, 0, 0, 4, 403, 1, 0, 0, 0, 6, 412, 1, 0, 0, 0, 8, 427, 1, 0, 0, 0, 10, 430, 1, 0, 0, 0, 12, 436, 1, 0, 0, 0, 14, 444, 1, 0, 0, 0, 16, 446, 1, 0, 0, 0, 18, 473, 1, 0, 0, 0, 20, 483, 1, 0, 0, 0, 22, 525, 1, 0, 0, 0, 24, 529, 1, 0, 0, 0, 26, 531, 1, 0, 0, 0, 28, 533, 1, 0, 0, 0, 30, 537, 1, 0, 0, 0, 32, 545, 1, 0, 0, 0, 34, 554, 1, 0, 0, 0, 36, 563, 1, 0, 0, 0, 38, 566, 1, 0, 0, 0, 40, 568, 1, 0, 0, 0, 42, 576, 1, 0, 0, 0, 44, 578, 1, 0, 0, 0, 46, 600, 1, 0, 0, 0, 48, 611, 1, 0, 0, 0, 50, 613, 1, 0, 0, 0, 52, 621, 1, 0, 0, 0, 54, 626, 1, 0, 0, 0, 56, 634, 1, 0, 0, 0, 58, 639, 1, 0, 0, 0, 60, 656, 1, 0, 0, 0, 62, 662, 1, 0, 0, 0, 64, 670, 1, 0, 0, 0, 66, 672, 1, 0, 0, 0, 68, 691, 1, 0, 0, 0, 70, 732, 1, 0, 0, 0, 72, 734, 1, 0, 0, 0, 74, 785, 1, 0, 0, 0, 76, 788, 1, 0, 0, 0, 78, 799, 1, 0, 0, 0, 80, 844, 1, 0, 0, 0, 82, 846, 1, 0, 0, 0, 84, 849, 1, 0, 0, 0, 86, 856, 1, 0, 0, 0, 88, 863, 1, 0, 0, 0, 90, 871, 1, 0, 0, 0, 92, 881, 1, 0, 0, 0, 94, 885, 1, 0, 0, 0, 96, 888, 1, 0, 0, 0, 98, 891, 1, 0, 0, 0, 100, 894, 1, 0, 0, 0, 102, 897, 1, 0, 0, 0, 104, 907, 1, 0, 0, 0, 106, 917, 1, 0, 0, 0, 108, 921, 1, 0, 0, 0, 110, 929, 1, 0, 0, 0, 112, 944, 1, 0, 0, 0, 114, 978, 1, 0, 0, 0, 116, 1016, 1, 0, 0, 0, 118, 1018, 1, 0, 0, 0, 120, 1029, 1, 0, 0, 0, 122, 1039, 1, 0, 0, 0, 124, 1043, 1, 0, 0, 0, 126, 1061, 1, 0, 0, 0, 128, 1063, 1, 0, 0, 0, 130, 1071, 1, 0, 0, 0, 132, 1076, 1, 0, 0, 0, 134, 1080, 1, 0, 0, 0, 136, 1082, 1, 0, 0, 0, 138, 1086, 1, 0, 0, 0, 140, 1102, 1, 0, 0, 0, 142, 1110, 1, 0, 0, 0, 144, 1118, 1, 0, 0, 0, 146, 1120, 1, 0, 0, 0, 148, 1125, 1, 0, 0, 0, 150, 1130, 1, 0, 0, 0, 152, 1134, 1, 0, 0, 0, 154, 1136, 1, 0, 0, 0, 156, 1138, 1, 0, 0, 0, 158, 1140, 1, 0, 0, 0, 160, 1142, 1, 0, 0, 0, 162, 1144, 1, 0, 0, 0, 164, 1146, 1, 0, 0, 0, 166, 1153, 1, 0, 0, 0, 168, 1161, 1, 0, 0, 0, 170, 1175, 1, 0, 0, 0, 172, 1177, 1, 0, 0, 0, 174, 1182, 1, 0, 0, 0, 176, 1195, 1, 0, 0, 0, 178, 1197, 1, 0, 0, 0, 180, 1220, 1, 0, 0, 0, 182, 1222, 1, 0, 0, 0, 184, 1232, 1, 0, 0, 0, 186, 1237, 1, 0, 0, 0, 188, 1240, 1, 0, 0, 0, 190, 1257, 1, 0, 0, 0, 192, 1265, 1, 0, 0, 0, 194, 1273, 1, 0, 0, 0, 196, 1277, 1, 0, 0, 0, 198, 1285, 1, 0, 0, 0, 200, 1289, 1, 0, 0, 0, 202, 1308, 1, 0, 0, 0, 204, 1310, 1, 0, 0, 0, 206, 1313, 1, 0, 0, 0, 208, 1333, 1, 0, 0, 0, 210, 1335, 1, 0, 0, 0, 212, 1343, 1, 0, 0, 0, 214, 1357, 1, 0, 0, 0, 216, 1359, 1, 0, 0, 0, 218, 1373, 1, 0, 0, 0, 220, 1375, 1, 0, 0, 0, 222, 1381, 1, 0, 0, 0, 224, 1383, 1, 0, 0, 0, 226, 1391, 1, 0, 0, 0, 228, 1402, 1, 0, 0, 0, 230, 1404, 1, 0, 0, 0, 232, 1421, 1, 0, 0, 0, 234, 1423, 1, 0, 0, 0, 236, 1426, 1, 0, 0, 0, 238, 1429, 1, 0, 0, 0, 240, 1432, 1, 0, 0, 0, 242, 1435, 1, 0, 0, 0, 244, 1438, 1, 0, 0, 0, 246, 1441, 1, 0, 0, 0, 248, 1445, 1, 0, 0, 0, 250, 1448, 1, 0, 0, 0, 252, 1452, 1, 0, 0, 0, 254, 1455, 1, 0, 0, 0, 256, 1466, 1, 0, 0, 0, 258, 1477, 1, 0, 0, 0, 260, 1488, 1, 0, 0, 0, 262, 1499, 1, 0, 0, 0, 264, 1510, 1, 0, 0, 0, 266, 1528, 1, 0, 0, 0, 268, 1530, 1, 0, 0, 0, 270, 1538, 1, 0, 0, 0, 272, 1540, 1, 0, 0, 0, 274, 1581, 1, 0, 0, 0, 276, 1597, 1, 0, 0, 0, 278, 1621, 1, 0, 0, 0, 280, 1623, 1, 0, 0, 0, 282, 1630, 1, 0, 0, 0, 284, 1637, 1, 0, 0, 0, 286, 1688, 1, 0, 0, 0, 288, 1691, 1, 0, 0, 0, 290, 1702, 1, 0, 0, 0, 292, 1736, 1, 0, 0, 0, 294, 1738, 1, 0, 0, 0, 296, 1741, 1, 0, 0, 0, 298, 1745, 1, 0, 0, 0, 300, 1750, 1, 0, 0, 0, 302, 1757, 1, 0, 0, 0, 304, 1761, 1, 0, 0, 0, 306, 1763, 1, 0, 0, 0, 308, 1779, 1, 0, 0, 0, 310, 1782, 1, 0, 0, 0, 312, 1791, 1, 0, 0, 0, 314, 1793, 1, 0, 0, 0, 316, 1802, 1, 0, 0, 0, 318, 1806, 1, 0, 0, 0, 320, 1810, 1, 0, 0, 0, 322, 1816, 1, 0, 0, 0, 324, 1826, 1, 0, 0, 0, 326, 1830, 1, 0, 0, 0, 328, 1836, 1, 0, 0, 0, 330, 1850, 1, 0, 0, 0, 332, 1852, 1, 0, 0, 0, 334, 1857, 1, 0, 0, 0, 336, 1862, 1, 0, 0, 0, 338, 1875, 1, 0, 0, 0, 340, 1880, 1, 0, 0, 0, 342, 1885, 1, 0, 0, 0, 344, 1893, 1, 0, 0, 0, 346, 1898, 1, 0, 0, 0, 348, 1927, 1, 0, 0, 0, 350, 1956, 1, 0, 0, 0, 352, 1958, 1, 0, 0, 0, 354, 1965, 1, 0, 0, 0, 356, 1972, 1, 0, 0, 0, 358, 1974, 1, 0, 0, 0, 360, 1985, 1, 0, 0, 0, 362, 1995, 1, 0, 0, 0, 364, 2011, 1, 0, 0, 0, 366, 2023, 1, 0, 0, 0, 368, 2040, 1, 0, 0, 0, 370, 2048, 1, 0, 0, 0, 372, 2050, 1, 0, 0, 0, 374, 2059, 1, 0, 0, 0, 376, 2082, 1, 0, 0, 0, 378, 2103, 1, 0, 0, 0, 380, 2120, 1, 0, 0, 0, 382, 2153, 1, 0, 0, 0, 384, 2158, 1, 0, 0, 0, 386, 2160, 1, 0, 0, 0, 388, 2163, 1, 0, 0, 0, 390, 2166, 1, 0, 0, 0, 392, 2169, 1, 0, 0, 0, 394, 2172, 1, 0, 0, 0, 396, 398, 3, 10, 5, 0, 397, 396, 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 399, 1, 0, 0, 0, 399, 400, 5, 0, 0, 1, 400, 1, 1, 0, 0, 0, 401, 402, 3, 14, 7, 0, 402, 3, 1, 0, 0, 0, 403, 407, 3, 206, 103, 0, 404, 406, 5, 93, 0, 0, 405, 404, 1, 0, 0, 0, 406, 409, 1, 0, 0, 0, 407, 405, 1, 0, 0, 0, 407, 408, 1, 0, 0, 0, 408, 410, 1, 0, 0, 0, 409, 407, 1, 0, 0, 0, 410, 411, 5, 0, 0, 1, 411, 5, 1, 0, 0, 0, 412, 414, 5, 42, 0, 0, 413, 415, 3, 382, 191, 0, 414, 413, 1, 0, 0, 0, 414, 415, 1, 0, 0, 0, 415, 416, 1, 0, 0, 0, 416, 417, 5, 45, 0, 0, 417, 418, 5, 86, 0, 0, 418, 422, 3, 208, 104, 0, 419, 421, 5, 93, 0, 0, 420, 419, 1, 0, 0, 0, 421, 424, 1, 0, 0, 0, 422, 420, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 425, 1, 0, 0, 0, 424, 422, 1, 0, 0, 0, 425, 426, 5, 0, 0, 1, 426, 7, 1, 0, 0, 0, 427, 428, 3, 212, 106, 0, 428, 9, 1, 0, 0, 0, 429, 431, 3, 12, 6, 0, 430, 429, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 11, 1, 0, 0, 0, 434, 437, 3, 20, 10, 0, 435, 437, 3, 16, 8, 0, 436, 434, 1, 0, 0, 0, 436, 435, 1, 0, 0, 0, 437, 13, 1, 0, 0, 0, 438, 439, 3, 20, 10, 0, 439, 440, 5, 93, 0, 0, 440, 445, 1, 0, 0, 0, 441, 445, 3, 16, 8, 0, 442, 445, 5, 93, 0, 0, 443, 445, 5, 0, 0, 1, 444, 438, 1, 0, 0, 0, 444, 441, 1, 0, 0, 0, 444, 442, 1, 0, 0, 0, 444, 443, 1, 0, 0, 0, 445, 15, 1, 0, 0, 0, 446, 451, 3, 18, 9, 0, 447, 448, 5, 51, 0, 0, 448, 450, 3, 18, 9, 0, 449, 447, 1, 0, 0, 0, 450, 453, 1, 0, 0, 0, 451, 449, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 455, 1, 0, 0, 0, 453, 451, 1, 0, 0, 0, 454, 456, 5, 51, 0, 0, 455, 454, 1, 0, 0, 0, 455, 456, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 458, 5, 93, 0, 0, 458, 17, 1, 0, 0, 0, 459, 474, 3, 22, 11, 0, 460, 474, 3, 196, 98, 0, 461, 474, 3, 212, 106, 0, 462, 474, 3, 28, 14, 0, 463, 474, 3, 42, 21, 0, 464, 474, 3, 30, 15, 0, 465, 474, 5, 11, 0, 0, 466, 474, 3, 36, 18, 0, 467, 474, 3, 38, 19, 0, 468, 474, 3, 40, 20, 0, 469, 474, 5, 13, 0, 0, 470, 474, 5, 23, 0, 0, 471, 474, 3, 32, 16, 0, 472, 474, 3, 34, 17, 0, 473, 459, 1, 0, 0, 0, 473, 460, 1, 0, 0, 0, 473, 461, 1, 0, 0, 0, 473, 462, 1, 0, 0, 0, 473, 463, 1, 0, 0, 0, 473, 464, 1, 0, 0, 0, 473, 465, 1, 0, 0, 0, 473, 466, 1, 0, 0, 0, 473, 467, 1, 0, 0, 0, 473, 468, 1, 0, 0, 0, 473, 469, 1, 0, 0, 0, 473, 470, 1, 0, 0, 0, 473, 471, 1, 0, 0, 0, 473, 472, 1, 0, 0, 0, 474, 19, 1, 0, 0, 0, 475, 484, 3, 68, 34, 0, 476, 484, 3, 102, 51, 0, 477, 484, 3, 64, 32, 0, 478, 484, 3, 112, 56, 0, 479, 484, 3, 110, 55, 0, 480, 484, 3, 116, 58, 0, 481, 484, 3, 108, 54, 0, 482, 484, 3, 124, 62, 0, 483, 475, 1, 0, 0, 0, 483, 476, 1, 0, 0, 0, 483, 477, 1, 0, 0, 0, 483, 478, 1, 0, 0, 0, 483, 479, 1, 0, 0, 0, 483, 480, 1, 0, 0, 0, 483, 481, 1, 0, 0, 0, 483, 482, 1, 0, 0, 0, 484, 21, 1, 0, 0, 0, 485, 486, 5, 90, 0, 0, 486, 487, 5, 49, 0, 0, 487, 490, 3, 208, 104, 0, 488, 489, 5, 60, 0, 0, 489, 491, 3, 24, 12, 0, 490, 488, 1, 0, 0, 0, 490, 491, 1, 0, 0, 0, 491, 526, 1, 0, 0, 0, 492, 493, 5, 42, 0, 0, 493, 494, 3, 370, 185, 0, 494, 495, 5, 45, 0, 0, 495, 498, 1, 0, 0, 0, 496, 498, 3, 372, 186, 0, 497, 492, 1, 0, 0, 0, 497, 496, 1, 0, 0, 0, 498, 499, 1, 0, 0, 0, 499, 500, 5, 49, 0, 0, 500, 503, 3, 208, 104, 0, 501, 502, 5, 60, 0, 0, 502, 504, 3, 24, 12, 0, 503, 501, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 526, 1, 0, 0, 0, 505, 506, 3, 358, 179, 0, 506, 507, 5, 60, 0, 0, 507, 509, 1, 0, 0, 0, 508, 505, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 508, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 514, 1, 0, 0, 0, 512, 515, 3, 210, 105, 0, 513, 515, 3, 212, 106, 0, 514, 512, 1, 0, 0, 0, 514, 513, 1, 0, 0, 0, 515, 517, 1, 0, 0, 0, 516, 518, 5, 3, 0, 0, 517, 516, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 526, 1, 0, 0, 0, 519, 520, 3, 370, 185, 0, 520, 523, 3, 26, 13, 0, 521, 524, 3, 210, 105, 0, 522, 524, 3, 212, 106, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 526, 1, 0, 0, 0, 525, 485, 1, 0, 0, 0, 525, 497, 1, 0, 0, 0, 525, 508, 1, 0, 0, 0, 525, 519, 1, 0, 0, 0, 526, 23, 1, 0, 0, 0, 527, 530, 3, 210, 105, 0, 528, 530, 3, 212, 106, 0, 529, 527, 1, 0, 0, 0, 529, 528, 1, 0, 0, 0, 530, 25, 1, 0, 0, 0, 531, 532, 7, 0, 0, 0, 532, 27, 1, 0, 0, 0, 533, 535, 5, 21, 0, 0, 534, 536, 3, 212, 106, 0, 535, 534, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 29, 1, 0, 0, 0, 537, 543, 5, 16, 0, 0, 538, 541, 3, 208, 104, 0, 539, 540, 5, 29, 0, 0, 540, 542, 3, 208, 104, 0, 541, 539, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 544, 1, 0, 0, 0, 543, 538, 1, 0, 0, 0, 543, 544, 1, 0, 0, 0, 544, 31, 1, 0, 0, 0, 545, 546, 5, 34, 0, 0, 546, 551, 5, 90, 0, 0, 547, 548, 5, 50, 0, 0, 548, 550, 5, 90, 0, 0, 549, 547, 1, 0, 0, 0, 550, 553, 1, 0, 0, 0, 551, 549, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 33, 1, 0, 0, 0, 553, 551, 1, 0, 0, 0, 554, 555, 5, 30, 0, 0, 555, 560, 5, 90, 0, 0, 556, 557, 5, 50, 0, 0, 557, 559, 5, 90, 0, 0, 558, 556, 1, 0, 0, 0, 559, 562, 1, 0, 0, 0, 560, 558, 1, 0, 0, 0, 560, 561, 1, 0, 0, 0, 561, 35, 1, 0, 0, 0, 562, 560, 1, 0, 0, 0, 563, 564, 5, 33, 0, 0, 564, 565, 3, 376, 188, 0, 565, 37, 1, 0, 0, 0, 566, 567, 3, 210, 105, 0, 567, 39, 1, 0, 0, 0, 568, 569, 5, 32, 0, 0, 569, 572, 3, 208, 104, 0, 570, 571, 5, 50, 0, 0, 571, 573, 3, 208, 104, 0, 572, 570, 1, 0, 0, 0, 572, 573, 1, 0, 0, 0, 573, 41, 1, 0, 0, 0, 574, 577, 3, 44, 22, 0, 575, 577, 3, 46, 23, 0, 576, 574, 1, 0, 0, 0, 576, 575, 1, 0, 0, 0, 577, 43, 1, 0, 0, 0, 578, 579, 5, 10, 0, 0, 579, 580, 3, 54, 27, 0, 580, 45, 1, 0, 0, 0, 581, 585, 5, 29, 0, 0, 582, 584, 7, 1, 0, 0, 583, 582, 1, 0, 0, 0, 584, 587, 1, 0, 0, 0, 585, 583, 1, 0, 0, 0, 585, 586, 1, 0, 0, 0, 586, 588, 1, 0, 0, 0, 587, 585, 1, 0, 0, 0, 588, 589, 3, 58, 29, 0, 589, 590, 5, 10, 0, 0, 590, 591, 3, 48, 24, 0, 591, 601, 1, 0, 0, 0, 592, 594, 5, 29, 0, 0, 593, 595, 7, 1, 0, 0, 594, 593, 1, 0, 0, 0, 595, 596, 1, 0, 0, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 5, 10, 0, 0, 599, 601, 3, 48, 24, 0, 600, 581, 1, 0, 0, 0, 600, 592, 1, 0, 0, 0, 601, 47, 1, 0, 0, 0, 602, 603, 5, 42, 0, 0, 603, 605, 3, 50, 25, 0, 604, 606, 5, 50, 0, 0, 605, 604, 1, 0, 0, 0, 605, 606, 1, 0, 0, 0, 606, 607, 1, 0, 0, 0, 607, 608, 5, 45, 0, 0, 608, 612, 1, 0, 0, 0, 609, 612, 3, 50, 25, 0, 610, 612, 5, 54, 0, 0, 611, 602, 1, 0, 0, 0, 611, 609, 1, 0, 0, 0, 611, 610, 1, 0, 0, 0, 612, 49, 1, 0, 0, 0, 613, 618, 3, 52, 26, 0, 614, 615, 5, 50, 0, 0, 615, 617, 3, 52, 26, 0, 616, 614, 1, 0, 0, 0, 617, 620, 1, 0, 0, 0, 618, 616, 1, 0, 0, 0, 618, 619, 1, 0, 0, 0, 619, 51, 1, 0, 0, 0, 620, 618, 1, 0, 0, 0, 621, 624, 5, 90, 0, 0, 622, 623, 5, 27, 0, 0, 623, 625, 5, 90, 0, 0, 624, 622, 1, 0, 0, 0, 624, 625, 1, 0, 0, 0, 625, 53, 1, 0, 0, 0, 626, 631, 3, 56, 28, 0, 627, 628, 5, 50, 0, 0, 628, 630, 3, 56, 28, 0, 629, 627, 1, 0, 0, 0, 630, 633, 1, 0, 0, 0, 631, 629, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 55, 1, 0, 0, 0, 633, 631, 1, 0, 0, 0, 634, 637, 3, 58, 29, 0, 635, 636, 5, 27, 0, 0, 636, 638, 5, 90, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 57, 1, 0, 0, 0, 639, 640, 6, 29, -1, 0, 640, 641, 5, 90, 0, 0, 641, 647, 1, 0, 0, 0, 642, 643, 10, 2, 0, 0, 643, 644, 5, 48, 0, 0, 644, 646, 5, 90, 0, 0, 645, 642, 1, 0, 0, 0, 646, 649, 1, 0, 0, 0, 647, 645, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 59, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 650, 651, 5, 93, 0, 0, 651, 652, 5, 1, 0, 0, 652, 653, 3, 10, 5, 0, 653, 654, 5, 2, 0, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 16, 8, 0, 656, 650, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 61, 1, 0, 0, 0, 658, 659, 5, 84, 0, 0, 659, 660, 3, 222, 111, 0, 660, 661, 5, 93, 0, 0, 661, 663, 1, 0, 0, 0, 662, 658, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 662, 1, 0, 0, 0, 664, 665, 1, 0, 0, 0, 665, 63, 1, 0, 0, 0, 666, 667, 3, 62, 31, 0, 667, 668, 3, 66, 33, 0, 668, 671, 1, 0, 0, 0, 669, 671, 3, 66, 33, 0, 670, 666, 1, 0, 0, 0, 670, 669, 1, 0, 0, 0, 671, 65, 1, 0, 0, 0, 672, 673, 5, 18, 0, 0, 673, 675, 5, 90, 0, 0, 674, 676, 3, 198, 99, 0, 675, 674, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 682, 1, 0, 0, 0, 677, 679, 5, 42, 0, 0, 678, 680, 3, 346, 173, 0, 679, 678, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 681, 1, 0, 0, 0, 681, 683, 5, 45, 0, 0, 682, 677, 1, 0, 0, 0, 682, 683, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 685, 5, 49, 0, 0, 685, 686, 3, 60, 30, 0, 686, 67, 1, 0, 0, 0, 687, 688, 3, 62, 31, 0, 688, 689, 3, 70, 35, 0, 689, 692, 1, 0, 0, 0, 690, 692, 3, 70, 35, 0, 691, 687, 1, 0, 0, 0, 691, 690, 1, 0, 0, 0, 692, 69, 1, 0, 0, 0, 693, 694, 5, 28, 0, 0, 694, 696, 5, 90, 0, 0, 695, 697, 3, 198, 99, 0, 696, 695, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 700, 5, 42, 0, 0, 699, 701, 3, 72, 36, 0, 700, 699, 1, 0, 0, 0, 700, 701, 1, 0, 0, 0, 701, 702, 1, 0, 0, 0, 702, 705, 5, 45, 0, 0, 703, 704, 5, 86, 0, 0, 704, 706, 3, 208, 104, 0, 705, 703, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 709, 5, 49, 0, 0, 708, 710, 3, 384, 192, 0, 709, 708, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 733, 3, 60, 30, 0, 712, 713, 5, 37, 0, 0, 713, 714, 5, 28, 0, 0, 714, 716, 5, 90, 0, 0, 715, 717, 3, 198, 99, 0, 716, 715, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 718, 1, 0, 0, 0, 718, 720, 5, 42, 0, 0, 719, 721, 3, 72, 36, 0, 720, 719, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 722, 1, 0, 0, 0, 722, 725, 5, 45, 0, 0, 723, 724, 5, 86, 0, 0, 724, 726, 3, 208, 104, 0, 725, 723, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 729, 5, 49, 0, 0, 728, 730, 3, 384, 192, 0, 729, 728, 1, 0, 0, 0, 729, 730, 1, 0, 0, 0, 730, 731, 1, 0, 0, 0, 731, 733, 3, 60, 30, 0, 732, 693, 1, 0, 0, 0, 732, 712, 1, 0, 0, 0, 733, 71, 1, 0, 0, 0, 734, 735, 3, 74, 37, 0, 735, 73, 1, 0, 0, 0, 736, 740, 3, 76, 38, 0, 737, 739, 3, 84, 42, 0, 738, 737, 1, 0, 0, 0, 739, 742, 1, 0, 0, 0, 740, 738, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 746, 1, 0, 0, 0, 742, 740, 1, 0, 0, 0, 743, 745, 3, 88, 44, 0, 744, 743, 1, 0, 0, 0, 745, 748, 1, 0, 0, 0, 746, 744, 1, 0, 0, 0, 746, 747, 1, 0, 0, 0, 747, 750, 1, 0, 0, 0, 748, 746, 1, 0, 0, 0, 749, 751, 3, 80, 40, 0, 750, 749, 1, 0, 0, 0, 750, 751, 1, 0, 0, 0, 751, 786, 1, 0, 0, 0, 752, 756, 3, 78, 39, 0, 753, 755, 3, 88, 44, 0, 754, 753, 1, 0, 0, 0, 755, 758, 1, 0, 0, 0, 756, 754, 1, 0, 0, 0, 756, 757, 1, 0, 0, 0, 757, 760, 1, 0, 0, 0, 758, 756, 1, 0, 0, 0, 759, 761, 3, 80, 40, 0, 760, 759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 786, 1, 0, 0, 0, 762, 764, 3, 84, 42, 0, 763, 762, 1, 0, 0, 0, 764, 765, 1, 0, 0, 0, 765, 763, 1, 0, 0, 0, 765, 766, 1, 0, 0, 0, 766, 770, 1, 0, 0, 0, 767, 769, 3, 88, 44, 0, 768, 767, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 774, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 775, 3, 80, 40, 0, 774, 773, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 786, 1, 0, 0, 0, 776, 778, 3, 88, 44, 0, 777, 776, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, 777, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 782, 1, 0, 0, 0, 781, 783, 3, 80, 40, 0, 782, 781, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 786, 1, 0, 0, 0, 784, 786, 3, 80, 40, 0, 785, 736, 1, 0, 0, 0, 785, 752, 1, 0, 0, 0, 785, 763, 1, 0, 0, 0, 785, 777, 1, 0, 0, 0, 785, 784, 1, 0, 0, 0, 786, 75, 1, 0, 0, 0, 787, 789, 3, 84, 42, 0, 788, 787, 1, 0, 0, 0, 789, 790, 1, 0, 0, 0, 790, 788, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 5, 55, 0, 0, 793, 795, 5, 50, 0, 0, 794, 793, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 77, 1, 0, 0, 0, 796, 798, 3, 84, 42, 0, 797, 796, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 803, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 804, 3, 88, 44, 0, 803, 802, 1, 0, 0, 0, 804, 805, 1, 0, 0, 0, 805, 803, 1, 0, 0, 0, 805, 806, 1, 0, 0, 0, 806, 807, 1, 0, 0, 0, 807, 809, 5, 55, 0, 0, 808, 810, 5, 50, 0, 0, 809, 808, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 79, 1, 0, 0, 0, 811, 812, 5, 54, 0, 0, 812, 816, 3, 84, 42, 0, 813, 815, 3, 90, 45, 0, 814, 813, 1, 0, 0, 0, 815, 818, 1, 0, 0, 0, 816, 814, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817, 820, 1, 0, 0, 0, 818, 816, 1, 0, 0, 0, 819, 821, 3, 82, 41, 0, 820, 819, 1, 0, 0, 0, 820, 821, 1, 0, 0, 0, 821, 845, 1, 0, 0, 0, 822, 823, 5, 54, 0, 0, 823, 827, 3, 86, 43, 0, 824, 826, 3, 90, 45, 0, 825, 824, 1, 0, 0, 0, 826, 829, 1, 0, 0, 0, 827, 825, 1, 0, 0, 0, 827, 828, 1, 0, 0, 0, 828, 831, 1, 0, 0, 0, 829, 827, 1, 0, 0, 0, 830, 832, 3, 82, 41, 0, 831, 830, 1, 0, 0, 0, 831, 832, 1, 0, 0, 0, 832, 845, 1, 0, 0, 0, 833, 834, 5, 54, 0, 0, 834, 836, 5, 50, 0, 0, 835, 837, 3, 90, 45, 0, 836, 835, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 836, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 841, 1, 0, 0, 0, 840, 842, 3, 82, 41, 0, 841, 840, 1, 0, 0, 0, 841, 842, 1, 0, 0, 0, 842, 845, 1, 0, 0, 0, 843, 845, 3, 82, 41, 0, 844, 811, 1, 0, 0, 0, 844, 822, 1, 0, 0, 0, 844, 833, 1, 0, 0, 0, 844, 843, 1, 0, 0, 0, 845, 81, 1, 0, 0, 0, 846, 847, 5, 70, 0, 0, 847, 848, 3, 84, 42, 0, 848, 83, 1, 0, 0, 0, 849, 851, 3, 92, 46, 0, 850, 852, 5, 50, 0, 0, 851, 850, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0, 852, 854, 1, 0, 0, 0, 853, 855, 5, 3, 0, 0, 854, 853, 1, 0, 0, 0, 854, 855, 1, 0, 0, 0, 855, 85, 1, 0, 0, 0, 856, 858, 3, 94, 47, 0, 857, 859, 5, 50, 0, 0, 858, 857, 1, 0, 0, 0, 858, 859, 1, 0, 0, 0, 859, 861, 1, 0, 0, 0, 860, 862, 5, 3, 0, 0, 861, 860, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 862, 87, 1, 0, 0, 0, 863, 864, 3, 92, 46, 0, 864, 866, 3, 100, 50, 0, 865, 867, 5, 50, 0, 0, 866, 865, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 869, 1, 0, 0, 0, 868, 870, 5, 3, 0, 0, 869, 868, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 89, 1, 0, 0, 0, 871, 873, 3, 92, 46, 0, 872, 874, 3, 100, 50, 0, 873, 872, 1, 0, 0, 0, 873, 874, 1, 0, 0, 0, 874, 876, 1, 0, 0, 0, 875, 877, 5, 50, 0, 0, 876, 875, 1, 0, 0, 0, 876, 877, 1, 0, 0, 0, 877, 879, 1, 0, 0, 0, 878, 880, 5, 3, 0, 0, 879, 878, 1, 0, 0, 0, 879, 880, 1, 0, 0, 0, 880, 91, 1, 0, 0, 0, 881, 883, 5, 90, 0, 0, 882, 884, 3, 96, 48, 0, 883, 882, 1, 0, 0, 0, 883, 884, 1, 0, 0, 0, 884, 93, 1, 0, 0, 0, 885, 886, 5, 90, 0, 0, 886, 887, 3, 98, 49, 0, 887, 95, 1, 0, 0, 0, 888, 889, 5, 49, 0, 0, 889, 890, 3, 208, 104, 0, 890, 97, 1, 0, 0, 0, 891, 892, 5, 49, 0, 0, 892, 893, 3, 214, 107, 0, 893, 99, 1, 0, 0, 0, 894, 895, 5, 60, 0, 0, 895, 896, 3, 208, 104, 0, 896, 101, 1, 0, 0, 0, 897, 898, 5, 39, 0, 0, 898, 899, 3, 222, 111, 0, 899, 900, 5, 49, 0, 0, 900, 905, 3, 60, 30, 0, 901, 906, 3, 104, 52, 0, 902, 904, 3, 106, 53, 0, 903, 902, 1, 0, 0, 0, 903, 904, 1, 0, 0, 0, 904, 906, 1, 0, 0, 0, 905, 901, 1, 0, 0, 0, 905, 903, 1, 0, 0, 0, 906, 103, 1, 0, 0, 0, 907, 908, 5, 38, 0, 0, 908, 909, 3, 222, 111, 0, 909, 910, 5, 49, 0, 0, 910, 915, 3, 60, 30, 0, 911, 916, 3, 104, 52, 0, 912, 914, 3, 106, 53, 0, 913, 912, 1, 0, 0, 0, 913, 914, 1, 0, 0, 0, 914, 916, 1, 0, 0, 0, 915, 911, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 916, 105, 1, 0, 0, 0, 917, 918, 5, 9, 0, 0, 918, 919, 5, 49, 0, 0, 919, 920, 3, 60, 30, 0, 920, 107, 1, 0, 0, 0, 921, 922, 5, 31, 0, 0, 922, 923, 3, 222, 111, 0, 923, 924, 5, 49, 0, 0, 924, 926, 3, 60, 30, 0, 925, 927, 3, 106, 53, 0, 926, 925, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 109, 1, 0, 0, 0, 928, 930, 5, 37, 0, 0, 929, 928, 1, 0, 0, 0, 929, 930, 1, 0, 0, 0, 930, 931, 1, 0, 0, 0, 931, 932, 5, 24, 0, 0, 932, 933, 3, 358, 179, 0, 933, 934, 5, 15, 0, 0, 934, 935, 3, 212, 106, 0, 935, 937, 5, 49, 0, 0, 936, 938, 5, 3, 0, 0, 937, 936, 1, 0, 0, 0, 937, 938, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 941, 3, 60, 30, 0, 940, 942, 3, 106, 53, 0, 941, 940, 1, 0, 0, 0, 941, 942, 1, 0, 0, 0, 942, 111, 1, 0, 0, 0, 943, 945, 5, 37, 0, 0, 944, 943, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 974, 5, 36, 0, 0, 947, 948, 5, 42, 0, 0, 948, 953, 3, 114, 57, 0, 949, 950, 5, 50, 0, 0, 950, 952, 3, 114, 57, 0, 951, 949, 1, 0, 0, 0, 952, 955, 1, 0, 0, 0, 953, 951, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 954, 957, 1, 0, 0, 0, 955, 953, 1, 0, 0, 0, 956, 958, 5, 50, 0, 0, 957, 956, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 960, 5, 45, 0, 0, 960, 961, 5, 49, 0, 0, 961, 975, 1, 0, 0, 0, 962, 967, 3, 114, 57, 0, 963, 964, 5, 50, 0, 0, 964, 966, 3, 114, 57, 0, 965, 963, 1, 0, 0, 0, 966, 969, 1, 0, 0, 0, 967, 965, 1, 0, 0, 0, 967, 968, 1, 0, 0, 0, 968, 970, 1, 0, 0, 0, 969, 967, 1, 0, 0, 0, 970, 972, 5, 49, 0, 0, 971, 973, 5, 3, 0, 0, 972, 971, 1, 0, 0, 0, 972, 973, 1, 0, 0, 0, 973, 975, 1, 0, 0, 0, 974, 947, 1, 0, 0, 0, 974, 962, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 977, 3, 60, 30, 0, 977, 113, 1, 0, 0, 0, 978, 981, 3, 208, 104, 0, 979, 980, 5, 27, 0, 0, 980, 982, 3, 364, 182, 0, 981, 979, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 115, 1, 0, 0, 0, 983, 984, 5, 26, 0, 0, 984, 985, 5, 49, 0, 0, 985, 986, 3, 60, 30, 0, 986, 987, 3, 122, 61, 0, 987, 1017, 1, 0, 0, 0, 988, 989, 5, 26, 0, 0, 989, 990, 5, 49, 0, 0, 990, 992, 3, 60, 30, 0, 991, 993, 3, 118, 59, 0, 992, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 992, 1, 0, 0, 0, 994, 995, 1, 0, 0, 0, 995, 997, 1, 0, 0, 0, 996, 998, 3, 106, 53, 0, 997, 996, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 1000, 1, 0, 0, 0, 999, 1001, 3, 122, 61, 0, 1000, 999, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1017, 1, 0, 0, 0, 1002, 1003, 5, 26, 0, 0, 1003, 1004, 5, 49, 0, 0, 1004, 1006, 3, 60, 30, 0, 1005, 1007, 3, 120, 60, 0, 1006, 1005, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1006, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 1, 0, 0, 0, 1010, 1012, 3, 106, 53, 0, 1011, 1010, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, 0, 1012, 1014, 1, 0, 0, 0, 1013, 1015, 3, 122, 61, 0, 1014, 1013, 1, 0, 0, 0, 1014, 1015, 1, 0, 0, 0, 1015, 1017, 1, 0, 0, 0, 1016, 983, 1, 0, 0, 0, 1016, 988, 1, 0, 0, 0, 1016, 1002, 1, 0, 0, 0, 1017, 117, 1, 0, 0, 0, 1018, 1024, 5, 14, 0, 0, 1019, 1022, 3, 208, 104, 0, 1020, 1021, 5, 27, 0, 0, 1021, 1023, 5, 90, 0, 0, 1022, 1020, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1025, 1, 0, 0, 0, 1024, 1019, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 1027, 5, 49, 0, 0, 1027, 1028, 3, 60, 30, 0, 1028, 119, 1, 0, 0, 0, 1029, 1030, 5, 14, 0, 0, 1030, 1031, 5, 54, 0, 0, 1031, 1034, 3, 208, 104, 0, 1032, 1033, 5, 27, 0, 0, 1033, 1035, 5, 90, 0, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1035, 1, 0, 0, 0, 1035, 1036, 1, 0, 0, 0, 1036, 1037, 5, 49, 0, 0, 1037, 1038, 3, 60, 30, 0, 1038, 121, 1, 0, 0, 0, 1039, 1040, 5, 19, 0, 0, 1040, 1041, 5, 49, 0, 0, 1041, 1042, 3, 60, 30, 0, 1042, 123, 1, 0, 0, 0, 1043, 1044, 3, 388, 194, 0, 1044, 1045, 3, 126, 63, 0, 1045, 1046, 5, 49, 0, 0, 1046, 1047, 5, 93, 0, 0, 1047, 1049, 5, 1, 0, 0, 1048, 1050, 3, 128, 64, 0, 1049, 1048, 1, 0, 0, 0, 1050, 1051, 1, 0, 0, 0, 1051, 1049, 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1054, 5, 2, 0, 0, 1054, 125, 1, 0, 0, 0, 1055, 1056, 3, 218, 109, 0, 1056, 1058, 5, 50, 0, 0, 1057, 1059, 3, 216, 108, 0, 1058, 1057, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1062, 1, 0, 0, 0, 1060, 1062, 3, 222, 111, 0, 1061, 1055, 1, 0, 0, 0, 1061, 1060, 1, 0, 0, 0, 1062, 127, 1, 0, 0, 0, 1063, 1064, 3, 390, 195, 0, 1064, 1066, 3, 132, 66, 0, 1065, 1067, 3, 130, 65, 0, 1066, 1065, 1, 0, 0, 0, 1066, 1067, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1069, 5, 49, 0, 0, 1069, 1070, 3, 60, 30, 0, 1070, 129, 1, 0, 0, 0, 1071, 1072, 5, 39, 0, 0, 1072, 1073, 3, 222, 111, 0, 1073, 131, 1, 0, 0, 0, 1074, 1077, 3, 172, 86, 0, 1075, 1077, 3, 134, 67, 0, 1076, 1074, 1, 0, 0, 0, 1076, 1075, 1, 0, 0, 0, 1077, 133, 1, 0, 0, 0, 1078, 1081, 3, 136, 68, 0, 1079, 1081, 3, 138, 69, 0, 1080, 1078, 1, 0, 0, 0, 1080, 1079, 1, 0, 0, 0, 1081, 135, 1, 0, 0, 0, 1082, 1083, 3, 138, 69, 0, 1083, 1084, 5, 27, 0, 0, 1084, 1085, 3, 158, 79, 0, 1085, 137, 1, 0, 0, 0, 1086, 1091, 3, 140, 70, 0, 1087, 1088, 5, 56, 0, 0, 1088, 1090, 3, 140, 70, 0, 1089, 1087, 1, 0, 0, 0, 1090, 1093, 1, 0, 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 139, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1094, 1103, 3, 142, 71, 0, 1095, 1103, 3, 156, 78, 0, 1096, 1103, 3, 160, 80, 0, 1097, 1103, 3, 162, 81, 0, 1098, 1103, 3, 168, 84, 0, 1099, 1103, 3, 170, 85, 0, 1100, 1103, 3, 180, 90, 0, 1101, 1103, 3, 188, 94, 0, 1102, 1094, 1, 0, 0, 0, 1102, 1095, 1, 0, 0, 0, 1102, 1096, 1, 0, 0, 0, 1102, 1097, 1, 0, 0, 0, 1102, 1098, 1, 0, 0, 0, 1102, 1099, 1, 0, 0, 0, 1102, 1100, 1, 0, 0, 0, 1102, 1101, 1, 0, 0, 0, 1103, 141, 1, 0, 0, 0, 1104, 1111, 3, 148, 74, 0, 1105, 1111, 3, 146, 73, 0, 1106, 1111, 3, 318, 159, 0, 1107, 1111, 5, 12, 0, 0, 1108, 1111, 5, 17, 0, 0, 1109, 1111, 5, 7, 0, 0, 1110, 1104, 1, 0, 0, 0, 1110, 1105, 1, 0, 0, 0, 1110, 1106, 1, 0, 0, 0, 1110, 1107, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1109, 1, 0, 0, 0, 1111, 143, 1, 0, 0, 0, 1112, 1119, 3, 148, 74, 0, 1113, 1119, 3, 146, 73, 0, 1114, 1119, 3, 318, 159, 0, 1115, 1119, 5, 12, 0, 0, 1116, 1119, 5, 17, 0, 0, 1117, 1119, 5, 7, 0, 0, 1118, 1112, 1, 0, 0, 0, 1118, 1113, 1, 0, 0, 0, 1118, 1114, 1, 0, 0, 0, 1118, 1115, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1117, 1, 0, 0, 0, 1119, 145, 1, 0, 0, 0, 1120, 1121, 3, 150, 75, 0, 1121, 1122, 7, 2, 0, 0, 1122, 1123, 3, 154, 77, 0, 1123, 147, 1, 0, 0, 0, 1124, 1126, 5, 53, 0, 0, 1125, 1124, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1128, 5, 91, 0, 0, 1128, 149, 1, 0, 0, 0, 1129, 1131, 5, 53, 0, 0, 1130, 1129, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 3, 152, 76, 0, 1133, 151, 1, 0, 0, 0, 1134, 1135, 5, 91, 0, 0, 1135, 153, 1, 0, 0, 0, 1136, 1137, 5, 91, 0, 0, 1137, 155, 1, 0, 0, 0, 1138, 1139, 3, 158, 79, 0, 1139, 157, 1, 0, 0, 0, 1140, 1141, 3, 394, 197, 0, 1141, 159, 1, 0, 0, 0, 1142, 1143, 3, 392, 196, 0, 1143, 161, 1, 0, 0, 0, 1144, 1145, 3, 164, 82, 0, 1145, 163, 1, 0, 0, 0, 1146, 1149, 5, 90, 0, 0, 1147, 1148, 5, 48, 0, 0, 1148, 1150, 5, 90, 0, 0, 1149, 1147, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 165, 1, 0, 0, 0, 1153, 1158, 5, 90, 0, 0, 1154, 1155, 5, 48, 0, 0, 1155, 1157, 5, 90, 0, 0, 1156, 1154, 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 167, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1161, 1162, 5, 42, 0, 0, 1162, 1163, 3, 134, 67, 0, 1163, 1164, 5, 45, 0, 0, 1164, 169, 1, 0, 0, 0, 1165, 1167, 5, 43, 0, 0, 1166, 1168, 3, 174, 87, 0, 1167, 1166, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1176, 5, 46, 0, 0, 1170, 1172, 5, 42, 0, 0, 1171, 1173, 3, 172, 86, 0, 1172, 1171, 1, 0, 0, 0, 1172, 1173, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1176, 5, 45, 0, 0, 1175, 1165, 1, 0, 0, 0, 1175, 1170, 1, 0, 0, 0, 1176, 171, 1, 0, 0, 0, 1177, 1178, 3, 176, 88, 0, 1178, 1180, 5, 50, 0, 0, 1179, 1181, 3, 174, 87, 0, 1180, 1179, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 173, 1, 0, 0, 0, 1182, 1187, 3, 176, 88, 0, 1183, 1184, 5, 50, 0, 0, 1184, 1186, 3, 176, 88, 0, 1185, 1183, 1, 0, 0, 0, 1186, 1189, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1187, 1188, 1, 0, 0, 0, 1188, 1191, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1190, 1192, 5, 50, 0, 0, 1191, 1190, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 175, 1, 0, 0, 0, 1193, 1196, 3, 178, 89, 0, 1194, 1196, 3, 134, 67, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1194, 1, 0, 0, 0, 1196, 177, 1, 0, 0, 0, 1197, 1198, 5, 54, 0, 0, 1198, 1199, 5, 90, 0, 0, 1199, 179, 1, 0, 0, 0, 1200, 1201, 5, 44, 0, 0, 1201, 1221, 5, 47, 0, 0, 1202, 1203, 5, 44, 0, 0, 1203, 1205, 3, 186, 93, 0, 1204, 1206, 5, 50, 0, 0, 1205, 1204, 1, 0, 0, 0, 1205, 1206, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1208, 5, 47, 0, 0, 1208, 1221, 1, 0, 0, 0, 1209, 1210, 5, 44, 0, 0, 1210, 1213, 3, 182, 91, 0, 1211, 1212, 5, 50, 0, 0, 1212, 1214, 3, 186, 93, 0, 1213, 1211, 1, 0, 0, 0, 1213, 1214, 1, 0, 0, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1217, 5, 50, 0, 0, 1216, 1215, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1219, 5, 47, 0, 0, 1219, 1221, 1, 0, 0, 0, 1220, 1200, 1, 0, 0, 0, 1220, 1202, 1, 0, 0, 0, 1220, 1209, 1, 0, 0, 0, 1221, 181, 1, 0, 0, 0, 1222, 1227, 3, 184, 92, 0, 1223, 1224, 5, 50, 0, 0, 1224, 1226, 3, 184, 92, 0, 1225, 1223, 1, 0, 0, 0, 1226, 1229, 1, 0, 0, 0, 1227, 1225, 1, 0, 0, 0, 1227, 1228, 1, 0, 0, 0, 1228, 183, 1, 0, 0, 0, 1229, 1227, 1, 0, 0, 0, 1230, 1233, 3, 144, 72, 0, 1231, 1233, 3, 164, 82, 0, 1232, 1230, 1, 0, 0, 0, 1232, 1231, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1235, 5, 49, 0, 0, 1235, 1236, 3, 134, 67, 0, 1236, 185, 1, 0, 0, 0, 1237, 1238, 5, 70, 0, 0, 1238, 1239, 3, 158, 79, 0, 1239, 187, 1, 0, 0, 0, 1240, 1241, 3, 166, 83, 0, 1241, 1253, 5, 42, 0, 0, 1242, 1245, 3, 190, 95, 0, 1243, 1244, 5, 50, 0, 0, 1244, 1246, 3, 192, 96, 0, 1245, 1243, 1, 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1249, 1, 0, 0, 0, 1247, 1249, 3, 192, 96, 0, 1248, 1242, 1, 0, 0, 0, 1248, 1247, 1, 0, 0, 0, 1249, 1251, 1, 0, 0, 0, 1250, 1252, 5, 50, 0, 0, 1251, 1250, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, 1254, 1, 0, 0, 0, 1253, 1248, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 1256, 5, 45, 0, 0, 1256, 189, 1, 0, 0, 0, 1257, 1262, 3, 134, 67, 0, 1258, 1259, 5, 50, 0, 0, 1259, 1261, 3, 134, 67, 0, 1260, 1258, 1, 0, 0, 0, 1261, 1264, 1, 0, 0, 0, 1262, 1260, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 191, 1, 0, 0, 0, 1264, 1262, 1, 0, 0, 0, 1265, 1270, 3, 194, 97, 0, 1266, 1267, 5, 50, 0, 0, 1267, 1269, 3, 194, 97, 0, 1268, 1266, 1, 0, 0, 0, 1269, 1272, 1, 0, 0, 0, 1270, 1268, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, 193, 1, 0, 0, 0, 1272, 1270, 1, 0, 0, 0, 1273, 1274, 5, 90, 0, 0, 1274, 1275, 5, 60, 0, 0, 1275, 1276, 3, 134, 67, 0, 1276, 195, 1, 0, 0, 0, 1277, 1278, 3, 386, 193, 0, 1278, 1280, 5, 90, 0, 0, 1279, 1281, 3, 198, 99, 0, 1280, 1279, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 5, 60, 0, 0, 1283, 1284, 3, 208, 104, 0, 1284, 197, 1, 0, 0, 0, 1285, 1286, 5, 43, 0, 0, 1286, 1287, 3, 200, 100, 0, 1287, 1288, 5, 46, 0, 0, 1288, 199, 1, 0, 0, 0, 1289, 1294, 3, 202, 101, 0, 1290, 1291, 5, 50, 0, 0, 1291, 1293, 3, 202, 101, 0, 1292, 1290, 1, 0, 0, 0, 1293, 1296, 1, 0, 0, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 1298, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1297, 1299, 5, 50, 0, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 201, 1, 0, 0, 0, 1300, 1302, 5, 90, 0, 0, 1301, 1303, 3, 204, 102, 0, 1302, 1301, 1, 0, 0, 0, 1302, 1303, 1, 0, 0, 0, 1303, 1309, 1, 0, 0, 0, 1304, 1305, 5, 54, 0, 0, 1305, 1309, 5, 90, 0, 0, 1306, 1307, 5, 70, 0, 0, 1307, 1309, 5, 90, 0, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1308, 1306, 1, 0, 0, 0, 1309, 203, 1, 0, 0, 0, 1310, 1311, 5, 49, 0, 0, 1311, 1312, 3, 208, 104, 0, 1312, 205, 1, 0, 0, 0, 1313, 1318, 3, 208, 104, 0, 1314, 1315, 5, 50, 0, 0, 1315, 1317, 3, 208, 104, 0, 1316, 1314, 1, 0, 0, 0, 1317, 1320, 1, 0, 0, 0, 1318, 1316, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 1322, 1, 0, 0, 0, 1320, 1318, 1, 0, 0, 0, 1321, 1323, 5, 50, 0, 0, 1322, 1321, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 207, 1, 0, 0, 0, 1324, 1330, 3, 224, 112, 0, 1325, 1326, 5, 39, 0, 0, 1326, 1327, 3, 224, 112, 0, 1327, 1328, 5, 9, 0, 0, 1328, 1329, 3, 208, 104, 0, 1329, 1331, 1, 0, 0, 0, 1330, 1325, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1334, 3, 282, 141, 0, 1333, 1324, 1, 0, 0, 0, 1333, 1332, 1, 0, 0, 0, 1334, 209, 1, 0, 0, 0, 1335, 1341, 5, 41, 0, 0, 1336, 1337, 5, 29, 0, 0, 1337, 1342, 3, 208, 104, 0, 1338, 1340, 3, 212, 106, 0, 1339, 1338, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 1342, 1, 0, 0, 0, 1341, 1336, 1, 0, 0, 0, 1341, 1339, 1, 0, 0, 0, 1342, 211, 1, 0, 0, 0, 1343, 1348, 3, 214, 107, 0, 1344, 1345, 5, 50, 0, 0, 1345, 1347, 3, 214, 107, 0, 1346, 1344, 1, 0, 0, 0, 1347, 1350, 1, 0, 0, 0, 1348, 1346, 1, 0, 0, 0, 1348, 1349, 1, 0, 0, 0, 1349, 1352, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1351, 1353, 5, 50, 0, 0, 1352, 1351, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 213, 1, 0, 0, 0, 1354, 1355, 5, 54, 0, 0, 1355, 1358, 3, 254, 127, 0, 1356, 1358, 3, 208, 104, 0, 1357, 1354, 1, 0, 0, 0, 1357, 1356, 1, 0, 0, 0, 1358, 215, 1, 0, 0, 0, 1359, 1364, 3, 218, 109, 0, 1360, 1361, 5, 50, 0, 0, 1361, 1363, 3, 218, 109, 0, 1362, 1360, 1, 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1368, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1369, 5, 50, 0, 0, 1368, 1367, 1, 0, 0, 0, 1368, 1369, 1, 0, 0, 0, 1369, 217, 1, 0, 0, 0, 1370, 1371, 5, 54, 0, 0, 1371, 1374, 3, 254, 127, 0, 1372, 1374, 3, 222, 111, 0, 1373, 1370, 1, 0, 0, 0, 1373, 1372, 1, 0, 0, 0, 1374, 219, 1, 0, 0, 0, 1375, 1376, 5, 90, 0, 0, 1376, 1377, 5, 88, 0, 0, 1377, 1378, 3, 208, 104, 0, 1378, 221, 1, 0, 0, 0, 1379, 1382, 3, 220, 110, 0, 1380, 1382, 3, 208, 104, 0, 1381, 1379, 1, 0, 0, 0, 1381, 1380, 1, 0, 0, 0, 1382, 223, 1, 0, 0, 0, 1383, 1388, 3, 226, 113, 0, 1384, 1385, 5, 40, 0, 0, 1385, 1387, 3, 226, 113, 0, 1386, 1384, 1, 0, 0, 0, 1387, 1390, 1, 0, 0, 0, 1388, 1386, 1, 0, 0, 0, 1388, 1389, 1, 0, 0, 0, 1389, 225, 1, 0, 0, 0, 1390, 1388, 1, 0, 0, 0, 1391, 1396, 3, 228, 114, 0, 1392, 1393, 5, 22, 0, 0, 1393, 1395, 3, 228, 114, 0, 1394, 1392, 1, 0, 0, 0, 1395, 1398, 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, 227, 1, 0, 0, 0, 1398, 1396, 1, 0, 0, 0, 1399, 1400, 5, 35, 0, 0, 1400, 1403, 3, 228, 114, 0, 1401, 1403, 3, 230, 115, 0, 1402, 1399, 1, 0, 0, 0, 1402, 1401, 1, 0, 0, 0, 1403, 229, 1, 0, 0, 0, 1404, 1408, 3, 254, 127, 0, 1405, 1407, 3, 232, 116, 0, 1406, 1405, 1, 0, 0, 0, 1407, 1410, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, 1408, 1409, 1, 0, 0, 0, 1409, 231, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1411, 1422, 3, 234, 117, 0, 1412, 1422, 3, 236, 118, 0, 1413, 1422, 3, 238, 119, 0, 1414, 1422, 3, 240, 120, 0, 1415, 1422, 3, 242, 121, 0, 1416, 1422, 3, 244, 122, 0, 1417, 1422, 3, 246, 123, 0, 1418, 1422, 3, 248, 124, 0, 1419, 1422, 3, 250, 125, 0, 1420, 1422, 3, 252, 126, 0, 1421, 1411, 1, 0, 0, 0, 1421, 1412, 1, 0, 0, 0, 1421, 1413, 1, 0, 0, 0, 1421, 1414, 1, 0, 0, 0, 1421, 1415, 1, 0, 0, 0, 1421, 1416, 1, 0, 0, 0, 1421, 1417, 1, 0, 0, 0, 1421, 1418, 1, 0, 0, 0, 1421, 1419, 1, 0, 0, 0, 1421, 1420, 1, 0, 0, 0, 1422, 233, 1, 0, 0, 0, 1423, 1424, 5, 62, 0, 0, 1424, 1425, 3, 254, 127, 0, 1425, 235, 1, 0, 0, 0, 1426, 1427, 5, 63, 0, 0, 1427, 1428, 3, 254, 127, 0, 1428, 237, 1, 0, 0, 0, 1429, 1430, 5, 64, 0, 0, 1430, 1431, 3, 254, 127, 0, 1431, 239, 1, 0, 0, 0, 1432, 1433, 5, 58, 0, 0, 1433, 1434, 3, 254, 127, 0, 1434, 241, 1, 0, 0, 0, 1435, 1436, 5, 65, 0, 0, 1436, 1437, 3, 254, 127, 0, 1437, 243, 1, 0, 0, 0, 1438, 1439, 5, 59, 0, 0, 1439, 1440, 3, 254, 127, 0, 1440, 245, 1, 0, 0, 0, 1441, 1442, 5, 35, 0, 0, 1442, 1443, 5, 15, 0, 0, 1443, 1444, 3, 254, 127, 0, 1444, 247, 1, 0, 0, 0, 1445, 1446, 5, 15, 0, 0, 1446, 1447, 3, 254, 127, 0, 1447, 249, 1, 0, 0, 0, 1448, 1449, 5, 20, 0, 0, 1449, 1450, 5, 35, 0, 0, 1450, 1451, 3, 254, 127, 0, 1451, 251, 1, 0, 0, 0, 1452, 1453, 5, 20, 0, 0, 1453, 1454, 3, 254, 127, 0, 1454, 253, 1, 0, 0, 0, 1455, 1456, 6, 127, -1, 0, 1456, 1457, 3, 256, 128, 0, 1457, 1463, 1, 0, 0, 0, 1458, 1459, 10, 2, 0, 0, 1459, 1460, 5, 56, 0, 0, 1460, 1462, 3, 256, 128, 0, 1461, 1458, 1, 0, 0, 0, 1462, 1465, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1463, 1464, 1, 0, 0, 0, 1464, 255, 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1466, 1467, 6, 128, -1, 0, 1467, 1468, 3, 258, 129, 0, 1468, 1474, 1, 0, 0, 0, 1469, 1470, 10, 2, 0, 0, 1470, 1471, 5, 67, 0, 0, 1471, 1473, 3, 258, 129, 0, 1472, 1469, 1, 0, 0, 0, 1473, 1476, 1, 0, 0, 0, 1474, 1472, 1, 0, 0, 0, 1474, 1475, 1, 0, 0, 0, 1475, 257, 1, 0, 0, 0, 1476, 1474, 1, 0, 0, 0, 1477, 1478, 6, 129, -1, 0, 1478, 1479, 3, 260, 130, 0, 1479, 1485, 1, 0, 0, 0, 1480, 1481, 10, 2, 0, 0, 1481, 1482, 5, 57, 0, 0, 1482, 1484, 3, 260, 130, 0, 1483, 1480, 1, 0, 0, 0, 1484, 1487, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 259, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1488, 1489, 6, 130, -1, 0, 1489, 1490, 3, 262, 131, 0, 1490, 1496, 1, 0, 0, 0, 1491, 1492, 10, 2, 0, 0, 1492, 1493, 7, 3, 0, 0, 1493, 1495, 3, 262, 131, 0, 1494, 1491, 1, 0, 0, 0, 1495, 1498, 1, 0, 0, 0, 1496, 1494, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 261, 1, 0, 0, 0, 1498, 1496, 1, 0, 0, 0, 1499, 1500, 6, 131, -1, 0, 1500, 1501, 3, 264, 132, 0, 1501, 1507, 1, 0, 0, 0, 1502, 1503, 10, 2, 0, 0, 1503, 1504, 7, 2, 0, 0, 1504, 1506, 3, 264, 132, 0, 1505, 1502, 1, 0, 0, 0, 1506, 1509, 1, 0, 0, 0, 1507, 1505, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 263, 1, 0, 0, 0, 1509, 1507, 1, 0, 0, 0, 1510, 1511, 6, 132, -1, 0, 1511, 1512, 3, 266, 133, 0, 1512, 1518, 1, 0, 0, 0, 1513, 1514, 10, 2, 0, 0, 1514, 1515, 7, 4, 0, 0, 1515, 1517, 3, 266, 133, 0, 1516, 1513, 1, 0, 0, 0, 1517, 1520, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 265, 1, 0, 0, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1522, 5, 52, 0, 0, 1522, 1529, 3, 266, 133, 0, 1523, 1524, 5, 53, 0, 0, 1524, 1529, 3, 266, 133, 0, 1525, 1526, 5, 66, 0, 0, 1526, 1529, 3, 266, 133, 0, 1527, 1529, 3, 268, 134, 0, 1528, 1521, 1, 0, 0, 0, 1528, 1523, 1, 0, 0, 0, 1528, 1525, 1, 0, 0, 0, 1528, 1527, 1, 0, 0, 0, 1529, 267, 1, 0, 0, 0, 1530, 1533, 3, 270, 135, 0, 1531, 1532, 5, 70, 0, 0, 1532, 1534, 3, 266, 133, 0, 1533, 1531, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 269, 1, 0, 0, 0, 1535, 1536, 5, 8, 0, 0, 1536, 1539, 3, 272, 136, 0, 1537, 1539, 3, 272, 136, 0, 1538, 1535, 1, 0, 0, 0, 1538, 1537, 1, 0, 0, 0, 1539, 271, 1, 0, 0, 0, 1540, 1541, 6, 136, -1, 0, 1541, 1542, 3, 278, 139, 0, 1542, 1560, 1, 0, 0, 0, 1543, 1556, 10, 2, 0, 0, 1544, 1545, 5, 48, 0, 0, 1545, 1557, 5, 90, 0, 0, 1546, 1557, 3, 342, 171, 0, 1547, 1549, 5, 42, 0, 0, 1548, 1550, 3, 346, 173, 0, 1549, 1548, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 1557, 5, 45, 0, 0, 1552, 1553, 5, 43, 0, 0, 1553, 1554, 3, 274, 137, 0, 1554, 1555, 5, 46, 0, 0, 1555, 1557, 1, 0, 0, 0, 1556, 1544, 1, 0, 0, 0, 1556, 1546, 1, 0, 0, 0, 1556, 1547, 1, 0, 0, 0, 1556, 1552, 1, 0, 0, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1543, 1, 0, 0, 0, 1559, 1562, 1, 0, 0, 0, 1560, 1558, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 273, 1, 0, 0, 0, 1562, 1560, 1, 0, 0, 0, 1563, 1582, 3, 276, 138, 0, 1564, 1567, 3, 276, 138, 0, 1565, 1567, 3, 352, 176, 0, 1566, 1564, 1, 0, 0, 0, 1566, 1565, 1, 0, 0, 0, 1567, 1575, 1, 0, 0, 0, 1568, 1571, 5, 50, 0, 0, 1569, 1572, 3, 276, 138, 0, 1570, 1572, 3, 352, 176, 0, 1571, 1569, 1, 0, 0, 0, 1571, 1570, 1, 0, 0, 0, 1572, 1574, 1, 0, 0, 0, 1573, 1568, 1, 0, 0, 0, 1574, 1577, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 1579, 1, 0, 0, 0, 1577, 1575, 1, 0, 0, 0, 1578, 1580, 5, 50, 0, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1582, 1, 0, 0, 0, 1581, 1563, 1, 0, 0, 0, 1581, 1566, 1, 0, 0, 0, 1582, 275, 1, 0, 0, 0, 1583, 1585, 3, 208, 104, 0, 1584, 1583, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 1, 0, 0, 0, 1586, 1588, 5, 49, 0, 0, 1587, 1589, 3, 208, 104, 0, 1588, 1587, 1, 0, 0, 0, 1588, 1589, 1, 0, 0, 0, 1589, 1594, 1, 0, 0, 0, 1590, 1592, 5, 49, 0, 0, 1591, 1593, 3, 208, 104, 0, 1592, 1591, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1595, 1, 0, 0, 0, 1594, 1590, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 1598, 1, 0, 0, 0, 1596, 1598, 3, 222, 111, 0, 1597, 1584, 1, 0, 0, 0, 1597, 1596, 1, 0, 0, 0, 1598, 277, 1, 0, 0, 0, 1599, 1622, 5, 90, 0, 0, 1600, 1622, 5, 17, 0, 0, 1601, 1622, 5, 7, 0, 0, 1602, 1622, 5, 12, 0, 0, 1603, 1622, 3, 318, 159, 0, 1604, 1622, 5, 91, 0, 0, 1605, 1609, 3, 322, 161, 0, 1606, 1609, 3, 280, 140, 0, 1607, 1609, 3, 342, 171, 0, 1608, 1605, 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1608, 1607, 1, 0, 0, 0, 1609, 1622, 1, 0, 0, 0, 1610, 1613, 3, 320, 160, 0, 1611, 1613, 3, 338, 169, 0, 1612, 1610, 1, 0, 0, 0, 1612, 1611, 1, 0, 0, 0, 1613, 1622, 1, 0, 0, 0, 1614, 1619, 3, 326, 163, 0, 1615, 1619, 3, 324, 162, 0, 1616, 1619, 3, 344, 172, 0, 1617, 1619, 3, 340, 170, 0, 1618, 1614, 1, 0, 0, 0, 1618, 1615, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1618, 1617, 1, 0, 0, 0, 1619, 1622, 1, 0, 0, 0, 1620, 1622, 5, 87, 0, 0, 1621, 1599, 1, 0, 0, 0, 1621, 1600, 1, 0, 0, 0, 1621, 1601, 1, 0, 0, 0, 1621, 1602, 1, 0, 0, 0, 1621, 1603, 1, 0, 0, 0, 1621, 1604, 1, 0, 0, 0, 1621, 1608, 1, 0, 0, 0, 1621, 1612, 1, 0, 0, 0, 1621, 1618, 1, 0, 0, 0, 1621, 1620, 1, 0, 0, 0, 1622, 279, 1, 0, 0, 0, 1623, 1626, 5, 42, 0, 0, 1624, 1627, 3, 210, 105, 0, 1625, 1627, 3, 222, 111, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1625, 1, 0, 0, 0, 1627, 1628, 1, 0, 0, 0, 1628, 1629, 5, 45, 0, 0, 1629, 281, 1, 0, 0, 0, 1630, 1632, 5, 25, 0, 0, 1631, 1633, 3, 284, 142, 0, 1632, 1631, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1635, 5, 49, 0, 0, 1635, 1636, 3, 208, 104, 0, 1636, 283, 1, 0, 0, 0, 1637, 1638, 3, 286, 143, 0, 1638, 285, 1, 0, 0, 0, 1639, 1643, 3, 288, 144, 0, 1640, 1642, 3, 296, 148, 0, 1641, 1640, 1, 0, 0, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1649, 1, 0, 0, 0, 1645, 1643, 1, 0, 0, 0, 1646, 1648, 3, 298, 149, 0, 1647, 1646, 1, 0, 0, 0, 1648, 1651, 1, 0, 0, 0, 1649, 1647, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1653, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1652, 1654, 3, 292, 146, 0, 1653, 1652, 1, 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 1689, 1, 0, 0, 0, 1655, 1659, 3, 290, 145, 0, 1656, 1658, 3, 298, 149, 0, 1657, 1656, 1, 0, 0, 0, 1658, 1661, 1, 0, 0, 0, 1659, 1657, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1663, 1, 0, 0, 0, 1661, 1659, 1, 0, 0, 0, 1662, 1664, 3, 292, 146, 0, 1663, 1662, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1689, 1, 0, 0, 0, 1665, 1667, 3, 296, 148, 0, 1666, 1665, 1, 0, 0, 0, 1667, 1668, 1, 0, 0, 0, 1668, 1666, 1, 0, 0, 0, 1668, 1669, 1, 0, 0, 0, 1669, 1673, 1, 0, 0, 0, 1670, 1672, 3, 298, 149, 0, 1671, 1670, 1, 0, 0, 0, 1672, 1675, 1, 0, 0, 0, 1673, 1671, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1677, 1, 0, 0, 0, 1675, 1673, 1, 0, 0, 0, 1676, 1678, 3, 292, 146, 0, 1677, 1676, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1689, 1, 0, 0, 0, 1679, 1681, 3, 298, 149, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1682, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 1685, 1, 0, 0, 0, 1684, 1686, 3, 292, 146, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1689, 1, 0, 0, 0, 1687, 1689, 3, 292, 146, 0, 1688, 1639, 1, 0, 0, 0, 1688, 1655, 1, 0, 0, 0, 1688, 1666, 1, 0, 0, 0, 1688, 1680, 1, 0, 0, 0, 1688, 1687, 1, 0, 0, 0, 1689, 287, 1, 0, 0, 0, 1690, 1692, 3, 296, 148, 0, 1691, 1690, 1, 0, 0, 0, 1692, 1693, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1695, 1697, 5, 55, 0, 0, 1696, 1698, 5, 50, 0, 0, 1697, 1696, 1, 0, 0, 0, 1697, 1698, 1, 0, 0, 0, 1698, 289, 1, 0, 0, 0, 1699, 1701, 3, 296, 148, 0, 1700, 1699, 1, 0, 0, 0, 1701, 1704, 1, 0, 0, 0, 1702, 1700, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1706, 1, 0, 0, 0, 1704, 1702, 1, 0, 0, 0, 1705, 1707, 3, 298, 149, 0, 1706, 1705, 1, 0, 0, 0, 1707, 1708, 1, 0, 0, 0, 1708, 1706, 1, 0, 0, 0, 1708, 1709, 1, 0, 0, 0, 1709, 1710, 1, 0, 0, 0, 1710, 1712, 5, 55, 0, 0, 1711, 1713, 5, 50, 0, 0, 1712, 1711, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 291, 1, 0, 0, 0, 1714, 1715, 5, 54, 0, 0, 1715, 1719, 3, 296, 148, 0, 1716, 1718, 3, 300, 150, 0, 1717, 1716, 1, 0, 0, 0, 1718, 1721, 1, 0, 0, 0, 1719, 1717, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1723, 1, 0, 0, 0, 1721, 1719, 1, 0, 0, 0, 1722, 1724, 3, 294, 147, 0, 1723, 1722, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1737, 1, 0, 0, 0, 1725, 1726, 5, 54, 0, 0, 1726, 1728, 5, 50, 0, 0, 1727, 1729, 3, 300, 150, 0, 1728, 1727, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1728, 1, 0, 0, 0, 1730, 1731, 1, 0, 0, 0, 1731, 1733, 1, 0, 0, 0, 1732, 1734, 3, 294, 147, 0, 1733, 1732, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 1737, 1, 0, 0, 0, 1735, 1737, 3, 294, 147, 0, 1736, 1714, 1, 0, 0, 0, 1736, 1725, 1, 0, 0, 0, 1736, 1735, 1, 0, 0, 0, 1737, 293, 1, 0, 0, 0, 1738, 1739, 5, 70, 0, 0, 1739, 1740, 3, 296, 148, 0, 1740, 295, 1, 0, 0, 0, 1741, 1743, 3, 302, 151, 0, 1742, 1744, 5, 50, 0, 0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 297, 1, 0, 0, 0, 1745, 1746, 3, 302, 151, 0, 1746, 1748, 3, 100, 50, 0, 1747, 1749, 5, 50, 0, 0, 1748, 1747, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 299, 1, 0, 0, 0, 1750, 1752, 3, 302, 151, 0, 1751, 1753, 3, 100, 50, 0, 1752, 1751, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1755, 1, 0, 0, 0, 1754, 1756, 5, 50, 0, 0, 1755, 1754, 1, 0, 0, 0, 1755, 1756, 1, 0, 0, 0, 1756, 301, 1, 0, 0, 0, 1757, 1758, 5, 90, 0, 0, 1758, 303, 1, 0, 0, 0, 1759, 1762, 3, 306, 153, 0, 1760, 1762, 5, 5, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1760, 1, 0, 0, 0, 1762, 305, 1, 0, 0, 0, 1763, 1766, 5, 44, 0, 0, 1764, 1767, 3, 210, 105, 0, 1765, 1767, 3, 212, 106, 0, 1766, 1764, 1, 0, 0, 0, 1766, 1765, 1, 0, 0, 0, 1767, 1769, 1, 0, 0, 0, 1768, 1770, 5, 60, 0, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1773, 3, 308, 154, 0, 1772, 1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1775, 1, 0, 0, 0, 1774, 1776, 3, 310, 155, 0, 1775, 1774, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 5, 47, 0, 0, 1778, 307, 1, 0, 0, 0, 1779, 1780, 5, 89, 0, 0, 1780, 1781, 5, 90, 0, 0, 1781, 309, 1, 0, 0, 0, 1782, 1786, 5, 49, 0, 0, 1783, 1785, 3, 312, 156, 0, 1784, 1783, 1, 0, 0, 0, 1785, 1788, 1, 0, 0, 0, 1786, 1784, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 311, 1, 0, 0, 0, 1788, 1786, 1, 0, 0, 0, 1789, 1792, 5, 5, 0, 0, 1790, 1792, 3, 306, 153, 0, 1791, 1789, 1, 0, 0, 0, 1791, 1790, 1, 0, 0, 0, 1792, 313, 1, 0, 0, 0, 1793, 1797, 5, 4, 0, 0, 1794, 1796, 3, 304, 152, 0, 1795, 1794, 1, 0, 0, 0, 1796, 1799, 1, 0, 0, 0, 1797, 1795, 1, 0, 0, 0, 1797, 1798, 1, 0, 0, 0, 1798, 1800, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1800, 1801, 5, 6, 0, 0, 1801, 315, 1, 0, 0, 0, 1802, 1803, 5, 92, 0, 0, 1803, 317, 1, 0, 0, 0, 1804, 1807, 3, 314, 157, 0, 1805, 1807, 3, 316, 158, 0, 1806, 1804, 1, 0, 0, 0, 1806, 1805, 1, 0, 0, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1806, 1, 0, 0, 0, 1808, 1809, 1, 0, 0, 0, 1809, 319, 1, 0, 0, 0, 1810, 1812, 5, 43, 0, 0, 1811, 1813, 3, 216, 108, 0, 1812, 1811, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1815, 5, 46, 0, 0, 1815, 321, 1, 0, 0, 0, 1816, 1822, 5, 42, 0, 0, 1817, 1818, 3, 218, 109, 0, 1818, 1820, 5, 50, 0, 0, 1819, 1821, 3, 216, 108, 0, 1820, 1819, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 1823, 1, 0, 0, 0, 1822, 1817, 1, 0, 0, 0, 1822, 1823, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 5, 45, 0, 0, 1825, 323, 1, 0, 0, 0, 1826, 1827, 5, 44, 0, 0, 1827, 1828, 3, 216, 108, 0, 1828, 1829, 5, 47, 0, 0, 1829, 325, 1, 0, 0, 0, 1830, 1832, 5, 44, 0, 0, 1831, 1833, 3, 328, 164, 0, 1832, 1831, 1, 0, 0, 0, 1832, 1833, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1835, 5, 47, 0, 0, 1835, 327, 1, 0, 0, 0, 1836, 1841, 3, 330, 165, 0, 1837, 1838, 5, 50, 0, 0, 1838, 1840, 3, 330, 165, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1843, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1845, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1844, 1846, 5, 50, 0, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 329, 1, 0, 0, 0, 1847, 1848, 5, 70, 0, 0, 1848, 1851, 3, 254, 127, 0, 1849, 1851, 3, 332, 166, 0, 1850, 1847, 1, 0, 0, 0, 1850, 1849, 1, 0, 0, 0, 1851, 331, 1, 0, 0, 0, 1852, 1853, 3, 208, 104, 0, 1853, 1854, 5, 49, 0, 0, 1854, 1855, 3, 208, 104, 0, 1855, 333, 1, 0, 0, 0, 1856, 1858, 3, 336, 168, 0, 1857, 1856, 1, 0, 0, 0, 1858, 1859, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 335, 1, 0, 0, 0, 1861, 1863, 5, 37, 0, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 5, 24, 0, 0, 1865, 1866, 3, 358, 179, 0, 1866, 1867, 5, 15, 0, 0, 1867, 1872, 3, 224, 112, 0, 1868, 1869, 5, 39, 0, 0, 1869, 1871, 3, 224, 112, 0, 1870, 1868, 1, 0, 0, 0, 1871, 1874, 1, 0, 0, 0, 1872, 1870, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, 337, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1875, 1876, 5, 43, 0, 0, 1876, 1877, 3, 222, 111, 0, 1877, 1878, 3, 334, 167, 0, 1878, 1879, 5, 46, 0, 0, 1879, 339, 1, 0, 0, 0, 1880, 1881, 5, 44, 0, 0, 1881, 1882, 3, 222, 111, 0, 1882, 1883, 3, 334, 167, 0, 1883, 1884, 5, 47, 0, 0, 1884, 341, 1, 0, 0, 0, 1885, 1888, 5, 42, 0, 0, 1886, 1889, 3, 220, 110, 0, 1887, 1889, 3, 208, 104, 0, 1888, 1886, 1, 0, 0, 0, 1888, 1887, 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1891, 3, 334, 167, 0, 1891, 1892, 5, 45, 0, 0, 1892, 343, 1, 0, 0, 0, 1893, 1894, 5, 44, 0, 0, 1894, 1895, 3, 332, 166, 0, 1895, 1896, 3, 334, 167, 0, 1896, 1897, 5, 47, 0, 0, 1897, 345, 1, 0, 0, 0, 1898, 1900, 3, 348, 174, 0, 1899, 1901, 5, 50, 0, 0, 1900, 1899, 1, 0, 0, 0, 1900, 1901, 1, 0, 0, 0, 1901, 347, 1, 0, 0, 0, 1902, 1908, 3, 352, 176, 0, 1903, 1906, 3, 220, 110, 0, 1904, 1906, 3, 208, 104, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1904, 1, 0, 0, 0, 1906, 1908, 1, 0, 0, 0, 1907, 1902, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1908, 1919, 1, 0, 0, 0, 1909, 1915, 5, 50, 0, 0, 1910, 1916, 3, 352, 176, 0, 1911, 1914, 3, 220, 110, 0, 1912, 1914, 3, 208, 104, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1912, 1, 0, 0, 0, 1914, 1916, 1, 0, 0, 0, 1915, 1910, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1918, 1, 0, 0, 0, 1917, 1909, 1, 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1917, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1924, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1922, 1923, 5, 50, 0, 0, 1923, 1925, 3, 350, 175, 0, 1924, 1922, 1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1928, 1, 0, 0, 0, 1926, 1928, 3, 350, 175, 0, 1927, 1907, 1, 0, 0, 0, 1927, 1926, 1, 0, 0, 0, 1928, 349, 1, 0, 0, 0, 1929, 1934, 3, 354, 177, 0, 1930, 1931, 5, 50, 0, 0, 1931, 1933, 3, 354, 177, 0, 1932, 1930, 1, 0, 0, 0, 1933, 1936, 1, 0, 0, 0, 1934, 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1946, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1937, 1938, 5, 50, 0, 0, 1938, 1943, 3, 356, 178, 0, 1939, 1940, 5, 50, 0, 0, 1940, 1942, 3, 356, 178, 0, 1941, 1939, 1, 0, 0, 0, 1942, 1945, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 1947, 1, 0, 0, 0, 1945, 1943, 1, 0, 0, 0, 1946, 1937, 1, 0, 0, 0, 1946, 1947, 1, 0, 0, 0, 1947, 1957, 1, 0, 0, 0, 1948, 1953, 3, 356, 178, 0, 1949, 1950, 5, 50, 0, 0, 1950, 1952, 3, 356, 178, 0, 1951, 1949, 1, 0, 0, 0, 1952, 1955, 1, 0, 0, 0, 1953, 1951, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1957, 1, 0, 0, 0, 1955, 1953, 1, 0, 0, 0, 1956, 1929, 1, 0, 0, 0, 1956, 1948, 1, 0, 0, 0, 1957, 351, 1, 0, 0, 0, 1958, 1959, 5, 54, 0, 0, 1959, 1960, 3, 208, 104, 0, 1960, 353, 1, 0, 0, 0, 1961, 1962, 5, 90, 0, 0, 1962, 1963, 5, 60, 0, 0, 1963, 1966, 3, 208, 104, 0, 1964, 1966, 3, 352, 176, 0, 1965, 1961, 1, 0, 0, 0, 1965, 1964, 1, 0, 0, 0, 1966, 355, 1, 0, 0, 0, 1967, 1968, 5, 90, 0, 0, 1968, 1969, 5, 60, 0, 0, 1969, 1973, 3, 208, 104, 0, 1970, 1971, 5, 70, 0, 0, 1971, 1973, 3, 208, 104, 0, 1972, 1967, 1, 0, 0, 0, 1972, 1970, 1, 0, 0, 0, 1973, 357, 1, 0, 0, 0, 1974, 1979, 3, 364, 182, 0, 1975, 1976, 5, 50, 0, 0, 1976, 1978, 3, 364, 182, 0, 1977, 1975, 1, 0, 0, 0, 1978, 1981, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1983, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1982, 1984, 5, 50, 0, 0, 1983, 1982, 1, 0, 0, 0, 1983, 1984, 1, 0, 0, 0, 1984, 359, 1, 0, 0, 0, 1985, 1988, 3, 364, 182, 0, 1986, 1987, 5, 50, 0, 0, 1987, 1989, 3, 364, 182, 0, 1988, 1986, 1, 0, 0, 0, 1989, 1990, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1993, 1, 0, 0, 0, 1992, 1994, 5, 50, 0, 0, 1993, 1992, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 361, 1, 0, 0, 0, 1995, 2006, 3, 364, 182, 0, 1996, 2007, 5, 50, 0, 0, 1997, 1998, 5, 50, 0, 0, 1998, 2000, 3, 364, 182, 0, 1999, 1997, 1, 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 1999, 1, 0, 0, 0, 2001, 2002, 1, 0, 0, 0, 2002, 2004, 1, 0, 0, 0, 2003, 2005, 5, 50, 0, 0, 2004, 2003, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2007, 1, 0, 0, 0, 2006, 1996, 1, 0, 0, 0, 2006, 1999, 1, 0, 0, 0, 2007, 363, 1, 0, 0, 0, 2008, 2009, 5, 54, 0, 0, 2009, 2012, 3, 364, 182, 0, 2010, 2012, 3, 366, 183, 0, 2011, 2008, 1, 0, 0, 0, 2011, 2010, 1, 0, 0, 0, 2012, 365, 1, 0, 0, 0, 2013, 2020, 3, 374, 187, 0, 2014, 2015, 5, 48, 0, 0, 2015, 2021, 5, 90, 0, 0, 2016, 2017, 5, 43, 0, 0, 2017, 2018, 3, 274, 137, 0, 2018, 2019, 5, 46, 0, 0, 2019, 2021, 1, 0, 0, 0, 2020, 2014, 1, 0, 0, 0, 2020, 2016, 1, 0, 0, 0, 2021, 2024, 1, 0, 0, 0, 2022, 2024, 3, 368, 184, 0, 2023, 2013, 1, 0, 0, 0, 2023, 2022, 1, 0, 0, 0, 2024, 367, 1, 0, 0, 0, 2025, 2041, 5, 90, 0, 0, 2026, 2027, 5, 42, 0, 0, 2027, 2028, 3, 366, 183, 0, 2028, 2029, 5, 45, 0, 0, 2029, 2041, 1, 0, 0, 0, 2030, 2032, 5, 42, 0, 0, 2031, 2033, 3, 362, 181, 0, 2032, 2031, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2034, 1, 0, 0, 0, 2034, 2041, 5, 45, 0, 0, 2035, 2037, 5, 43, 0, 0, 2036, 2038, 3, 360, 180, 0, 2037, 2036, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2041, 5, 46, 0, 0, 2040, 2025, 1, 0, 0, 0, 2040, 2026, 1, 0, 0, 0, 2040, 2030, 1, 0, 0, 0, 2040, 2035, 1, 0, 0, 0, 2041, 369, 1, 0, 0, 0, 2042, 2049, 3, 372, 186, 0, 2043, 2049, 5, 90, 0, 0, 2044, 2045, 5, 42, 0, 0, 2045, 2046, 3, 370, 185, 0, 2046, 2047, 5, 45, 0, 0, 2047, 2049, 1, 0, 0, 0, 2048, 2042, 1, 0, 0, 0, 2048, 2043, 1, 0, 0, 0, 2048, 2044, 1, 0, 0, 0, 2049, 371, 1, 0, 0, 0, 2050, 2057, 3, 374, 187, 0, 2051, 2052, 5, 48, 0, 0, 2052, 2058, 5, 90, 0, 0, 2053, 2054, 5, 43, 0, 0, 2054, 2055, 3, 274, 137, 0, 2055, 2056, 5, 46, 0, 0, 2056, 2058, 1, 0, 0, 0, 2057, 2051, 1, 0, 0, 0, 2057, 2053, 1, 0, 0, 0, 2058, 373, 1, 0, 0, 0, 2059, 2060, 6, 187, -1, 0, 2060, 2061, 3, 278, 139, 0, 2061, 2079, 1, 0, 0, 0, 2062, 2075, 10, 2, 0, 0, 2063, 2064, 5, 48, 0, 0, 2064, 2076, 5, 90, 0, 0, 2065, 2066, 5, 43, 0, 0, 2066, 2067, 3, 274, 137, 0, 2067, 2068, 5, 46, 0, 0, 2068, 2076, 1, 0, 0, 0, 2069, 2076, 3, 342, 171, 0, 2070, 2072, 5, 42, 0, 0, 2071, 2073, 3, 346, 173, 0, 2072, 2071, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 2074, 1, 0, 0, 0, 2074, 2076, 5, 45, 0, 0, 2075, 2063, 1, 0, 0, 0, 2075, 2065, 1, 0, 0, 0, 2075, 2069, 1, 0, 0, 0, 2075, 2070, 1, 0, 0, 0, 2076, 2078, 1, 0, 0, 0, 2077, 2062, 1, 0, 0, 0, 2078, 2081, 1, 0, 0, 0, 2079, 2077, 1, 0, 0, 0, 2079, 2080, 1, 0, 0, 0, 2080, 375, 1, 0, 0, 0, 2081, 2079, 1, 0, 0, 0, 2082, 2087, 3, 378, 189, 0, 2083, 2084, 5, 50, 0, 0, 2084, 2086, 3, 378, 189, 0, 2085, 2083, 1, 0, 0, 0, 2086, 2089, 1, 0, 0, 0, 2087, 2085, 1, 0, 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2091, 1, 0, 0, 0, 2089, 2087, 1, 0, 0, 0, 2090, 2092, 5, 50, 0, 0, 2091, 2090, 1, 0, 0, 0, 2091, 2092, 1, 0, 0, 0, 2092, 377, 1, 0, 0, 0, 2093, 2100, 3, 374, 187, 0, 2094, 2095, 5, 48, 0, 0, 2095, 2101, 5, 90, 0, 0, 2096, 2097, 5, 43, 0, 0, 2097, 2098, 3, 274, 137, 0, 2098, 2099, 5, 46, 0, 0, 2099, 2101, 1, 0, 0, 0, 2100, 2094, 1, 0, 0, 0, 2100, 2096, 1, 0, 0, 0, 2101, 2104, 1, 0, 0, 0, 2102, 2104, 3, 380, 190, 0, 2103, 2093, 1, 0, 0, 0, 2103, 2102, 1, 0, 0, 0, 2104, 379, 1, 0, 0, 0, 2105, 2121, 5, 90, 0, 0, 2106, 2107, 5, 42, 0, 0, 2107, 2108, 3, 378, 189, 0, 2108, 2109, 5, 45, 0, 0, 2109, 2121, 1, 0, 0, 0, 2110, 2112, 5, 42, 0, 0, 2111, 2113, 3, 376, 188, 0, 2112, 2111, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2121, 5, 45, 0, 0, 2115, 2117, 5, 43, 0, 0, 2116, 2118, 3, 376, 188, 0, 2117, 2116, 1, 0, 0, 0, 2117, 2118, 1, 0, 0, 0, 2118, 2119, 1, 0, 0, 0, 2119, 2121, 5, 46, 0, 0, 2120, 2105, 1, 0, 0, 0, 2120, 2106, 1, 0, 0, 0, 2120, 2110, 1, 0, 0, 0, 2120, 2115, 1, 0, 0, 0, 2121, 381, 1, 0, 0, 0, 2122, 2127, 3, 208, 104, 0, 2123, 2124, 5, 50, 0, 0, 2124, 2126, 3, 208, 104, 0, 2125, 2123, 1, 0, 0, 0, 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2142, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2140, 5, 50, 0, 0, 2131, 2132, 5, 54, 0, 0, 2132, 2136, 3, 208, 104, 0, 2133, 2134, 5, 50, 0, 0, 2134, 2135, 5, 70, 0, 0, 2135, 2137, 3, 208, 104, 0, 2136, 2133, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2141, 1, 0, 0, 0, 2138, 2139, 5, 70, 0, 0, 2139, 2141, 3, 208, 104, 0, 2140, 2131, 1, 0, 0, 0, 2140, 2138, 1, 0, 0, 0, 2141, 2143, 1, 0, 0, 0, 2142, 2130, 1, 0, 0, 0, 2142, 2143, 1, 0, 0, 0, 2143, 2154, 1, 0, 0, 0, 2144, 2145, 5, 54, 0, 0, 2145, 2149, 3, 208, 104, 0, 2146, 2147, 5, 50, 0, 0, 2147, 2148, 5, 70, 0, 0, 2148, 2150, 3, 208, 104, 0, 2149, 2146, 1, 0, 0, 0, 2149, 2150, 1, 0, 0, 0, 2150, 2154, 1, 0, 0, 0, 2151, 2152, 5, 70, 0, 0, 2152, 2154, 3, 208, 104, 0, 2153, 2122, 1, 0, 0, 0, 2153, 2144, 1, 0, 0, 0, 2153, 2151, 1, 0, 0, 0, 2154, 383, 1, 0, 0, 0, 2155, 2156, 5, 93, 0, 0, 2156, 2159, 5, 3, 0, 0, 2157, 2159, 5, 3, 0, 0, 2158, 2155, 1, 0, 0, 0, 2158, 2157, 1, 0, 0, 0, 2159, 385, 1, 0, 0, 0, 2160, 2161, 4, 193, 9, 0, 2161, 2162, 5, 90, 0, 0, 2162, 387, 1, 0, 0, 0, 2163, 2164, 4, 194, 10, 0, 2164, 2165, 5, 90, 0, 0, 2165, 389, 1, 0, 0, 0, 2166, 2167, 4, 195, 11, 0, 2167, 2168, 5, 90, 0, 0, 2168, 391, 1, 0, 0, 0, 2169, 2170, 4, 196, 12, 0, 2170, 2171, 5, 90, 0, 0, 2171, 393, 1, 0, 0, 0, 2172, 2173, 4, 197, 13, 0, 2173, 2174, 5, 90, 0, 0, 2174, 395, 1, 0, 0, 0, 288, 397, 407, 414, 422, 432, 436, 444, 451, 455, 473, 483, 490, 497, 503, 510, 514, 517, 523, 525, 529, 535, 541, 543, 551, 560, 572, 576, 585, 596, 600, 605, 611, 618, 624, 631, 637, 647, 656, 664, 670, 675, 679, 682, 691, 696, 700, 705, 709, 716, 720, 725, 729, 732, 740, 746, 750, 756, 760, 765, 770, 774, 779, 782, 785, 790, 794, 799, 805, 809, 816, 820, 827, 831, 838, 841, 844, 851, 854, 858, 861, 866, 869, 873, 876, 879, 883, 903, 905, 913, 915, 926, 929, 937, 941, 944, 953, 957, 967, 972, 974, 981, 994, 997, 1000, 1008, 1011, 1014, 1016, 1022, 1024, 1034, 1051, 1058, 1061, 1066, 1076, 1080, 1091, 1102, 1110, 1118, 1125, 1130, 1151, 1158, 1167, 1172, 1175, 1180, 1187, 1191, 1195, 1205, 1213, 1216, 1220, 1227, 1232, 1245, 1248, 1251, 1253, 1262, 1270, 1280, 1294, 1298, 1302, 1308, 1318, 1322, 1330, 1333, 1339, 1341, 1348, 1352, 1357, 1364, 1368, 1373, 1381, 1388, 1396, 1402, 1408, 1421, 1463, 1474, 1485, 1496, 1507, 1518, 1528, 1533, 1538, 1549, 1556, 1560, 1566, 1571, 1575, 1579, 1581, 1584, 1588, 1592, 1594, 1597, 1608, 1612, 1618, 1621, 1626, 1632, 1643, 1649, 1653, 1659, 1663, 1668, 1673, 1677, 1682, 1685, 1688, 1693, 1697, 1702, 1708, 1712, 1719, 1723, 1730, 1733, 1736, 1743, 1748, 1752, 1755, 1761, 1766, 1769, 1772, 1775, 1786, 1791, 1797, 1806, 1808, 1812, 1820, 1822, 1832, 1841, 1845, 1850, 1859, 1862, 1872, 1888, 1900, 1905, 1907, 1913, 1915, 1919, 1924, 1927, 1934, 1943, 1946, 1953, 1956, 1965, 1972, 1979, 1983, 1990, 1993, 2001, 2004, 2006, 2011, 2020, 2023, 2032, 2037, 2040, 2048, 2057, 2072, 2075, 2079, 2087, 2091, 2100, 2103, 2112, 2117, 2120, 2127, 2136, 2140, 2142, 2149, 2153, 2158] \ No newline at end of file diff --git a/src/main/java/PythonParser.java b/src/main/java/PythonParser.java new file mode 100644 index 0000000..70c2104 --- /dev/null +++ b/src/main/java/PythonParser.java @@ -0,0 +1,18693 @@ +// Generated from PythonParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.FailedPredicateException; +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.TerminalNode; + +import java.util.List; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class PythonParser extends PythonParserBase { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + INDENT = 1, DEDENT = 2, TYPE_COMMENT = 3, FSTRING_START = 4, FSTRING_MIDDLE = 5, + FSTRING_END = 6, FALSE = 7, AWAIT = 8, ELSE = 9, IMPORT = 10, PASS = 11, NONE = 12, + BREAK = 13, EXCEPT = 14, IN = 15, RAISE = 16, TRUE = 17, CLASS = 18, FINALLY = 19, IS = 20, + RETURN = 21, AND = 22, CONTINUE = 23, FOR = 24, LAMBDA = 25, TRY = 26, AS = 27, DEF = 28, + FROM = 29, NONLOCAL = 30, WHILE = 31, ASSERT = 32, DEL = 33, GLOBAL = 34, NOT = 35, + WITH = 36, ASYNC = 37, ELIF = 38, IF = 39, OR = 40, YIELD = 41, LPAR = 42, LSQB = 43, + LBRACE = 44, RPAR = 45, RSQB = 46, RBRACE = 47, DOT = 48, COLON = 49, COMMA = 50, SEMI = 51, + PLUS = 52, MINUS = 53, STAR = 54, SLASH = 55, VBAR = 56, AMPER = 57, LESS = 58, GREATER = 59, + EQUAL = 60, PERCENT = 61, EQEQUAL = 62, NOTEQUAL = 63, LESSEQUAL = 64, GREATEREQUAL = 65, + TILDE = 66, CIRCUMFLEX = 67, LEFTSHIFT = 68, RIGHTSHIFT = 69, DOUBLESTAR = 70, PLUSEQUAL = 71, + MINEQUAL = 72, STAREQUAL = 73, SLASHEQUAL = 74, PERCENTEQUAL = 75, AMPEREQUAL = 76, + VBAREQUAL = 77, CIRCUMFLEXEQUAL = 78, LEFTSHIFTEQUAL = 79, RIGHTSHIFTEQUAL = 80, + DOUBLESTAREQUAL = 81, DOUBLESLASH = 82, DOUBLESLASHEQUAL = 83, AT = 84, ATEQUAL = 85, + RARROW = 86, ELLIPSIS = 87, COLONEQUAL = 88, EXCLAMATION = 89, NAME = 90, NUMBER = 91, + STRING = 92, NEWLINE = 93, COMMENT = 94, WS = 95, EXPLICIT_LINE_JOINING = 96, ERRORTOKEN = 97; + public static final int + RULE_file_input = 0, RULE_interactive = 1, RULE_eval = 2, RULE_func_type = 3, + RULE_fstring_input = 4, RULE_statements = 5, RULE_statement = 6, RULE_statement_newline = 7, + RULE_simple_stmts = 8, RULE_simple_stmt = 9, RULE_compound_stmt = 10, + RULE_assignment = 11, RULE_annotated_rhs = 12, RULE_augassign = 13, RULE_return_stmt = 14, + RULE_raise_stmt = 15, RULE_global_stmt = 16, RULE_nonlocal_stmt = 17, + RULE_del_stmt = 18, RULE_yield_stmt = 19, RULE_assert_stmt = 20, RULE_import_stmt = 21, + RULE_import_name = 22, RULE_import_from = 23, RULE_import_from_targets = 24, + RULE_import_from_as_names = 25, RULE_import_from_as_name = 26, RULE_dotted_as_names = 27, + RULE_dotted_as_name = 28, RULE_dotted_name = 29, RULE_block = 30, RULE_decorators = 31, + RULE_class_def = 32, RULE_class_def_raw = 33, RULE_function_def = 34, + RULE_function_def_raw = 35, RULE_params = 36, RULE_parameters = 37, RULE_slash_no_default = 38, + RULE_slash_with_default = 39, RULE_star_etc = 40, RULE_kwds = 41, RULE_param_no_default = 42, + RULE_param_no_default_star_annotation = 43, RULE_param_with_default = 44, + RULE_param_maybe_default = 45, RULE_param = 46, RULE_param_star_annotation = 47, + RULE_annotation = 48, RULE_star_annotation = 49, RULE_default_assignment = 50, + RULE_if_stmt = 51, RULE_elif_stmt = 52, RULE_else_block = 53, RULE_while_stmt = 54, + RULE_for_stmt = 55, RULE_with_stmt = 56, RULE_with_item = 57, RULE_try_stmt = 58, + RULE_except_block = 59, RULE_except_star_block = 60, RULE_finally_block = 61, + RULE_match_stmt = 62, RULE_subject_expr = 63, RULE_case_block = 64, RULE_guard = 65, + RULE_patterns = 66, RULE_pattern = 67, RULE_as_pattern = 68, RULE_or_pattern = 69, + RULE_closed_pattern = 70, RULE_literal_pattern = 71, RULE_literal_expr = 72, + RULE_complex_number = 73, RULE_signed_number = 74, RULE_signed_real_number = 75, + RULE_real_number = 76, RULE_imaginary_number = 77, RULE_capture_pattern = 78, + RULE_pattern_capture_target = 79, RULE_wildcard_pattern = 80, RULE_value_pattern = 81, + RULE_attr = 82, RULE_name_or_attr = 83, RULE_group_pattern = 84, RULE_sequence_pattern = 85, + RULE_open_sequence_pattern = 86, RULE_maybe_sequence_pattern = 87, RULE_maybe_star_pattern = 88, + RULE_star_pattern = 89, RULE_mapping_pattern = 90, RULE_items_pattern = 91, + RULE_key_value_pattern = 92, RULE_double_star_pattern = 93, RULE_class_pattern = 94, + RULE_positional_patterns = 95, RULE_keyword_patterns = 96, RULE_keyword_pattern = 97, + RULE_type_alias = 98, RULE_type_params = 99, RULE_type_param_seq = 100, + RULE_type_param = 101, RULE_type_param_bound = 102, RULE_expressions = 103, + RULE_expression = 104, RULE_yield_expr = 105, RULE_star_expressions = 106, + RULE_star_expression = 107, RULE_star_named_expressions = 108, RULE_star_named_expression = 109, + RULE_assignment_expression = 110, RULE_named_expression = 111, RULE_disjunction = 112, + RULE_conjunction = 113, RULE_inversion = 114, RULE_comparison = 115, RULE_compare_op_bitwise_or_pair = 116, + RULE_eq_bitwise_or = 117, RULE_noteq_bitwise_or = 118, RULE_lte_bitwise_or = 119, + RULE_lt_bitwise_or = 120, RULE_gte_bitwise_or = 121, RULE_gt_bitwise_or = 122, + RULE_notin_bitwise_or = 123, RULE_in_bitwise_or = 124, RULE_isnot_bitwise_or = 125, + RULE_is_bitwise_or = 126, RULE_bitwise_or = 127, RULE_bitwise_xor = 128, + RULE_bitwise_and = 129, RULE_shift_expr = 130, RULE_sum = 131, RULE_term = 132, + RULE_factor = 133, RULE_power = 134, RULE_await_primary = 135, RULE_primary = 136, + RULE_slices = 137, RULE_slice = 138, RULE_atom = 139, RULE_group = 140, + RULE_lambdef = 141, RULE_lambda_params = 142, RULE_lambda_parameters = 143, + RULE_lambda_slash_no_default = 144, RULE_lambda_slash_with_default = 145, + RULE_lambda_star_etc = 146, RULE_lambda_kwds = 147, RULE_lambda_param_no_default = 148, + RULE_lambda_param_with_default = 149, RULE_lambda_param_maybe_default = 150, + RULE_lambda_param = 151, RULE_fstring_middle = 152, RULE_fstring_replacement_field = 153, + RULE_fstring_conversion = 154, RULE_fstring_full_format_spec = 155, RULE_fstring_format_spec = 156, + RULE_fstring = 157, RULE_string = 158, RULE_strings = 159, RULE_list = 160, + RULE_tuple = 161, RULE_set = 162, RULE_dict = 163, RULE_double_starred_kvpairs = 164, + RULE_double_starred_kvpair = 165, RULE_kvpair = 166, RULE_for_if_clauses = 167, + RULE_for_if_clause = 168, RULE_listcomp = 169, RULE_setcomp = 170, RULE_genexp = 171, + RULE_dictcomp = 172, RULE_arguments = 173, RULE_args = 174, RULE_kwargs = 175, + RULE_starred_expression = 176, RULE_kwarg_or_starred = 177, RULE_kwarg_or_double_starred = 178, + RULE_star_targets = 179, RULE_star_targets_list_seq = 180, RULE_star_targets_tuple_seq = 181, + RULE_star_target = 182, RULE_target_with_star_atom = 183, RULE_star_atom = 184, + RULE_single_target = 185, RULE_single_subscript_attribute_target = 186, + RULE_t_primary = 187, RULE_del_targets = 188, RULE_del_target = 189, RULE_del_t_atom = 190, + RULE_type_expressions = 191, RULE_func_type_comment = 192, RULE_soft_kw_type = 193, + RULE_soft_kw_match = 194, RULE_soft_kw_case = 195, RULE_soft_kw_wildcard = 196, + RULE_soft_kw__not__wildcard = 197; + + private static String[] makeRuleNames() { + return new String[]{ + "file_input", "interactive", "eval", "func_type", "fstring_input", "statements", + "statement", "statement_newline", "simple_stmts", "simple_stmt", "compound_stmt", + "assignment", "annotated_rhs", "augassign", "return_stmt", "raise_stmt", + "global_stmt", "nonlocal_stmt", "del_stmt", "yield_stmt", "assert_stmt", + "import_stmt", "import_name", "import_from", "import_from_targets", "import_from_as_names", + "import_from_as_name", "dotted_as_names", "dotted_as_name", "dotted_name", + "block", "decorators", "class_def", "class_def_raw", "function_def", + "function_def_raw", "params", "parameters", "slash_no_default", "slash_with_default", + "star_etc", "kwds", "param_no_default", "param_no_default_star_annotation", + "param_with_default", "param_maybe_default", "param", "param_star_annotation", + "annotation", "star_annotation", "default_assignment", "if_stmt", "elif_stmt", + "else_block", "while_stmt", "for_stmt", "with_stmt", "with_item", "try_stmt", + "except_block", "except_star_block", "finally_block", "match_stmt", "subject_expr", + "case_block", "guard", "patterns", "pattern", "as_pattern", "or_pattern", + "closed_pattern", "literal_pattern", "literal_expr", "complex_number", + "signed_number", "signed_real_number", "real_number", "imaginary_number", + "capture_pattern", "pattern_capture_target", "wildcard_pattern", "value_pattern", + "attr", "name_or_attr", "group_pattern", "sequence_pattern", "open_sequence_pattern", + "maybe_sequence_pattern", "maybe_star_pattern", "star_pattern", "mapping_pattern", + "items_pattern", "key_value_pattern", "double_star_pattern", "class_pattern", + "positional_patterns", "keyword_patterns", "keyword_pattern", "type_alias", + "type_params", "type_param_seq", "type_param", "type_param_bound", "expressions", + "expression", "yield_expr", "star_expressions", "star_expression", "star_named_expressions", + "star_named_expression", "assignment_expression", "named_expression", + "disjunction", "conjunction", "inversion", "comparison", "compare_op_bitwise_or_pair", + "eq_bitwise_or", "noteq_bitwise_or", "lte_bitwise_or", "lt_bitwise_or", + "gte_bitwise_or", "gt_bitwise_or", "notin_bitwise_or", "in_bitwise_or", + "isnot_bitwise_or", "is_bitwise_or", "bitwise_or", "bitwise_xor", "bitwise_and", + "shift_expr", "sum", "term", "factor", "power", "await_primary", "primary", + "slices", "slice", "atom", "group", "lambdef", "lambda_params", "lambda_parameters", + "lambda_slash_no_default", "lambda_slash_with_default", "lambda_star_etc", + "lambda_kwds", "lambda_param_no_default", "lambda_param_with_default", + "lambda_param_maybe_default", "lambda_param", "fstring_middle", "fstring_replacement_field", + "fstring_conversion", "fstring_full_format_spec", "fstring_format_spec", + "fstring", "string", "strings", "list", "tuple", "set", "dict", "double_starred_kvpairs", + "double_starred_kvpair", "kvpair", "for_if_clauses", "for_if_clause", + "listcomp", "setcomp", "genexp", "dictcomp", "arguments", "args", "kwargs", + "starred_expression", "kwarg_or_starred", "kwarg_or_double_starred", + "star_targets", "star_targets_list_seq", "star_targets_tuple_seq", "star_target", + "target_with_star_atom", "star_atom", "single_target", "single_subscript_attribute_target", + "t_primary", "del_targets", "del_target", "del_t_atom", "type_expressions", + "func_type_comment", "soft_kw_type", "soft_kw_match", "soft_kw_case", + "soft_kw_wildcard", "soft_kw__not__wildcard" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + null, null, null, null, null, null, null, "'False'", "'await'", "'else'", + "'import'", "'pass'", "'None'", "'break'", "'except'", "'in'", "'raise'", + "'True'", "'class'", "'finally'", "'is'", "'return'", "'and'", "'continue'", + "'for'", "'lambda'", "'try'", "'as'", "'def'", "'from'", "'nonlocal'", + "'while'", "'assert'", "'del'", "'global'", "'not'", "'with'", "'async'", + "'elif'", "'if'", "'or'", "'yield'", "'('", "'['", null, "')'", "']'", + null, "'.'", "':'", "','", "';'", "'+'", "'-'", "'*'", "'/'", "'|'", + "'&'", "'<'", "'>'", "'='", "'%'", "'=='", "'!='", "'<='", "'>='", "'~'", + "'^'", "'<<'", "'>>'", "'**'", "'+='", "'-='", "'*='", "'/='", "'%='", + "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//'", "'//='", "'@'", + "'@='", "'->'", "'...'", "':='", "'!'" + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "INDENT", "DEDENT", "TYPE_COMMENT", "FSTRING_START", "FSTRING_MIDDLE", + "FSTRING_END", "FALSE", "AWAIT", "ELSE", "IMPORT", "PASS", "NONE", "BREAK", + "EXCEPT", "IN", "RAISE", "TRUE", "CLASS", "FINALLY", "IS", "RETURN", + "AND", "CONTINUE", "FOR", "LAMBDA", "TRY", "AS", "DEF", "FROM", "NONLOCAL", + "WHILE", "ASSERT", "DEL", "GLOBAL", "NOT", "WITH", "ASYNC", "ELIF", "IF", + "OR", "YIELD", "LPAR", "LSQB", "LBRACE", "RPAR", "RSQB", "RBRACE", "DOT", + "COLON", "COMMA", "SEMI", "PLUS", "MINUS", "STAR", "SLASH", "VBAR", "AMPER", + "LESS", "GREATER", "EQUAL", "PERCENT", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", + "GREATEREQUAL", "TILDE", "CIRCUMFLEX", "LEFTSHIFT", "RIGHTSHIFT", "DOUBLESTAR", + "PLUSEQUAL", "MINEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", + "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", + "DOUBLESTAREQUAL", "DOUBLESLASH", "DOUBLESLASHEQUAL", "AT", "ATEQUAL", + "RARROW", "ELLIPSIS", "COLONEQUAL", "EXCLAMATION", "NAME", "NUMBER", + "STRING", "NEWLINE", "COMMENT", "WS", "EXPLICIT_LINE_JOINING", "ERRORTOKEN" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { + return "PythonParser.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public PythonParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class File_inputContext extends ParserRuleContext { + public TerminalNode EOF() { + return getToken(PythonParser.EOF, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public File_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_file_input; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFile_input(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFile_input(this); + } + } + + public final File_inputContext file_input() throws RecognitionException { + File_inputContext _localctx = new File_inputContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_file_input); + try { + enterOuterAlt(_localctx, 1); + { + setState(397); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 0, _ctx)) { + case 1: { + setState(396); + statements(); + } + break; + } + setState(399); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InteractiveContext extends ParserRuleContext { + public Statement_newlineContext statement_newline() { + return getRuleContext(Statement_newlineContext.class, 0); + } + + public InteractiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_interactive; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterInteractive(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitInteractive(this); + } + } + + public final InteractiveContext interactive() throws RecognitionException { + InteractiveContext _localctx = new InteractiveContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_interactive); + try { + enterOuterAlt(_localctx, 1); + { + setState(401); + statement_newline(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EvalContext extends ParserRuleContext { + public ExpressionsContext expressions() { + return getRuleContext(ExpressionsContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(PythonParser.EOF, 0); + } + + public List NEWLINE() { + return getTokens(PythonParser.NEWLINE); + } + + public TerminalNode NEWLINE(int i) { + return getToken(PythonParser.NEWLINE, i); + } + + public EvalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_eval; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterEval(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitEval(this); + } + } + + public final EvalContext eval() throws RecognitionException { + EvalContext _localctx = new EvalContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_eval); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(403); + expressions(); + setState(407); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NEWLINE) { + { + { + setState(404); + match(NEWLINE); + } + } + setState(409); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(410); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_typeContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public TerminalNode RARROW() { + return getToken(PythonParser.RARROW, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(PythonParser.EOF, 0); + } + + public Type_expressionsContext type_expressions() { + return getRuleContext(Type_expressionsContext.class, 0); + } + + public List NEWLINE() { + return getTokens(PythonParser.NEWLINE); + } + + public TerminalNode NEWLINE(int i) { + return getToken(PythonParser.NEWLINE, i); + } + + public Func_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_func_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFunc_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFunc_type(this); + } + } + + public final Func_typeContext func_type() throws RecognitionException { + Func_typeContext _localctx = new Func_typeContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_func_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(412); + match(LPAR); + setState(414); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537681L) != 0)) { + { + setState(413); + type_expressions(); + } + } + + setState(416); + match(RPAR); + setState(417); + match(RARROW); + setState(418); + expression(); + setState(422); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NEWLINE) { + { + { + setState(419); + match(NEWLINE); + } + } + setState(424); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(425); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_inputContext extends ParserRuleContext { + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public Fstring_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_input; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFstring_input(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFstring_input(this); + } + } + + public final Fstring_inputContext fstring_input() throws RecognitionException { + Fstring_inputContext _localctx = new Fstring_inputContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_fstring_input); + try { + enterOuterAlt(_localctx, 1); + { + setState(427); + star_expressions(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementsContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public StatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statements; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStatements(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStatements(this); + } + } + + public final StatementsContext statements() throws RecognitionException { + StatementsContext _localctx = new StatementsContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_statements); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(430); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(429); + statement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(432); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 4, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementContext extends ParserRuleContext { + public Compound_stmtContext compound_stmt() { + return getRuleContext(Compound_stmtContext.class, 0); + } + + public Simple_stmtsContext simple_stmts() { + return getRuleContext(Simple_stmtsContext.class, 0); + } + + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStatement(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_statement); + try { + setState(436); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(434); + compound_stmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(435); + simple_stmts(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Statement_newlineContext extends ParserRuleContext { + public Compound_stmtContext compound_stmt() { + return getRuleContext(Compound_stmtContext.class, 0); + } + + public TerminalNode NEWLINE() { + return getToken(PythonParser.NEWLINE, 0); + } + + public Simple_stmtsContext simple_stmts() { + return getRuleContext(Simple_stmtsContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(PythonParser.EOF, 0); + } + + public Statement_newlineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_statement_newline; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStatement_newline(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStatement_newline(this); + } + } + + public final Statement_newlineContext statement_newline() throws RecognitionException { + Statement_newlineContext _localctx = new Statement_newlineContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_statement_newline); + try { + setState(444); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 6, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(438); + compound_stmt(); + setState(439); + match(NEWLINE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(441); + simple_stmts(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(442); + match(NEWLINE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(443); + match(EOF); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_stmtsContext extends ParserRuleContext { + public List simple_stmt() { + return getRuleContexts(Simple_stmtContext.class); + } + + public Simple_stmtContext simple_stmt(int i) { + return getRuleContext(Simple_stmtContext.class, i); + } + + public TerminalNode NEWLINE() { + return getToken(PythonParser.NEWLINE, 0); + } + + public List SEMI() { + return getTokens(PythonParser.SEMI); + } + + public TerminalNode SEMI(int i) { + return getToken(PythonParser.SEMI, i); + } + + public Simple_stmtsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simple_stmts; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSimple_stmts(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSimple_stmts(this); + } + } + + public final Simple_stmtsContext simple_stmts() throws RecognitionException { + Simple_stmtsContext _localctx = new Simple_stmtsContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_simple_stmts); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(446); + simple_stmt(); + setState(451); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 7, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(447); + match(SEMI); + setState(448); + simple_stmt(); + } + } + } + setState(453); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 7, _ctx); + } + setState(455); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMI) { + { + setState(454); + match(SEMI); + } + } + + setState(457); + match(NEWLINE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_stmtContext extends ParserRuleContext { + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class, 0); + } + + public Type_aliasContext type_alias() { + return getRuleContext(Type_aliasContext.class, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public Return_stmtContext return_stmt() { + return getRuleContext(Return_stmtContext.class, 0); + } + + public Import_stmtContext import_stmt() { + return getRuleContext(Import_stmtContext.class, 0); + } + + public Raise_stmtContext raise_stmt() { + return getRuleContext(Raise_stmtContext.class, 0); + } + + public TerminalNode PASS() { + return getToken(PythonParser.PASS, 0); + } + + public Del_stmtContext del_stmt() { + return getRuleContext(Del_stmtContext.class, 0); + } + + public Yield_stmtContext yield_stmt() { + return getRuleContext(Yield_stmtContext.class, 0); + } + + public Assert_stmtContext assert_stmt() { + return getRuleContext(Assert_stmtContext.class, 0); + } + + public TerminalNode BREAK() { + return getToken(PythonParser.BREAK, 0); + } + + public TerminalNode CONTINUE() { + return getToken(PythonParser.CONTINUE, 0); + } + + public Global_stmtContext global_stmt() { + return getRuleContext(Global_stmtContext.class, 0); + } + + public Nonlocal_stmtContext nonlocal_stmt() { + return getRuleContext(Nonlocal_stmtContext.class, 0); + } + + public Simple_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_simple_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSimple_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSimple_stmt(this); + } + } + + public final Simple_stmtContext simple_stmt() throws RecognitionException { + Simple_stmtContext _localctx = new Simple_stmtContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_simple_stmt); + try { + setState(473); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(459); + assignment(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(460); + type_alias(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(461); + star_expressions(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(462); + return_stmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(463); + import_stmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(464); + raise_stmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(465); + match(PASS); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(466); + del_stmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(467); + yield_stmt(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(468); + assert_stmt(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(469); + match(BREAK); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(470); + match(CONTINUE); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(471); + global_stmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(472); + nonlocal_stmt(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Compound_stmtContext extends ParserRuleContext { + public Function_defContext function_def() { + return getRuleContext(Function_defContext.class, 0); + } + + public If_stmtContext if_stmt() { + return getRuleContext(If_stmtContext.class, 0); + } + + public Class_defContext class_def() { + return getRuleContext(Class_defContext.class, 0); + } + + public With_stmtContext with_stmt() { + return getRuleContext(With_stmtContext.class, 0); + } + + public For_stmtContext for_stmt() { + return getRuleContext(For_stmtContext.class, 0); + } + + public Try_stmtContext try_stmt() { + return getRuleContext(Try_stmtContext.class, 0); + } + + public While_stmtContext while_stmt() { + return getRuleContext(While_stmtContext.class, 0); + } + + public Match_stmtContext match_stmt() { + return getRuleContext(Match_stmtContext.class, 0); + } + + public Compound_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_compound_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterCompound_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitCompound_stmt(this); + } + } + + public final Compound_stmtContext compound_stmt() throws RecognitionException { + Compound_stmtContext _localctx = new Compound_stmtContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_compound_stmt); + try { + setState(483); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 10, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(475); + function_def(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(476); + if_stmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(477); + class_def(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(478); + with_stmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(479); + for_stmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(480); + try_stmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(481); + while_stmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(482); + match_stmt(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssignmentContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List EQUAL() { + return getTokens(PythonParser.EQUAL); + } + + public TerminalNode EQUAL(int i) { + return getToken(PythonParser.EQUAL, i); + } + + public Annotated_rhsContext annotated_rhs() { + return getRuleContext(Annotated_rhsContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public Single_targetContext single_target() { + return getRuleContext(Single_targetContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Single_subscript_attribute_targetContext single_subscript_attribute_target() { + return getRuleContext(Single_subscript_attribute_targetContext.class, 0); + } + + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public List star_targets() { + return getRuleContexts(Star_targetsContext.class); + } + + public Star_targetsContext star_targets(int i) { + return getRuleContext(Star_targetsContext.class, i); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public AugassignContext augassign() { + return getRuleContext(AugassignContext.class, 0); + } + + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assignment; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAssignment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAssignment(this); + } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_assignment); + int _la; + try { + int _alt; + setState(525); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 18, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(485); + match(NAME); + setState(486); + match(COLON); + setState(487); + expression(); + setState(490); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EQUAL) { + { + setState(488); + match(EQUAL); + setState(489); + annotated_rhs(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(497); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 12, _ctx)) { + case 1: { + setState(492); + match(LPAR); + setState(493); + single_target(); + setState(494); + match(RPAR); + } + break; + case 2: { + setState(496); + single_subscript_attribute_target(); + } + break; + } + setState(499); + match(COLON); + setState(500); + expression(); + setState(503); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EQUAL) { + { + setState(501); + match(EQUAL); + setState(502); + annotated_rhs(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(508); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(505); + star_targets(); + setState(506); + match(EQUAL); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(510); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 14, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(514); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: { + setState(512); + yield_expr(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(513); + star_expressions(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == TYPE_COMMENT) { + { + setState(516); + match(TYPE_COMMENT); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(519); + single_target(); + setState(520); + augassign(); + setState(523); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: { + setState(521); + yield_expr(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(522); + star_expressions(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Annotated_rhsContext extends ParserRuleContext { + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public Annotated_rhsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotated_rhs; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAnnotated_rhs(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAnnotated_rhs(this); + } + } + + public final Annotated_rhsContext annotated_rhs() throws RecognitionException { + Annotated_rhsContext _localctx = new Annotated_rhsContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_annotated_rhs); + try { + setState(529); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: + enterOuterAlt(_localctx, 1); + { + setState(527); + yield_expr(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(528); + star_expressions(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AugassignContext extends ParserRuleContext { + public TerminalNode PLUSEQUAL() { + return getToken(PythonParser.PLUSEQUAL, 0); + } + + public TerminalNode MINEQUAL() { + return getToken(PythonParser.MINEQUAL, 0); + } + + public TerminalNode STAREQUAL() { + return getToken(PythonParser.STAREQUAL, 0); + } + + public TerminalNode ATEQUAL() { + return getToken(PythonParser.ATEQUAL, 0); + } + + public TerminalNode SLASHEQUAL() { + return getToken(PythonParser.SLASHEQUAL, 0); + } + + public TerminalNode PERCENTEQUAL() { + return getToken(PythonParser.PERCENTEQUAL, 0); + } + + public TerminalNode AMPEREQUAL() { + return getToken(PythonParser.AMPEREQUAL, 0); + } + + public TerminalNode VBAREQUAL() { + return getToken(PythonParser.VBAREQUAL, 0); + } + + public TerminalNode CIRCUMFLEXEQUAL() { + return getToken(PythonParser.CIRCUMFLEXEQUAL, 0); + } + + public TerminalNode LEFTSHIFTEQUAL() { + return getToken(PythonParser.LEFTSHIFTEQUAL, 0); + } + + public TerminalNode RIGHTSHIFTEQUAL() { + return getToken(PythonParser.RIGHTSHIFTEQUAL, 0); + } + + public TerminalNode DOUBLESTAREQUAL() { + return getToken(PythonParser.DOUBLESTAREQUAL, 0); + } + + public TerminalNode DOUBLESLASHEQUAL() { + return getToken(PythonParser.DOUBLESLASHEQUAL, 0); + } + + public AugassignContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_augassign; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAugassign(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAugassign(this); + } + } + + public final AugassignContext augassign() throws RecognitionException { + AugassignContext _localctx = new AugassignContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_augassign); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(531); + _la = _input.LA(1); + if (!(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & 22527L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Return_stmtContext extends ParserRuleContext { + public TerminalNode RETURN() { + return getToken(PythonParser.RETURN, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public Return_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_return_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterReturn_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitReturn_stmt(this); + } + } + + public final Return_stmtContext return_stmt() throws RecognitionException { + Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_return_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(533); + match(RETURN); + setState(535); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(534); + star_expressions(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Raise_stmtContext extends ParserRuleContext { + public TerminalNode RAISE() { + return getToken(PythonParser.RAISE, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode FROM() { + return getToken(PythonParser.FROM, 0); + } + + public Raise_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_raise_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterRaise_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitRaise_stmt(this); + } + } + + public final Raise_stmtContext raise_stmt() throws RecognitionException { + Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_raise_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(537); + match(RAISE); + setState(543); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(538); + expression(); + setState(541); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == FROM) { + { + setState(539); + match(FROM); + setState(540); + expression(); + } + } + + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Global_stmtContext extends ParserRuleContext { + public TerminalNode GLOBAL() { + return getToken(PythonParser.GLOBAL, 0); + } + + public List NAME() { + return getTokens(PythonParser.NAME); + } + + public TerminalNode NAME(int i) { + return getToken(PythonParser.NAME, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Global_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_global_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGlobal_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGlobal_stmt(this); + } + } + + public final Global_stmtContext global_stmt() throws RecognitionException { + Global_stmtContext _localctx = new Global_stmtContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_global_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(545); + match(GLOBAL); + setState(546); + match(NAME); + setState(551); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(547); + match(COMMA); + setState(548); + match(NAME); + } + } + setState(553); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Nonlocal_stmtContext extends ParserRuleContext { + public TerminalNode NONLOCAL() { + return getToken(PythonParser.NONLOCAL, 0); + } + + public List NAME() { + return getTokens(PythonParser.NAME); + } + + public TerminalNode NAME(int i) { + return getToken(PythonParser.NAME, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Nonlocal_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_nonlocal_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterNonlocal_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitNonlocal_stmt(this); + } + } + + public final Nonlocal_stmtContext nonlocal_stmt() throws RecognitionException { + Nonlocal_stmtContext _localctx = new Nonlocal_stmtContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_nonlocal_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(554); + match(NONLOCAL); + setState(555); + match(NAME); + setState(560); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(556); + match(COMMA); + setState(557); + match(NAME); + } + } + setState(562); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Del_stmtContext extends ParserRuleContext { + public TerminalNode DEL() { + return getToken(PythonParser.DEL, 0); + } + + public Del_targetsContext del_targets() { + return getRuleContext(Del_targetsContext.class, 0); + } + + public Del_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_del_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDel_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDel_stmt(this); + } + } + + public final Del_stmtContext del_stmt() throws RecognitionException { + Del_stmtContext _localctx = new Del_stmtContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_del_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(563); + match(DEL); + setState(564); + del_targets(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Yield_stmtContext extends ParserRuleContext { + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class, 0); + } + + public Yield_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_yield_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterYield_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitYield_stmt(this); + } + } + + public final Yield_stmtContext yield_stmt() throws RecognitionException { + Yield_stmtContext _localctx = new Yield_stmtContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_yield_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(566); + yield_expr(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assert_stmtContext extends ParserRuleContext { + public TerminalNode ASSERT() { + return getToken(PythonParser.ASSERT, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Assert_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assert_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAssert_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAssert_stmt(this); + } + } + + public final Assert_stmtContext assert_stmt() throws RecognitionException { + Assert_stmtContext _localctx = new Assert_stmtContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_assert_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(568); + match(ASSERT); + setState(569); + expression(); + setState(572); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(570); + match(COMMA); + setState(571); + expression(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_stmtContext extends ParserRuleContext { + public Import_nameContext import_name() { + return getRuleContext(Import_nameContext.class, 0); + } + + public Import_fromContext import_from() { + return getRuleContext(Import_fromContext.class, 0); + } + + public Import_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterImport_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitImport_stmt(this); + } + } + + public final Import_stmtContext import_stmt() throws RecognitionException { + Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_import_stmt); + try { + setState(576); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + enterOuterAlt(_localctx, 1); + { + setState(574); + import_name(); + } + break; + case FROM: + enterOuterAlt(_localctx, 2); + { + setState(575); + import_from(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_nameContext extends ParserRuleContext { + public TerminalNode IMPORT() { + return getToken(PythonParser.IMPORT, 0); + } + + public Dotted_as_namesContext dotted_as_names() { + return getRuleContext(Dotted_as_namesContext.class, 0); + } + + public Import_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterImport_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitImport_name(this); + } + } + + public final Import_nameContext import_name() throws RecognitionException { + Import_nameContext _localctx = new Import_nameContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_import_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(578); + match(IMPORT); + setState(579); + dotted_as_names(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_fromContext extends ParserRuleContext { + public TerminalNode FROM() { + return getToken(PythonParser.FROM, 0); + } + + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class, 0); + } + + public TerminalNode IMPORT() { + return getToken(PythonParser.IMPORT, 0); + } + + public Import_from_targetsContext import_from_targets() { + return getRuleContext(Import_from_targetsContext.class, 0); + } + + public List DOT() { + return getTokens(PythonParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(PythonParser.DOT, i); + } + + public List ELLIPSIS() { + return getTokens(PythonParser.ELLIPSIS); + } + + public TerminalNode ELLIPSIS(int i) { + return getToken(PythonParser.ELLIPSIS, i); + } + + public Import_fromContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_from; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterImport_from(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitImport_from(this); + } + } + + public final Import_fromContext import_from() throws RecognitionException { + Import_fromContext _localctx = new Import_fromContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_import_from); + int _la; + try { + setState(600); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 29, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(581); + match(FROM); + setState(585); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == DOT || _la == ELLIPSIS) { + { + { + setState(582); + _la = _input.LA(1); + if (!(_la == DOT || _la == ELLIPSIS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(587); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(588); + dotted_name(0); + setState(589); + match(IMPORT); + setState(590); + import_from_targets(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(592); + match(FROM); + setState(594); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(593); + _la = _input.LA(1); + if (!(_la == DOT || _la == ELLIPSIS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(596); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == DOT || _la == ELLIPSIS); + setState(598); + match(IMPORT); + setState(599); + import_from_targets(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_from_targetsContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public Import_from_as_namesContext import_from_as_names() { + return getRuleContext(Import_from_as_namesContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Import_from_targetsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_from_targets; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterImport_from_targets(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitImport_from_targets(this); + } + } + + public final Import_from_targetsContext import_from_targets() throws RecognitionException { + Import_from_targetsContext _localctx = new Import_from_targetsContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_import_from_targets); + int _la; + try { + setState(611); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAR: + enterOuterAlt(_localctx, 1); + { + setState(602); + match(LPAR); + setState(603); + import_from_as_names(); + setState(605); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(604); + match(COMMA); + } + } + + setState(607); + match(RPAR); + } + break; + case NAME: + enterOuterAlt(_localctx, 2); + { + setState(609); + import_from_as_names(); + } + break; + case STAR: + enterOuterAlt(_localctx, 3); + { + setState(610); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_from_as_namesContext extends ParserRuleContext { + public List import_from_as_name() { + return getRuleContexts(Import_from_as_nameContext.class); + } + + public Import_from_as_nameContext import_from_as_name(int i) { + return getRuleContext(Import_from_as_nameContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Import_from_as_namesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_from_as_names; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterImport_from_as_names(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitImport_from_as_names(this); + } + } + + public final Import_from_as_namesContext import_from_as_names() throws RecognitionException { + Import_from_as_namesContext _localctx = new Import_from_as_namesContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_import_from_as_names); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(613); + import_from_as_name(); + setState(618); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(614); + match(COMMA); + setState(615); + import_from_as_name(); + } + } + } + setState(620); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 32, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_from_as_nameContext extends ParserRuleContext { + public List NAME() { + return getTokens(PythonParser.NAME); + } + + public TerminalNode NAME(int i) { + return getToken(PythonParser.NAME, i); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public Import_from_as_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_import_from_as_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterImport_from_as_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitImport_from_as_name(this); + } + } + + public final Import_from_as_nameContext import_from_as_name() throws RecognitionException { + Import_from_as_nameContext _localctx = new Import_from_as_nameContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_import_from_as_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + match(NAME); + setState(624); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AS) { + { + setState(622); + match(AS); + setState(623); + match(NAME); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Dotted_as_namesContext extends ParserRuleContext { + public List dotted_as_name() { + return getRuleContexts(Dotted_as_nameContext.class); + } + + public Dotted_as_nameContext dotted_as_name(int i) { + return getRuleContext(Dotted_as_nameContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Dotted_as_namesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_dotted_as_names; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDotted_as_names(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDotted_as_names(this); + } + } + + public final Dotted_as_namesContext dotted_as_names() throws RecognitionException { + Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_dotted_as_names); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(626); + dotted_as_name(); + setState(631); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(627); + match(COMMA); + setState(628); + dotted_as_name(); + } + } + setState(633); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Dotted_as_nameContext extends ParserRuleContext { + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class, 0); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Dotted_as_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_dotted_as_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDotted_as_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDotted_as_name(this); + } + } + + public final Dotted_as_nameContext dotted_as_name() throws RecognitionException { + Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_dotted_as_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(634); + dotted_name(0); + setState(637); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AS) { + { + setState(635); + match(AS); + setState(636); + match(NAME); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Dotted_nameContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public Dotted_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_dotted_name; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDotted_name(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDotted_name(this); + } + } + + public final Dotted_nameContext dotted_name() throws RecognitionException { + return dotted_name(0); + } + + private Dotted_nameContext dotted_name(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, _parentState); + Dotted_nameContext _prevctx = _localctx; + int _startState = 58; + enterRecursionRule(_localctx, 58, RULE_dotted_name, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(640); + match(NAME); + } + _ctx.stop = _input.LT(-1); + setState(647); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new Dotted_nameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_dotted_name); + setState(642); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(643); + match(DOT); + setState(644); + match(NAME); + } + } + } + setState(649); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockContext extends ParserRuleContext { + public TerminalNode NEWLINE() { + return getToken(PythonParser.NEWLINE, 0); + } + + public TerminalNode INDENT() { + return getToken(PythonParser.INDENT, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public TerminalNode DEDENT() { + return getToken(PythonParser.DEDENT, 0); + } + + public Simple_stmtsContext simple_stmts() { + return getRuleContext(Simple_stmtsContext.class, 0); + } + + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitBlock(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_block); + try { + setState(656); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 37, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(650); + match(NEWLINE); + setState(651); + match(INDENT); + setState(652); + statements(); + setState(653); + match(DEDENT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(655); + simple_stmts(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecoratorsContext extends ParserRuleContext { + public List AT() { + return getTokens(PythonParser.AT); + } + + public TerminalNode AT(int i) { + return getToken(PythonParser.AT, i); + } + + public List named_expression() { + return getRuleContexts(Named_expressionContext.class); + } + + public Named_expressionContext named_expression(int i) { + return getRuleContext(Named_expressionContext.class, i); + } + + public List NEWLINE() { + return getTokens(PythonParser.NEWLINE); + } + + public TerminalNode NEWLINE(int i) { + return getToken(PythonParser.NEWLINE, i); + } + + public DecoratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_decorators; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDecorators(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDecorators(this); + } + } + + public final DecoratorsContext decorators() throws RecognitionException { + DecoratorsContext _localctx = new DecoratorsContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_decorators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(662); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(658); + match(AT); + setState(659); + named_expression(); + setState(660); + match(NEWLINE); + } + } + setState(664); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == AT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_defContext extends ParserRuleContext { + public DecoratorsContext decorators() { + return getRuleContext(DecoratorsContext.class, 0); + } + + public Class_def_rawContext class_def_raw() { + return getRuleContext(Class_def_rawContext.class, 0); + } + + public Class_defContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_def; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterClass_def(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitClass_def(this); + } + } + + public final Class_defContext class_def() throws RecognitionException { + Class_defContext _localctx = new Class_defContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_class_def); + try { + setState(670); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(666); + decorators(); + setState(667); + class_def_raw(); + } + break; + case CLASS: + enterOuterAlt(_localctx, 2); + { + setState(669); + class_def_raw(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_def_rawContext extends ParserRuleContext { + public TerminalNode CLASS() { + return getToken(PythonParser.CLASS, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Type_paramsContext type_params() { + return getRuleContext(Type_paramsContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class, 0); + } + + public Class_def_rawContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_def_raw; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterClass_def_raw(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitClass_def_raw(this); + } + } + + public final Class_def_rawContext class_def_raw() throws RecognitionException { + Class_def_rawContext _localctx = new Class_def_rawContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_class_def_raw); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(672); + match(CLASS); + setState(673); + match(NAME); + setState(675); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LSQB) { + { + setState(674); + type_params(); + } + } + + setState(682); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LPAR) { + { + setState(677); + match(LPAR); + setState(679); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537681L) != 0)) { + { + setState(678); + arguments(); + } + } + + setState(681); + match(RPAR); + } + } + + setState(684); + match(COLON); + setState(685); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_defContext extends ParserRuleContext { + public DecoratorsContext decorators() { + return getRuleContext(DecoratorsContext.class, 0); + } + + public Function_def_rawContext function_def_raw() { + return getRuleContext(Function_def_rawContext.class, 0); + } + + public Function_defContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_function_def; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFunction_def(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFunction_def(this); + } + } + + public final Function_defContext function_def() throws RecognitionException { + Function_defContext _localctx = new Function_defContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_function_def); + try { + setState(691); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(687); + decorators(); + setState(688); + function_def_raw(); + } + break; + case DEF: + case ASYNC: + enterOuterAlt(_localctx, 2); + { + setState(690); + function_def_raw(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_def_rawContext extends ParserRuleContext { + public TerminalNode DEF() { + return getToken(PythonParser.DEF, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Type_paramsContext type_params() { + return getRuleContext(Type_paramsContext.class, 0); + } + + public ParamsContext params() { + return getRuleContext(ParamsContext.class, 0); + } + + public TerminalNode RARROW() { + return getToken(PythonParser.RARROW, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Func_type_commentContext func_type_comment() { + return getRuleContext(Func_type_commentContext.class, 0); + } + + public TerminalNode ASYNC() { + return getToken(PythonParser.ASYNC, 0); + } + + public Function_def_rawContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_function_def_raw; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFunction_def_raw(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFunction_def_raw(this); + } + } + + public final Function_def_rawContext function_def_raw() throws RecognitionException { + Function_def_rawContext _localctx = new Function_def_rawContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_function_def_raw); + int _la; + try { + setState(732); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEF: + enterOuterAlt(_localctx, 1); + { + setState(693); + match(DEF); + setState(694); + match(NAME); + setState(696); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LSQB) { + { + setState(695); + type_params(); + } + } + + setState(698); + match(LPAR); + setState(700); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 68719542273L) != 0)) { + { + setState(699); + params(); + } + } + + setState(702); + match(RPAR); + setState(705); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == RARROW) { + { + setState(703); + match(RARROW); + setState(704); + expression(); + } + } + + setState(707); + match(COLON); + setState(709); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 47, _ctx)) { + case 1: { + setState(708); + func_type_comment(); + } + break; + } + setState(711); + block(); + } + break; + case ASYNC: + enterOuterAlt(_localctx, 2); + { + setState(712); + match(ASYNC); + setState(713); + match(DEF); + setState(714); + match(NAME); + setState(716); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LSQB) { + { + setState(715); + type_params(); + } + } + + setState(718); + match(LPAR); + setState(720); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 68719542273L) != 0)) { + { + setState(719); + params(); + } + } + + setState(722); + match(RPAR); + setState(725); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == RARROW) { + { + setState(723); + match(RARROW); + setState(724); + expression(); + } + } + + setState(727); + match(COLON); + setState(729); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 51, _ctx)) { + case 1: { + setState(728); + func_type_comment(); + } + break; + } + setState(731); + block(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParamsContext extends ParserRuleContext { + public ParametersContext parameters() { + return getRuleContext(ParametersContext.class, 0); + } + + public ParamsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_params; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterParams(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitParams(this); + } + } + + public final ParamsContext params() throws RecognitionException { + ParamsContext _localctx = new ParamsContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_params); + try { + enterOuterAlt(_localctx, 1); + { + setState(734); + parameters(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParametersContext extends ParserRuleContext { + public Slash_no_defaultContext slash_no_default() { + return getRuleContext(Slash_no_defaultContext.class, 0); + } + + public List param_no_default() { + return getRuleContexts(Param_no_defaultContext.class); + } + + public Param_no_defaultContext param_no_default(int i) { + return getRuleContext(Param_no_defaultContext.class, i); + } + + public List param_with_default() { + return getRuleContexts(Param_with_defaultContext.class); + } + + public Param_with_defaultContext param_with_default(int i) { + return getRuleContext(Param_with_defaultContext.class, i); + } + + public Star_etcContext star_etc() { + return getRuleContext(Star_etcContext.class, 0); + } + + public Slash_with_defaultContext slash_with_default() { + return getRuleContext(Slash_with_defaultContext.class, 0); + } + + public ParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_parameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitParameters(this); + } + } + + public final ParametersContext parameters() throws RecognitionException { + ParametersContext _localctx = new ParametersContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_parameters); + int _la; + try { + int _alt; + setState(785); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 63, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(736); + slash_no_default(); + setState(740); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 53, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(737); + param_no_default(); + } + } + } + setState(742); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 53, _ctx); + } + setState(746); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(743); + param_with_default(); + } + } + setState(748); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(750); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(749); + star_etc(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(752); + slash_with_default(); + setState(756); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(753); + param_with_default(); + } + } + setState(758); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(760); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(759); + star_etc(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(763); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(762); + param_no_default(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(765); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 58, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(770); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(767); + param_with_default(); + } + } + setState(772); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(774); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(773); + star_etc(); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(777); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(776); + param_with_default(); + } + } + setState(779); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(782); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(781); + star_etc(); + } + } + + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(784); + star_etc(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Slash_no_defaultContext extends ParserRuleContext { + public TerminalNode SLASH() { + return getToken(PythonParser.SLASH, 0); + } + + public List param_no_default() { + return getRuleContexts(Param_no_defaultContext.class); + } + + public Param_no_defaultContext param_no_default(int i) { + return getRuleContext(Param_no_defaultContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Slash_no_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_slash_no_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSlash_no_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSlash_no_default(this); + } + } + + public final Slash_no_defaultContext slash_no_default() throws RecognitionException { + Slash_no_defaultContext _localctx = new Slash_no_defaultContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_slash_no_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(788); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(787); + param_no_default(); + } + } + setState(790); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(792); + match(SLASH); + setState(794); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(793); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Slash_with_defaultContext extends ParserRuleContext { + public TerminalNode SLASH() { + return getToken(PythonParser.SLASH, 0); + } + + public List param_no_default() { + return getRuleContexts(Param_no_defaultContext.class); + } + + public Param_no_defaultContext param_no_default(int i) { + return getRuleContext(Param_no_defaultContext.class, i); + } + + public List param_with_default() { + return getRuleContexts(Param_with_defaultContext.class); + } + + public Param_with_defaultContext param_with_default(int i) { + return getRuleContext(Param_with_defaultContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Slash_with_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_slash_with_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterSlash_with_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitSlash_with_default(this); + } + } + + public final Slash_with_defaultContext slash_with_default() throws RecognitionException { + Slash_with_defaultContext _localctx = new Slash_with_defaultContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_slash_with_default); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(799); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(796); + param_no_default(); + } + } + } + setState(801); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); + } + setState(803); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(802); + param_with_default(); + } + } + setState(805); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(807); + match(SLASH); + setState(809); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(808); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_etcContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Param_no_defaultContext param_no_default() { + return getRuleContext(Param_no_defaultContext.class, 0); + } + + public List param_maybe_default() { + return getRuleContexts(Param_maybe_defaultContext.class); + } + + public Param_maybe_defaultContext param_maybe_default(int i) { + return getRuleContext(Param_maybe_defaultContext.class, i); + } + + public KwdsContext kwds() { + return getRuleContext(KwdsContext.class, 0); + } + + public Param_no_default_star_annotationContext param_no_default_star_annotation() { + return getRuleContext(Param_no_default_star_annotationContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Star_etcContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_etc; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_etc(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_etc(this); + } + } + + public final Star_etcContext star_etc() throws RecognitionException { + Star_etcContext _localctx = new Star_etcContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_star_etc); + int _la; + try { + setState(844); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 75, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(811); + match(STAR); + setState(812); + param_no_default(); + setState(816); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(813); + param_maybe_default(); + } + } + setState(818); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(820); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == DOUBLESTAR) { + { + setState(819); + kwds(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(822); + match(STAR); + setState(823); + param_no_default_star_annotation(); + setState(827); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(824); + param_maybe_default(); + } + } + setState(829); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(831); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == DOUBLESTAR) { + { + setState(830); + kwds(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(833); + match(STAR); + setState(834); + match(COMMA); + setState(836); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(835); + param_maybe_default(); + } + } + setState(838); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(841); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == DOUBLESTAR) { + { + setState(840); + kwds(); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(843); + kwds(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KwdsContext extends ParserRuleContext { + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Param_no_defaultContext param_no_default() { + return getRuleContext(Param_no_defaultContext.class, 0); + } + + public KwdsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kwds; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKwds(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKwds(this); + } + } + + public final KwdsContext kwds() throws RecognitionException { + KwdsContext _localctx = new KwdsContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_kwds); + try { + enterOuterAlt(_localctx, 1); + { + setState(846); + match(DOUBLESTAR); + setState(847); + param_no_default(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_no_defaultContext extends ParserRuleContext { + public ParamContext param() { + return getRuleContext(ParamContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Param_no_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param_no_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterParam_no_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitParam_no_default(this); + } + } + + public final Param_no_defaultContext param_no_default() throws RecognitionException { + Param_no_defaultContext _localctx = new Param_no_defaultContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_param_no_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(849); + param(); + setState(851); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(850); + match(COMMA); + } + } + + setState(854); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == TYPE_COMMENT) { + { + setState(853); + match(TYPE_COMMENT); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_no_default_star_annotationContext extends ParserRuleContext { + public Param_star_annotationContext param_star_annotation() { + return getRuleContext(Param_star_annotationContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Param_no_default_star_annotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param_no_default_star_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterParam_no_default_star_annotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitParam_no_default_star_annotation(this); + } + } + + public final Param_no_default_star_annotationContext param_no_default_star_annotation() throws RecognitionException { + Param_no_default_star_annotationContext _localctx = new Param_no_default_star_annotationContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_param_no_default_star_annotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(856); + param_star_annotation(); + setState(858); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(857); + match(COMMA); + } + } + + setState(861); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == TYPE_COMMENT) { + { + setState(860); + match(TYPE_COMMENT); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_with_defaultContext extends ParserRuleContext { + public ParamContext param() { + return getRuleContext(ParamContext.class, 0); + } + + public Default_assignmentContext default_assignment() { + return getRuleContext(Default_assignmentContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Param_with_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param_with_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterParam_with_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitParam_with_default(this); + } + } + + public final Param_with_defaultContext param_with_default() throws RecognitionException { + Param_with_defaultContext _localctx = new Param_with_defaultContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_param_with_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(863); + param(); + setState(864); + default_assignment(); + setState(866); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(865); + match(COMMA); + } + } + + setState(869); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == TYPE_COMMENT) { + { + setState(868); + match(TYPE_COMMENT); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_maybe_defaultContext extends ParserRuleContext { + public ParamContext param() { + return getRuleContext(ParamContext.class, 0); + } + + public Default_assignmentContext default_assignment() { + return getRuleContext(Default_assignmentContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Param_maybe_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param_maybe_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterParam_maybe_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitParam_maybe_default(this); + } + } + + public final Param_maybe_defaultContext param_maybe_default() throws RecognitionException { + Param_maybe_defaultContext _localctx = new Param_maybe_defaultContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_param_maybe_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(871); + param(); + setState(873); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EQUAL) { + { + setState(872); + default_assignment(); + } + } + + setState(876); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(875); + match(COMMA); + } + } + + setState(879); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == TYPE_COMMENT) { + { + setState(878); + match(TYPE_COMMENT); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParamContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public ParamContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterParam(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitParam(this); + } + } + + public final ParamContext param() throws RecognitionException { + ParamContext _localctx = new ParamContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_param); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(881); + match(NAME); + setState(883); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(882); + annotation(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_star_annotationContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Star_annotationContext star_annotation() { + return getRuleContext(Star_annotationContext.class, 0); + } + + public Param_star_annotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_param_star_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterParam_star_annotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitParam_star_annotation(this); + } + } + + public final Param_star_annotationContext param_star_annotation() throws RecognitionException { + Param_star_annotationContext _localctx = new Param_star_annotationContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_param_star_annotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(885); + match(NAME); + setState(886); + star_annotation(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnnotationContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAnnotation(this); + } + } + + public final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_annotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(888); + match(COLON); + setState(889); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_annotationContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public Star_expressionContext star_expression() { + return getRuleContext(Star_expressionContext.class, 0); + } + + public Star_annotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_annotation; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_annotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_annotation(this); + } + } + + public final Star_annotationContext star_annotation() throws RecognitionException { + Star_annotationContext _localctx = new Star_annotationContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_star_annotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(891); + match(COLON); + setState(892); + star_expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Default_assignmentContext extends ParserRuleContext { + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Default_assignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_default_assignment; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterDefault_assignment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitDefault_assignment(this); + } + } + + public final Default_assignmentContext default_assignment() throws RecognitionException { + Default_assignmentContext _localctx = new Default_assignmentContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_default_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(894); + match(EQUAL); + setState(895); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class If_stmtContext extends ParserRuleContext { + public TerminalNode IF() { + return getToken(PythonParser.IF, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Elif_stmtContext elif_stmt() { + return getRuleContext(Elif_stmtContext.class, 0); + } + + public Else_blockContext else_block() { + return getRuleContext(Else_blockContext.class, 0); + } + + public If_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_if_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterIf_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitIf_stmt(this); + } + } + + public final If_stmtContext if_stmt() throws RecognitionException { + If_stmtContext _localctx = new If_stmtContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_if_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(897); + match(IF); + setState(898); + named_expression(); + setState(899); + match(COLON); + setState(900); + block(); + setState(905); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 87, _ctx)) { + case 1: { + setState(901); + elif_stmt(); + } + break; + case 2: { + setState(903); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 86, _ctx)) { + case 1: { + setState(902); + else_block(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Elif_stmtContext extends ParserRuleContext { + public TerminalNode ELIF() { + return getToken(PythonParser.ELIF, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Elif_stmtContext elif_stmt() { + return getRuleContext(Elif_stmtContext.class, 0); + } + + public Else_blockContext else_block() { + return getRuleContext(Else_blockContext.class, 0); + } + + public Elif_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_elif_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterElif_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitElif_stmt(this); + } + } + + public final Elif_stmtContext elif_stmt() throws RecognitionException { + Elif_stmtContext _localctx = new Elif_stmtContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_elif_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(907); + match(ELIF); + setState(908); + named_expression(); + setState(909); + match(COLON); + setState(910); + block(); + setState(915); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 89, _ctx)) { + case 1: { + setState(911); + elif_stmt(); + } + break; + case 2: { + setState(913); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 88, _ctx)) { + case 1: { + setState(912); + else_block(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Else_blockContext extends ParserRuleContext { + public TerminalNode ELSE() { + return getToken(PythonParser.ELSE, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Else_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_else_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterElse_block(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitElse_block(this); + } + } + + public final Else_blockContext else_block() throws RecognitionException { + Else_blockContext _localctx = new Else_blockContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_else_block); + try { + enterOuterAlt(_localctx, 1); + { + setState(917); + match(ELSE); + setState(918); + match(COLON); + setState(919); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class While_stmtContext extends ParserRuleContext { + public TerminalNode WHILE() { + return getToken(PythonParser.WHILE, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Else_blockContext else_block() { + return getRuleContext(Else_blockContext.class, 0); + } + + public While_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_while_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterWhile_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitWhile_stmt(this); + } + } + + public final While_stmtContext while_stmt() throws RecognitionException { + While_stmtContext _localctx = new While_stmtContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_while_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(921); + match(WHILE); + setState(922); + named_expression(); + setState(923); + match(COLON); + setState(924); + block(); + setState(926); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 90, _ctx)) { + case 1: { + setState(925); + else_block(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_stmtContext extends ParserRuleContext { + public TerminalNode FOR() { + return getToken(PythonParser.FOR, 0); + } + + public Star_targetsContext star_targets() { + return getRuleContext(Star_targetsContext.class, 0); + } + + public TerminalNode IN() { + return getToken(PythonParser.IN, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASYNC() { + return getToken(PythonParser.ASYNC, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Else_blockContext else_block() { + return getRuleContext(Else_blockContext.class, 0); + } + + public For_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_for_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFor_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFor_stmt(this); + } + } + + public final For_stmtContext for_stmt() throws RecognitionException { + For_stmtContext _localctx = new For_stmtContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_for_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(929); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASYNC) { + { + setState(928); + match(ASYNC); + } + } + + setState(931); + match(FOR); + setState(932); + star_targets(); + setState(933); + match(IN); + setState(934); + star_expressions(); + setState(935); + match(COLON); + setState(937); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 92, _ctx)) { + case 1: { + setState(936); + match(TYPE_COMMENT); + } + break; + } + setState(939); + block(); + setState(941); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 93, _ctx)) { + case 1: { + setState(940); + else_block(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class With_stmtContext extends ParserRuleContext { + public TerminalNode WITH() { + return getToken(PythonParser.WITH, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public List with_item() { + return getRuleContexts(With_itemContext.class); + } + + public With_itemContext with_item(int i) { + return getRuleContext(With_itemContext.class, i); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public TerminalNode ASYNC() { + return getToken(PythonParser.ASYNC, 0); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public With_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_with_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterWith_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitWith_stmt(this); + } + } + + public final With_stmtContext with_stmt() throws RecognitionException { + With_stmtContext _localctx = new With_stmtContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_with_stmt); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(944); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASYNC) { + { + setState(943); + match(ASYNC); + } + } + + setState(946); + match(WITH); + setState(974); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 99, _ctx)) { + case 1: { + setState(947); + match(LPAR); + setState(948); + with_item(); + setState(953); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 95, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(949); + match(COMMA); + setState(950); + with_item(); + } + } + } + setState(955); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 95, _ctx); + } + setState(957); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(956); + match(COMMA); + } + } + + setState(959); + match(RPAR); + setState(960); + match(COLON); + } + break; + case 2: { + setState(962); + with_item(); + setState(967); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(963); + match(COMMA); + setState(964); + with_item(); + } + } + setState(969); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(970); + match(COLON); + setState(972); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 98, _ctx)) { + case 1: { + setState(971); + match(TYPE_COMMENT); + } + break; + } + } + break; + } + setState(976); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class With_itemContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public Star_targetContext star_target() { + return getRuleContext(Star_targetContext.class, 0); + } + + public With_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_with_item; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterWith_item(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitWith_item(this); + } + } + + public final With_itemContext with_item() throws RecognitionException { + With_itemContext _localctx = new With_itemContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_with_item); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(978); + expression(); + setState(981); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AS) { + { + setState(979); + match(AS); + setState(980); + star_target(); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Try_stmtContext extends ParserRuleContext { + public TerminalNode TRY() { + return getToken(PythonParser.TRY, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Finally_blockContext finally_block() { + return getRuleContext(Finally_blockContext.class, 0); + } + + public List except_block() { + return getRuleContexts(Except_blockContext.class); + } + + public Except_blockContext except_block(int i) { + return getRuleContext(Except_blockContext.class, i); + } + + public Else_blockContext else_block() { + return getRuleContext(Else_blockContext.class, 0); + } + + public List except_star_block() { + return getRuleContexts(Except_star_blockContext.class); + } + + public Except_star_blockContext except_star_block(int i) { + return getRuleContext(Except_star_blockContext.class, i); + } + + public Try_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_try_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterTry_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitTry_stmt(this); + } + } + + public final Try_stmtContext try_stmt() throws RecognitionException { + Try_stmtContext _localctx = new Try_stmtContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_try_stmt); + try { + int _alt; + setState(1016); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 107, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(983); + match(TRY); + setState(984); + match(COLON); + setState(985); + block(); + setState(986); + finally_block(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(988); + match(TRY); + setState(989); + match(COLON); + setState(990); + block(); + setState(992); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(991); + except_block(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(994); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 101, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(997); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 102, _ctx)) { + case 1: { + setState(996); + else_block(); + } + break; + } + setState(1000); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 103, _ctx)) { + case 1: { + setState(999); + finally_block(); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1002); + match(TRY); + setState(1003); + match(COLON); + setState(1004); + block(); + setState(1006); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1005); + except_star_block(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1008); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 104, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1011); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 105, _ctx)) { + case 1: { + setState(1010); + else_block(); + } + break; + } + setState(1014); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 106, _ctx)) { + case 1: { + setState(1013); + finally_block(); + } + break; + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Except_blockContext extends ParserRuleContext { + public TerminalNode EXCEPT() { + return getToken(PythonParser.EXCEPT, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Except_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_except_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterExcept_block(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitExcept_block(this); + } + } + + public final Except_blockContext except_block() throws RecognitionException { + Except_blockContext _localctx = new Except_blockContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_except_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1018); + match(EXCEPT); + setState(1024); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1019); + expression(); + setState(1022); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AS) { + { + setState(1020); + match(AS); + setState(1021); + match(NAME); + } + } + + } + } + + setState(1026); + match(COLON); + setState(1027); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Except_star_blockContext extends ParserRuleContext { + public TerminalNode EXCEPT() { + return getToken(PythonParser.EXCEPT, 0); + } + + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Except_star_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_except_star_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterExcept_star_block(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitExcept_star_block(this); + } + } + + public final Except_star_blockContext except_star_block() throws RecognitionException { + Except_star_blockContext _localctx = new Except_star_blockContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_except_star_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1029); + match(EXCEPT); + setState(1030); + match(STAR); + setState(1031); + expression(); + setState(1034); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AS) { + { + setState(1032); + match(AS); + setState(1033); + match(NAME); + } + } + + setState(1036); + match(COLON); + setState(1037); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Finally_blockContext extends ParserRuleContext { + public TerminalNode FINALLY() { + return getToken(PythonParser.FINALLY, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public Finally_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_finally_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFinally_block(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFinally_block(this); + } + } + + public final Finally_blockContext finally_block() throws RecognitionException { + Finally_blockContext _localctx = new Finally_blockContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_finally_block); + try { + enterOuterAlt(_localctx, 1); + { + setState(1039); + match(FINALLY); + setState(1040); + match(COLON); + setState(1041); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Match_stmtContext extends ParserRuleContext { + public Soft_kw_matchContext soft_kw_match() { + return getRuleContext(Soft_kw_matchContext.class, 0); + } + + public Subject_exprContext subject_expr() { + return getRuleContext(Subject_exprContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public TerminalNode NEWLINE() { + return getToken(PythonParser.NEWLINE, 0); + } + + public TerminalNode INDENT() { + return getToken(PythonParser.INDENT, 0); + } + + public TerminalNode DEDENT() { + return getToken(PythonParser.DEDENT, 0); + } + + public List case_block() { + return getRuleContexts(Case_blockContext.class); + } + + public Case_blockContext case_block(int i) { + return getRuleContext(Case_blockContext.class, i); + } + + public Match_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_match_stmt; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterMatch_stmt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitMatch_stmt(this); + } + } + + public final Match_stmtContext match_stmt() throws RecognitionException { + Match_stmtContext _localctx = new Match_stmtContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_match_stmt); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1043); + soft_kw_match(); + setState(1044); + subject_expr(); + setState(1045); + match(COLON); + setState(1046); + match(NEWLINE); + setState(1047); + match(INDENT); + setState(1049); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1048); + case_block(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1051); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 111, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1053); + match(DEDENT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Subject_exprContext extends ParserRuleContext { + public Star_named_expressionContext star_named_expression() { + return getRuleContext(Star_named_expressionContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Star_named_expressionsContext star_named_expressions() { + return getRuleContext(Star_named_expressionsContext.class, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public Subject_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_subject_expr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSubject_expr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSubject_expr(this); + } + } + + public final Subject_exprContext subject_expr() throws RecognitionException { + Subject_exprContext _localctx = new Subject_exprContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_subject_expr); + int _la; + try { + setState(1061); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 113, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1055); + star_named_expression(); + setState(1056); + match(COMMA); + setState(1058); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1057); + star_named_expressions(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1060); + named_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_blockContext extends ParserRuleContext { + public Soft_kw_caseContext soft_kw_case() { + return getRuleContext(Soft_kw_caseContext.class, 0); + } + + public PatternsContext patterns() { + return getRuleContext(PatternsContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public GuardContext guard() { + return getRuleContext(GuardContext.class, 0); + } + + public Case_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_case_block; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterCase_block(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitCase_block(this); + } + } + + public final Case_blockContext case_block() throws RecognitionException { + Case_blockContext _localctx = new Case_blockContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_case_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1063); + soft_kw_case(); + setState(1064); + patterns(); + setState(1066); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == IF) { + { + setState(1065); + guard(); + } + } + + setState(1068); + match(COLON); + setState(1069); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GuardContext extends ParserRuleContext { + public TerminalNode IF() { + return getToken(PythonParser.IF, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public GuardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_guard; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGuard(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGuard(this); + } + } + + public final GuardContext guard() throws RecognitionException { + GuardContext _localctx = new GuardContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_guard); + try { + enterOuterAlt(_localctx, 1); + { + setState(1071); + match(IF); + setState(1072); + named_expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PatternsContext extends ParserRuleContext { + public Open_sequence_patternContext open_sequence_pattern() { + return getRuleContext(Open_sequence_patternContext.class, 0); + } + + public PatternContext pattern() { + return getRuleContext(PatternContext.class, 0); + } + + public PatternsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_patterns; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterPatterns(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitPatterns(this); + } + } + + public final PatternsContext patterns() throws RecognitionException { + PatternsContext _localctx = new PatternsContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_patterns); + try { + setState(1076); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 115, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1074); + open_sequence_pattern(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1075); + pattern(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PatternContext extends ParserRuleContext { + public As_patternContext as_pattern() { + return getRuleContext(As_patternContext.class, 0); + } + + public Or_patternContext or_pattern() { + return getRuleContext(Or_patternContext.class, 0); + } + + public PatternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterPattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitPattern(this); + } + } + + public final PatternContext pattern() throws RecognitionException { + PatternContext _localctx = new PatternContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_pattern); + try { + setState(1080); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 116, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1078); + as_pattern(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1079); + or_pattern(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class As_patternContext extends ParserRuleContext { + public Or_patternContext or_pattern() { + return getRuleContext(Or_patternContext.class, 0); + } + + public TerminalNode AS() { + return getToken(PythonParser.AS, 0); + } + + public Pattern_capture_targetContext pattern_capture_target() { + return getRuleContext(Pattern_capture_targetContext.class, 0); + } + + public As_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_as_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAs_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAs_pattern(this); + } + } + + public final As_patternContext as_pattern() throws RecognitionException { + As_patternContext _localctx = new As_patternContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_as_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1082); + or_pattern(); + setState(1083); + match(AS); + setState(1084); + pattern_capture_target(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Or_patternContext extends ParserRuleContext { + public List closed_pattern() { + return getRuleContexts(Closed_patternContext.class); + } + + public Closed_patternContext closed_pattern(int i) { + return getRuleContext(Closed_patternContext.class, i); + } + + public List VBAR() { + return getTokens(PythonParser.VBAR); + } + + public TerminalNode VBAR(int i) { + return getToken(PythonParser.VBAR, i); + } + + public Or_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_or_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterOr_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitOr_pattern(this); + } + } + + public final Or_patternContext or_pattern() throws RecognitionException { + Or_patternContext _localctx = new Or_patternContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_or_pattern); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1086); + closed_pattern(); + setState(1091); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == VBAR) { + { + { + setState(1087); + match(VBAR); + setState(1088); + closed_pattern(); + } + } + setState(1093); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Closed_patternContext extends ParserRuleContext { + public Literal_patternContext literal_pattern() { + return getRuleContext(Literal_patternContext.class, 0); + } + + public Capture_patternContext capture_pattern() { + return getRuleContext(Capture_patternContext.class, 0); + } + + public Wildcard_patternContext wildcard_pattern() { + return getRuleContext(Wildcard_patternContext.class, 0); + } + + public Value_patternContext value_pattern() { + return getRuleContext(Value_patternContext.class, 0); + } + + public Group_patternContext group_pattern() { + return getRuleContext(Group_patternContext.class, 0); + } + + public Sequence_patternContext sequence_pattern() { + return getRuleContext(Sequence_patternContext.class, 0); + } + + public Mapping_patternContext mapping_pattern() { + return getRuleContext(Mapping_patternContext.class, 0); + } + + public Class_patternContext class_pattern() { + return getRuleContext(Class_patternContext.class, 0); + } + + public Closed_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_closed_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterClosed_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitClosed_pattern(this); + } + } + + public final Closed_patternContext closed_pattern() throws RecognitionException { + Closed_patternContext _localctx = new Closed_patternContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_closed_pattern); + try { + setState(1102); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 118, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1094); + literal_pattern(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1095); + capture_pattern(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1096); + wildcard_pattern(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1097); + value_pattern(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1098); + group_pattern(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1099); + sequence_pattern(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1100); + mapping_pattern(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1101); + class_pattern(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Literal_patternContext extends ParserRuleContext { + public Signed_numberContext signed_number() { + return getRuleContext(Signed_numberContext.class, 0); + } + + public Complex_numberContext complex_number() { + return getRuleContext(Complex_numberContext.class, 0); + } + + public StringsContext strings() { + return getRuleContext(StringsContext.class, 0); + } + + public TerminalNode NONE() { + return getToken(PythonParser.NONE, 0); + } + + public TerminalNode TRUE() { + return getToken(PythonParser.TRUE, 0); + } + + public TerminalNode FALSE() { + return getToken(PythonParser.FALSE, 0); + } + + public Literal_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_literal_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLiteral_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLiteral_pattern(this); + } + } + + public final Literal_patternContext literal_pattern() throws RecognitionException { + Literal_patternContext _localctx = new Literal_patternContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_literal_pattern); + try { + setState(1110); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 119, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1104); + signed_number(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1105); + complex_number(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1106); + strings(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1107); + match(NONE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1108); + match(TRUE); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1109); + match(FALSE); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Literal_exprContext extends ParserRuleContext { + public Signed_numberContext signed_number() { + return getRuleContext(Signed_numberContext.class, 0); + } + + public Complex_numberContext complex_number() { + return getRuleContext(Complex_numberContext.class, 0); + } + + public StringsContext strings() { + return getRuleContext(StringsContext.class, 0); + } + + public TerminalNode NONE() { + return getToken(PythonParser.NONE, 0); + } + + public TerminalNode TRUE() { + return getToken(PythonParser.TRUE, 0); + } + + public TerminalNode FALSE() { + return getToken(PythonParser.FALSE, 0); + } + + public Literal_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_literal_expr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLiteral_expr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLiteral_expr(this); + } + } + + public final Literal_exprContext literal_expr() throws RecognitionException { + Literal_exprContext _localctx = new Literal_exprContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_literal_expr); + try { + setState(1118); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 120, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1112); + signed_number(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1113); + complex_number(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1114); + strings(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1115); + match(NONE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1116); + match(TRUE); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1117); + match(FALSE); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Complex_numberContext extends ParserRuleContext { + public Signed_real_numberContext signed_real_number() { + return getRuleContext(Signed_real_numberContext.class, 0); + } + + public Imaginary_numberContext imaginary_number() { + return getRuleContext(Imaginary_numberContext.class, 0); + } + + public TerminalNode PLUS() { + return getToken(PythonParser.PLUS, 0); + } + + public TerminalNode MINUS() { + return getToken(PythonParser.MINUS, 0); + } + + public Complex_numberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_complex_number; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterComplex_number(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitComplex_number(this); + } + } + + public final Complex_numberContext complex_number() throws RecognitionException { + Complex_numberContext _localctx = new Complex_numberContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_complex_number); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1120); + signed_real_number(); + setState(1121); + _la = _input.LA(1); + if (!(_la == PLUS || _la == MINUS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1122); + imaginary_number(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signed_numberContext extends ParserRuleContext { + public TerminalNode NUMBER() { + return getToken(PythonParser.NUMBER, 0); + } + + public TerminalNode MINUS() { + return getToken(PythonParser.MINUS, 0); + } + + public Signed_numberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_signed_number; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSigned_number(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSigned_number(this); + } + } + + public final Signed_numberContext signed_number() throws RecognitionException { + Signed_numberContext _localctx = new Signed_numberContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_signed_number); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1125); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == MINUS) { + { + setState(1124); + match(MINUS); + } + } + + setState(1127); + match(NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signed_real_numberContext extends ParserRuleContext { + public Real_numberContext real_number() { + return getRuleContext(Real_numberContext.class, 0); + } + + public TerminalNode MINUS() { + return getToken(PythonParser.MINUS, 0); + } + + public Signed_real_numberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_signed_real_number; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterSigned_real_number(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitSigned_real_number(this); + } + } + + public final Signed_real_numberContext signed_real_number() throws RecognitionException { + Signed_real_numberContext _localctx = new Signed_real_numberContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_signed_real_number); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1130); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == MINUS) { + { + setState(1129); + match(MINUS); + } + } + + setState(1132); + real_number(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Real_numberContext extends ParserRuleContext { + public TerminalNode NUMBER() { + return getToken(PythonParser.NUMBER, 0); + } + + public Real_numberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_real_number; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterReal_number(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitReal_number(this); + } + } + + public final Real_numberContext real_number() throws RecognitionException { + Real_numberContext _localctx = new Real_numberContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_real_number); + try { + enterOuterAlt(_localctx, 1); + { + setState(1134); + match(NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Imaginary_numberContext extends ParserRuleContext { + public TerminalNode NUMBER() { + return getToken(PythonParser.NUMBER, 0); + } + + public Imaginary_numberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_imaginary_number; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterImaginary_number(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitImaginary_number(this); + } + } + + public final Imaginary_numberContext imaginary_number() throws RecognitionException { + Imaginary_numberContext _localctx = new Imaginary_numberContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_imaginary_number); + try { + enterOuterAlt(_localctx, 1); + { + setState(1136); + match(NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Capture_patternContext extends ParserRuleContext { + public Pattern_capture_targetContext pattern_capture_target() { + return getRuleContext(Pattern_capture_targetContext.class, 0); + } + + public Capture_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_capture_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterCapture_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitCapture_pattern(this); + } + } + + public final Capture_patternContext capture_pattern() throws RecognitionException { + Capture_patternContext _localctx = new Capture_patternContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_capture_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1138); + pattern_capture_target(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Pattern_capture_targetContext extends ParserRuleContext { + public Soft_kw__not__wildcardContext soft_kw__not__wildcard() { + return getRuleContext(Soft_kw__not__wildcardContext.class, 0); + } + + public Pattern_capture_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_pattern_capture_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterPattern_capture_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitPattern_capture_target(this); + } + } + + public final Pattern_capture_targetContext pattern_capture_target() throws RecognitionException { + Pattern_capture_targetContext _localctx = new Pattern_capture_targetContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_pattern_capture_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(1140); + soft_kw__not__wildcard(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Wildcard_patternContext extends ParserRuleContext { + public Soft_kw_wildcardContext soft_kw_wildcard() { + return getRuleContext(Soft_kw_wildcardContext.class, 0); + } + + public Wildcard_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_wildcard_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterWildcard_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitWildcard_pattern(this); + } + } + + public final Wildcard_patternContext wildcard_pattern() throws RecognitionException { + Wildcard_patternContext _localctx = new Wildcard_patternContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_wildcard_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1142); + soft_kw_wildcard(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Value_patternContext extends ParserRuleContext { + public AttrContext attr() { + return getRuleContext(AttrContext.class, 0); + } + + public Value_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_value_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterValue_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitValue_pattern(this); + } + } + + public final Value_patternContext value_pattern() throws RecognitionException { + Value_patternContext _localctx = new Value_patternContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_value_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1144); + attr(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AttrContext extends ParserRuleContext { + public List NAME() { + return getTokens(PythonParser.NAME); + } + + public TerminalNode NAME(int i) { + return getToken(PythonParser.NAME, i); + } + + public List DOT() { + return getTokens(PythonParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(PythonParser.DOT, i); + } + + public AttrContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_attr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAttr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAttr(this); + } + } + + public final AttrContext attr() throws RecognitionException { + AttrContext _localctx = new AttrContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_attr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1146); + match(NAME); + setState(1149); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1147); + match(DOT); + setState(1148); + match(NAME); + } + } + setState(1151); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == DOT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Name_or_attrContext extends ParserRuleContext { + public List NAME() { + return getTokens(PythonParser.NAME); + } + + public TerminalNode NAME(int i) { + return getToken(PythonParser.NAME, i); + } + + public List DOT() { + return getTokens(PythonParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(PythonParser.DOT, i); + } + + public Name_or_attrContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_name_or_attr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterName_or_attr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitName_or_attr(this); + } + } + + public final Name_or_attrContext name_or_attr() throws RecognitionException { + Name_or_attrContext _localctx = new Name_or_attrContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_name_or_attr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1153); + match(NAME); + setState(1158); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == DOT) { + { + { + setState(1154); + match(DOT); + setState(1155); + match(NAME); + } + } + setState(1160); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_patternContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public PatternContext pattern() { + return getRuleContext(PatternContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Group_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_group_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGroup_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGroup_pattern(this); + } + } + + public final Group_patternContext group_pattern() throws RecognitionException { + Group_patternContext _localctx = new Group_patternContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_group_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1161); + match(LPAR); + setState(1162); + pattern(); + setState(1163); + match(RPAR); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Sequence_patternContext extends ParserRuleContext { + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Maybe_sequence_patternContext maybe_sequence_pattern() { + return getRuleContext(Maybe_sequence_patternContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Open_sequence_patternContext open_sequence_pattern() { + return getRuleContext(Open_sequence_patternContext.class, 0); + } + + public Sequence_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_sequence_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSequence_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSequence_pattern(this); + } + } + + public final Sequence_patternContext sequence_pattern() throws RecognitionException { + Sequence_patternContext _localctx = new Sequence_patternContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_sequence_pattern); + try { + setState(1175); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LSQB: + enterOuterAlt(_localctx, 1); + { + setState(1165); + match(LSQB); + setState(1167); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 125, _ctx)) { + case 1: { + setState(1166); + maybe_sequence_pattern(); + } + break; + } + setState(1169); + match(RSQB); + } + break; + case LPAR: + enterOuterAlt(_localctx, 2); + { + setState(1170); + match(LPAR); + setState(1172); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 126, _ctx)) { + case 1: { + setState(1171); + open_sequence_pattern(); + } + break; + } + setState(1174); + match(RPAR); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Open_sequence_patternContext extends ParserRuleContext { + public Maybe_star_patternContext maybe_star_pattern() { + return getRuleContext(Maybe_star_patternContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Maybe_sequence_patternContext maybe_sequence_pattern() { + return getRuleContext(Maybe_sequence_patternContext.class, 0); + } + + public Open_sequence_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_open_sequence_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterOpen_sequence_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitOpen_sequence_pattern(this); + } + } + + public final Open_sequence_patternContext open_sequence_pattern() throws RecognitionException { + Open_sequence_patternContext _localctx = new Open_sequence_patternContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_open_sequence_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1177); + maybe_star_pattern(); + setState(1178); + match(COMMA); + setState(1180); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 128, _ctx)) { + case 1: { + setState(1179); + maybe_sequence_pattern(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Maybe_sequence_patternContext extends ParserRuleContext { + public List maybe_star_pattern() { + return getRuleContexts(Maybe_star_patternContext.class); + } + + public Maybe_star_patternContext maybe_star_pattern(int i) { + return getRuleContext(Maybe_star_patternContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Maybe_sequence_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_maybe_sequence_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterMaybe_sequence_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitMaybe_sequence_pattern(this); + } + } + + public final Maybe_sequence_patternContext maybe_sequence_pattern() throws RecognitionException { + Maybe_sequence_patternContext _localctx = new Maybe_sequence_patternContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_maybe_sequence_pattern); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1182); + maybe_star_pattern(); + setState(1187); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 129, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1183); + match(COMMA); + setState(1184); + maybe_star_pattern(); + } + } + } + setState(1189); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 129, _ctx); + } + setState(1191); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1190); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Maybe_star_patternContext extends ParserRuleContext { + public Star_patternContext star_pattern() { + return getRuleContext(Star_patternContext.class, 0); + } + + public PatternContext pattern() { + return getRuleContext(PatternContext.class, 0); + } + + public Maybe_star_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_maybe_star_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterMaybe_star_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitMaybe_star_pattern(this); + } + } + + public final Maybe_star_patternContext maybe_star_pattern() throws RecognitionException { + Maybe_star_patternContext _localctx = new Maybe_star_patternContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_maybe_star_pattern); + try { + setState(1195); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 131, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1193); + star_pattern(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1194); + pattern(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_patternContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Star_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_pattern(this); + } + } + + public final Star_patternContext star_pattern() throws RecognitionException { + Star_patternContext _localctx = new Star_patternContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_star_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1197); + match(STAR); + setState(1198); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Mapping_patternContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public Double_star_patternContext double_star_pattern() { + return getRuleContext(Double_star_patternContext.class, 0); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Items_patternContext items_pattern() { + return getRuleContext(Items_patternContext.class, 0); + } + + public Mapping_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_mapping_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterMapping_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitMapping_pattern(this); + } + } + + public final Mapping_patternContext mapping_pattern() throws RecognitionException { + Mapping_patternContext _localctx = new Mapping_patternContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_mapping_pattern); + int _la; + try { + setState(1220); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 135, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1200); + match(LBRACE); + setState(1201); + match(RBRACE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1202); + match(LBRACE); + setState(1203); + double_star_pattern(); + setState(1205); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1204); + match(COMMA); + } + } + + setState(1207); + match(RBRACE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1209); + match(LBRACE); + setState(1210); + items_pattern(); + setState(1213); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 133, _ctx)) { + case 1: { + setState(1211); + match(COMMA); + setState(1212); + double_star_pattern(); + } + break; + } + setState(1216); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1215); + match(COMMA); + } + } + + setState(1218); + match(RBRACE); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Items_patternContext extends ParserRuleContext { + public List key_value_pattern() { + return getRuleContexts(Key_value_patternContext.class); + } + + public Key_value_patternContext key_value_pattern(int i) { + return getRuleContext(Key_value_patternContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Items_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_items_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterItems_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitItems_pattern(this); + } + } + + public final Items_patternContext items_pattern() throws RecognitionException { + Items_patternContext _localctx = new Items_patternContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_items_pattern); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1222); + key_value_pattern(); + setState(1227); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 136, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1223); + match(COMMA); + setState(1224); + key_value_pattern(); + } + } + } + setState(1229); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 136, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_value_patternContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public PatternContext pattern() { + return getRuleContext(PatternContext.class, 0); + } + + public Literal_exprContext literal_expr() { + return getRuleContext(Literal_exprContext.class, 0); + } + + public AttrContext attr() { + return getRuleContext(AttrContext.class, 0); + } + + public Key_value_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_key_value_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterKey_value_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKey_value_pattern(this); + } + } + + public final Key_value_patternContext key_value_pattern() throws RecognitionException { + Key_value_patternContext _localctx = new Key_value_patternContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_key_value_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1232); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: + case FALSE: + case NONE: + case TRUE: + case MINUS: + case NUMBER: + case STRING: { + setState(1230); + literal_expr(); + } + break; + case NAME: { + setState(1231); + attr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1234); + match(COLON); + setState(1235); + pattern(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Double_star_patternContext extends ParserRuleContext { + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Pattern_capture_targetContext pattern_capture_target() { + return getRuleContext(Pattern_capture_targetContext.class, 0); + } + + public Double_star_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_double_star_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterDouble_star_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitDouble_star_pattern(this); + } + } + + public final Double_star_patternContext double_star_pattern() throws RecognitionException { + Double_star_patternContext _localctx = new Double_star_patternContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_double_star_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1237); + match(DOUBLESTAR); + setState(1238); + pattern_capture_target(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Class_patternContext extends ParserRuleContext { + public Name_or_attrContext name_or_attr() { + return getRuleContext(Name_or_attrContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Positional_patternsContext positional_patterns() { + return getRuleContext(Positional_patternsContext.class, 0); + } + + public Keyword_patternsContext keyword_patterns() { + return getRuleContext(Keyword_patternsContext.class, 0); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Class_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_class_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterClass_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitClass_pattern(this); + } + } + + public final Class_patternContext class_pattern() throws RecognitionException { + Class_patternContext _localctx = new Class_patternContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_class_pattern); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1240); + name_or_attr(); + setState(1241); + match(LPAR); + setState(1253); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 141, _ctx)) { + case 1: { + setState(1248); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 139, _ctx)) { + case 1: { + setState(1242); + positional_patterns(); + setState(1245); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 138, _ctx)) { + case 1: { + setState(1243); + match(COMMA); + setState(1244); + keyword_patterns(); + } + break; + } + } + break; + case 2: { + setState(1247); + keyword_patterns(); + } + break; + } + setState(1251); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1250); + match(COMMA); + } + } + + } + break; + } + setState(1255); + match(RPAR); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Positional_patternsContext extends ParserRuleContext { + public List pattern() { + return getRuleContexts(PatternContext.class); + } + + public PatternContext pattern(int i) { + return getRuleContext(PatternContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Positional_patternsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_positional_patterns; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterPositional_patterns(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitPositional_patterns(this); + } + } + + public final Positional_patternsContext positional_patterns() throws RecognitionException { + Positional_patternsContext _localctx = new Positional_patternsContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_positional_patterns); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1257); + pattern(); + setState(1262); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 142, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1258); + match(COMMA); + setState(1259); + pattern(); + } + } + } + setState(1264); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 142, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Keyword_patternsContext extends ParserRuleContext { + public List keyword_pattern() { + return getRuleContexts(Keyword_patternContext.class); + } + + public Keyword_patternContext keyword_pattern(int i) { + return getRuleContext(Keyword_patternContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Keyword_patternsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_keyword_patterns; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKeyword_patterns(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKeyword_patterns(this); + } + } + + public final Keyword_patternsContext keyword_patterns() throws RecognitionException { + Keyword_patternsContext _localctx = new Keyword_patternsContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_keyword_patterns); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1265); + keyword_pattern(); + setState(1270); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 143, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1266); + match(COMMA); + setState(1267); + keyword_pattern(); + } + } + } + setState(1272); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 143, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Keyword_patternContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public PatternContext pattern() { + return getRuleContext(PatternContext.class, 0); + } + + public Keyword_patternContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_keyword_pattern; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKeyword_pattern(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKeyword_pattern(this); + } + } + + public final Keyword_patternContext keyword_pattern() throws RecognitionException { + Keyword_patternContext _localctx = new Keyword_patternContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_keyword_pattern); + try { + enterOuterAlt(_localctx, 1); + { + setState(1273); + match(NAME); + setState(1274); + match(EQUAL); + setState(1275); + pattern(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_aliasContext extends ParserRuleContext { + public Soft_kw_typeContext soft_kw_type() { + return getRuleContext(Soft_kw_typeContext.class, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Type_paramsContext type_params() { + return getRuleContext(Type_paramsContext.class, 0); + } + + public Type_aliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_alias; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_alias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_alias(this); + } + } + + public final Type_aliasContext type_alias() throws RecognitionException { + Type_aliasContext _localctx = new Type_aliasContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_type_alias); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1277); + soft_kw_type(); + setState(1278); + match(NAME); + setState(1280); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LSQB) { + { + setState(1279); + type_params(); + } + } + + setState(1282); + match(EQUAL); + setState(1283); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_paramsContext extends ParserRuleContext { + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public Type_param_seqContext type_param_seq() { + return getRuleContext(Type_param_seqContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Type_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_params; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_params(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_params(this); + } + } + + public final Type_paramsContext type_params() throws RecognitionException { + Type_paramsContext _localctx = new Type_paramsContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_type_params); + try { + enterOuterAlt(_localctx, 1); + { + setState(1285); + match(LSQB); + setState(1286); + type_param_seq(); + setState(1287); + match(RSQB); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_param_seqContext extends ParserRuleContext { + public List type_param() { + return getRuleContexts(Type_paramContext.class); + } + + public Type_paramContext type_param(int i) { + return getRuleContext(Type_paramContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Type_param_seqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_param_seq; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_param_seq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_param_seq(this); + } + } + + public final Type_param_seqContext type_param_seq() throws RecognitionException { + Type_param_seqContext _localctx = new Type_param_seqContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_type_param_seq); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1289); + type_param(); + setState(1294); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 145, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1290); + match(COMMA); + setState(1291); + type_param(); + } + } + } + setState(1296); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 145, _ctx); + } + setState(1298); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1297); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_paramContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Type_param_boundContext type_param_bound() { + return getRuleContext(Type_param_boundContext.class, 0); + } + + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Type_paramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_param; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_param(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_param(this); + } + } + + public final Type_paramContext type_param() throws RecognitionException { + Type_paramContext _localctx = new Type_paramContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_type_param); + int _la; + try { + setState(1308); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + enterOuterAlt(_localctx, 1); + { + setState(1300); + match(NAME); + setState(1302); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(1301); + type_param_bound(); + } + } + + } + break; + case STAR: + enterOuterAlt(_localctx, 2); + { + setState(1304); + match(STAR); + setState(1305); + match(NAME); + } + break; + case DOUBLESTAR: + enterOuterAlt(_localctx, 3); + { + setState(1306); + match(DOUBLESTAR); + setState(1307); + match(NAME); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_param_boundContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Type_param_boundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_param_bound; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_param_bound(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_param_bound(this); + } + } + + public final Type_param_boundContext type_param_bound() throws RecognitionException { + Type_param_boundContext _localctx = new Type_param_boundContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_type_param_bound); + try { + enterOuterAlt(_localctx, 1); + { + setState(1310); + match(COLON); + setState(1311); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionsContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public ExpressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_expressions; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterExpressions(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitExpressions(this); + } + } + + public final ExpressionsContext expressions() throws RecognitionException { + ExpressionsContext _localctx = new ExpressionsContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_expressions); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1313); + expression(); + setState(1318); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 149, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1314); + match(COMMA); + setState(1315); + expression(); + } + } + } + setState(1320); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 149, _ctx); + } + setState(1322); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1321); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionContext extends ParserRuleContext { + public List disjunction() { + return getRuleContexts(DisjunctionContext.class); + } + + public DisjunctionContext disjunction(int i) { + return getRuleContext(DisjunctionContext.class, i); + } + + public TerminalNode IF() { + return getToken(PythonParser.IF, 0); + } + + public TerminalNode ELSE() { + return getToken(PythonParser.ELSE, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public LambdefContext lambdef() { + return getRuleContext(LambdefContext.class, 0); + } + + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_expression); + int _la; + try { + setState(1333); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 1); + { + setState(1324); + disjunction(); + setState(1330); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == IF) { + { + setState(1325); + match(IF); + setState(1326); + disjunction(); + setState(1327); + match(ELSE); + setState(1328); + expression(); + } + } + + } + break; + case LAMBDA: + enterOuterAlt(_localctx, 2); + { + setState(1332); + lambdef(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Yield_exprContext extends ParserRuleContext { + public TerminalNode YIELD() { + return getToken(PythonParser.YIELD, 0); + } + + public TerminalNode FROM() { + return getToken(PythonParser.FROM, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public Yield_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_yield_expr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterYield_expr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitYield_expr(this); + } + } + + public final Yield_exprContext yield_expr() throws RecognitionException { + Yield_exprContext _localctx = new Yield_exprContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_yield_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1335); + match(YIELD); + setState(1341); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: { + setState(1336); + match(FROM); + setState(1337); + expression(); + } + break; + case TYPE_COMMENT: + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case RPAR: + case RBRACE: + case COLON: + case SEMI: + case PLUS: + case MINUS: + case STAR: + case EQUAL: + case TILDE: + case ELLIPSIS: + case EXCLAMATION: + case NAME: + case NUMBER: + case STRING: + case NEWLINE: { + setState(1339); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1338); + star_expressions(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_expressionsContext extends ParserRuleContext { + public List star_expression() { + return getRuleContexts(Star_expressionContext.class); + } + + public Star_expressionContext star_expression(int i) { + return getRuleContext(Star_expressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Star_expressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_expressions; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_expressions(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_expressions(this); + } + } + + public final Star_expressionsContext star_expressions() throws RecognitionException { + Star_expressionsContext _localctx = new Star_expressionsContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_star_expressions); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1343); + star_expression(); + setState(1348); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 155, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1344); + match(COMMA); + setState(1345); + star_expression(); + } + } + } + setState(1350); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 155, _ctx); + } + setState(1352); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1351); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_expressionContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Star_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_expression(this); + } + } + + public final Star_expressionContext star_expression() throws RecognitionException { + Star_expressionContext _localctx = new Star_expressionContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_star_expression); + try { + setState(1357); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + enterOuterAlt(_localctx, 1); + { + setState(1354); + match(STAR); + setState(1355); + bitwise_or(0); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(1356); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_named_expressionsContext extends ParserRuleContext { + public List star_named_expression() { + return getRuleContexts(Star_named_expressionContext.class); + } + + public Star_named_expressionContext star_named_expression(int i) { + return getRuleContext(Star_named_expressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Star_named_expressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_named_expressions; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStar_named_expressions(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitStar_named_expressions(this); + } + } + + public final Star_named_expressionsContext star_named_expressions() throws RecognitionException { + Star_named_expressionsContext _localctx = new Star_named_expressionsContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_star_named_expressions); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1359); + star_named_expression(); + setState(1364); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 158, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1360); + match(COMMA); + setState(1361); + star_named_expression(); + } + } + } + setState(1366); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 158, _ctx); + } + setState(1368); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1367); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_named_expressionContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public Star_named_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_named_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStar_named_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitStar_named_expression(this); + } + } + + public final Star_named_expressionContext star_named_expression() throws RecognitionException { + Star_named_expressionContext _localctx = new Star_named_expressionContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_star_named_expression); + try { + setState(1373); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + enterOuterAlt(_localctx, 1); + { + setState(1370); + match(STAR); + setState(1371); + bitwise_or(0); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(1372); + named_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assignment_expressionContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode COLONEQUAL() { + return getToken(PythonParser.COLONEQUAL, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Assignment_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_assignment_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterAssignment_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitAssignment_expression(this); + } + } + + public final Assignment_expressionContext assignment_expression() throws RecognitionException { + Assignment_expressionContext _localctx = new Assignment_expressionContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_assignment_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1375); + match(NAME); + setState(1376); + match(COLONEQUAL); + setState(1377); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Named_expressionContext extends ParserRuleContext { + public Assignment_expressionContext assignment_expression() { + return getRuleContext(Assignment_expressionContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Named_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_named_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterNamed_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitNamed_expression(this); + } + } + + public final Named_expressionContext named_expression() throws RecognitionException { + Named_expressionContext _localctx = new Named_expressionContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_named_expression); + try { + setState(1381); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 161, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1379); + assignment_expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1380); + expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DisjunctionContext extends ParserRuleContext { + public List conjunction() { + return getRuleContexts(ConjunctionContext.class); + } + + public ConjunctionContext conjunction(int i) { + return getRuleContext(ConjunctionContext.class, i); + } + + public List OR() { + return getTokens(PythonParser.OR); + } + + public TerminalNode OR(int i) { + return getToken(PythonParser.OR, i); + } + + public DisjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_disjunction; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDisjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDisjunction(this); + } + } + + public final DisjunctionContext disjunction() throws RecognitionException { + DisjunctionContext _localctx = new DisjunctionContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_disjunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1383); + conjunction(); + setState(1388); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OR) { + { + { + setState(1384); + match(OR); + setState(1385); + conjunction(); + } + } + setState(1390); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConjunctionContext extends ParserRuleContext { + public List inversion() { + return getRuleContexts(InversionContext.class); + } + + public InversionContext inversion(int i) { + return getRuleContext(InversionContext.class, i); + } + + public List AND() { + return getTokens(PythonParser.AND); + } + + public TerminalNode AND(int i) { + return getToken(PythonParser.AND, i); + } + + public ConjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_conjunction; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterConjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitConjunction(this); + } + } + + public final ConjunctionContext conjunction() throws RecognitionException { + ConjunctionContext _localctx = new ConjunctionContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_conjunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1391); + inversion(); + setState(1396); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AND) { + { + { + setState(1392); + match(AND); + setState(1393); + inversion(); + } + } + setState(1398); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InversionContext extends ParserRuleContext { + public TerminalNode NOT() { + return getToken(PythonParser.NOT, 0); + } + + public InversionContext inversion() { + return getRuleContext(InversionContext.class, 0); + } + + public ComparisonContext comparison() { + return getRuleContext(ComparisonContext.class, 0); + } + + public InversionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_inversion; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterInversion(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitInversion(this); + } + } + + public final InversionContext inversion() throws RecognitionException { + InversionContext _localctx = new InversionContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_inversion); + try { + setState(1402); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + enterOuterAlt(_localctx, 1); + { + setState(1399); + match(NOT); + setState(1400); + inversion(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(1401); + comparison(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ComparisonContext extends ParserRuleContext { + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public List compare_op_bitwise_or_pair() { + return getRuleContexts(Compare_op_bitwise_or_pairContext.class); + } + + public Compare_op_bitwise_or_pairContext compare_op_bitwise_or_pair(int i) { + return getRuleContext(Compare_op_bitwise_or_pairContext.class, i); + } + + public ComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_comparison; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterComparison(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitComparison(this); + } + } + + public final ComparisonContext comparison() throws RecognitionException { + ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_comparison); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1404); + bitwise_or(0); + setState(1408); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 15)) & ~0x3f) == 0 && ((1L << (_la - 15)) & 2137450605445153L) != 0)) { + { + { + setState(1405); + compare_op_bitwise_or_pair(); + } + } + setState(1410); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Compare_op_bitwise_or_pairContext extends ParserRuleContext { + public Eq_bitwise_orContext eq_bitwise_or() { + return getRuleContext(Eq_bitwise_orContext.class, 0); + } + + public Noteq_bitwise_orContext noteq_bitwise_or() { + return getRuleContext(Noteq_bitwise_orContext.class, 0); + } + + public Lte_bitwise_orContext lte_bitwise_or() { + return getRuleContext(Lte_bitwise_orContext.class, 0); + } + + public Lt_bitwise_orContext lt_bitwise_or() { + return getRuleContext(Lt_bitwise_orContext.class, 0); + } + + public Gte_bitwise_orContext gte_bitwise_or() { + return getRuleContext(Gte_bitwise_orContext.class, 0); + } + + public Gt_bitwise_orContext gt_bitwise_or() { + return getRuleContext(Gt_bitwise_orContext.class, 0); + } + + public Notin_bitwise_orContext notin_bitwise_or() { + return getRuleContext(Notin_bitwise_orContext.class, 0); + } + + public In_bitwise_orContext in_bitwise_or() { + return getRuleContext(In_bitwise_orContext.class, 0); + } + + public Isnot_bitwise_orContext isnot_bitwise_or() { + return getRuleContext(Isnot_bitwise_orContext.class, 0); + } + + public Is_bitwise_orContext is_bitwise_or() { + return getRuleContext(Is_bitwise_orContext.class, 0); + } + + public Compare_op_bitwise_or_pairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_compare_op_bitwise_or_pair; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterCompare_op_bitwise_or_pair(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitCompare_op_bitwise_or_pair(this); + } + } + + public final Compare_op_bitwise_or_pairContext compare_op_bitwise_or_pair() throws RecognitionException { + Compare_op_bitwise_or_pairContext _localctx = new Compare_op_bitwise_or_pairContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_compare_op_bitwise_or_pair); + try { + setState(1421); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1411); + eq_bitwise_or(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1412); + noteq_bitwise_or(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1413); + lte_bitwise_or(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1414); + lt_bitwise_or(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1415); + gte_bitwise_or(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1416); + gt_bitwise_or(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1417); + notin_bitwise_or(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1418); + in_bitwise_or(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1419); + isnot_bitwise_or(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1420); + is_bitwise_or(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Eq_bitwise_orContext extends ParserRuleContext { + public TerminalNode EQEQUAL() { + return getToken(PythonParser.EQEQUAL, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Eq_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_eq_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterEq_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitEq_bitwise_or(this); + } + } + + public final Eq_bitwise_orContext eq_bitwise_or() throws RecognitionException { + Eq_bitwise_orContext _localctx = new Eq_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_eq_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1423); + match(EQEQUAL); + setState(1424); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Noteq_bitwise_orContext extends ParserRuleContext { + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public TerminalNode NOTEQUAL() { + return getToken(PythonParser.NOTEQUAL, 0); + } + + public Noteq_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_noteq_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterNoteq_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitNoteq_bitwise_or(this); + } + } + + public final Noteq_bitwise_orContext noteq_bitwise_or() throws RecognitionException { + Noteq_bitwise_orContext _localctx = new Noteq_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_noteq_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + { + setState(1426); + match(NOTEQUAL); + } + setState(1427); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lte_bitwise_orContext extends ParserRuleContext { + public TerminalNode LESSEQUAL() { + return getToken(PythonParser.LESSEQUAL, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Lte_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lte_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLte_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLte_bitwise_or(this); + } + } + + public final Lte_bitwise_orContext lte_bitwise_or() throws RecognitionException { + Lte_bitwise_orContext _localctx = new Lte_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_lte_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1429); + match(LESSEQUAL); + setState(1430); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lt_bitwise_orContext extends ParserRuleContext { + public TerminalNode LESS() { + return getToken(PythonParser.LESS, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Lt_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lt_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLt_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLt_bitwise_or(this); + } + } + + public final Lt_bitwise_orContext lt_bitwise_or() throws RecognitionException { + Lt_bitwise_orContext _localctx = new Lt_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_lt_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1432); + match(LESS); + setState(1433); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Gte_bitwise_orContext extends ParserRuleContext { + public TerminalNode GREATEREQUAL() { + return getToken(PythonParser.GREATEREQUAL, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Gte_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_gte_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGte_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGte_bitwise_or(this); + } + } + + public final Gte_bitwise_orContext gte_bitwise_or() throws RecognitionException { + Gte_bitwise_orContext _localctx = new Gte_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_gte_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1435); + match(GREATEREQUAL); + setState(1436); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Gt_bitwise_orContext extends ParserRuleContext { + public TerminalNode GREATER() { + return getToken(PythonParser.GREATER, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Gt_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_gt_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGt_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGt_bitwise_or(this); + } + } + + public final Gt_bitwise_orContext gt_bitwise_or() throws RecognitionException { + Gt_bitwise_orContext _localctx = new Gt_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_gt_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1438); + match(GREATER); + setState(1439); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Notin_bitwise_orContext extends ParserRuleContext { + public TerminalNode NOT() { + return getToken(PythonParser.NOT, 0); + } + + public TerminalNode IN() { + return getToken(PythonParser.IN, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Notin_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_notin_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterNotin_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitNotin_bitwise_or(this); + } + } + + public final Notin_bitwise_orContext notin_bitwise_or() throws RecognitionException { + Notin_bitwise_orContext _localctx = new Notin_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_notin_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1441); + match(NOT); + setState(1442); + match(IN); + setState(1443); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class In_bitwise_orContext extends ParserRuleContext { + public TerminalNode IN() { + return getToken(PythonParser.IN, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public In_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_in_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterIn_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitIn_bitwise_or(this); + } + } + + public final In_bitwise_orContext in_bitwise_or() throws RecognitionException { + In_bitwise_orContext _localctx = new In_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_in_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1445); + match(IN); + setState(1446); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Isnot_bitwise_orContext extends ParserRuleContext { + public TerminalNode IS() { + return getToken(PythonParser.IS, 0); + } + + public TerminalNode NOT() { + return getToken(PythonParser.NOT, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Isnot_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_isnot_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterIsnot_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitIsnot_bitwise_or(this); + } + } + + public final Isnot_bitwise_orContext isnot_bitwise_or() throws RecognitionException { + Isnot_bitwise_orContext _localctx = new Isnot_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_isnot_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1448); + match(IS); + setState(1449); + match(NOT); + setState(1450); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Is_bitwise_orContext extends ParserRuleContext { + public TerminalNode IS() { + return getToken(PythonParser.IS, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public Is_bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_is_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterIs_bitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitIs_bitwise_or(this); + } + } + + public final Is_bitwise_orContext is_bitwise_or() throws RecognitionException { + Is_bitwise_orContext _localctx = new Is_bitwise_orContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_is_bitwise_or); + try { + enterOuterAlt(_localctx, 1); + { + setState(1452); + match(IS); + setState(1453); + bitwise_or(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Bitwise_orContext extends ParserRuleContext { + public Bitwise_xorContext bitwise_xor() { + return getRuleContext(Bitwise_xorContext.class, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public TerminalNode VBAR() { + return getToken(PythonParser.VBAR, 0); + } + + public Bitwise_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_bitwise_or; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterBitwise_or(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitBitwise_or(this); + } + } + + public final Bitwise_orContext bitwise_or() throws RecognitionException { + return bitwise_or(0); + } + + private Bitwise_orContext bitwise_or(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + Bitwise_orContext _localctx = new Bitwise_orContext(_ctx, _parentState); + Bitwise_orContext _prevctx = _localctx; + int _startState = 254; + enterRecursionRule(_localctx, 254, RULE_bitwise_or, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1456); + bitwise_xor(0); + } + _ctx.stop = _input.LT(-1); + setState(1463); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 167, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new Bitwise_orContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_bitwise_or); + setState(1458); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1459); + match(VBAR); + setState(1460); + bitwise_xor(0); + } + } + } + setState(1465); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 167, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Bitwise_xorContext extends ParserRuleContext { + public Bitwise_andContext bitwise_and() { + return getRuleContext(Bitwise_andContext.class, 0); + } + + public Bitwise_xorContext bitwise_xor() { + return getRuleContext(Bitwise_xorContext.class, 0); + } + + public TerminalNode CIRCUMFLEX() { + return getToken(PythonParser.CIRCUMFLEX, 0); + } + + public Bitwise_xorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_bitwise_xor; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterBitwise_xor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitBitwise_xor(this); + } + } + + public final Bitwise_xorContext bitwise_xor() throws RecognitionException { + return bitwise_xor(0); + } + + private Bitwise_xorContext bitwise_xor(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + Bitwise_xorContext _localctx = new Bitwise_xorContext(_ctx, _parentState); + Bitwise_xorContext _prevctx = _localctx; + int _startState = 256; + enterRecursionRule(_localctx, 256, RULE_bitwise_xor, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1467); + bitwise_and(0); + } + _ctx.stop = _input.LT(-1); + setState(1474); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 168, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new Bitwise_xorContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_bitwise_xor); + setState(1469); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1470); + match(CIRCUMFLEX); + setState(1471); + bitwise_and(0); + } + } + } + setState(1476); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 168, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Bitwise_andContext extends ParserRuleContext { + public Shift_exprContext shift_expr() { + return getRuleContext(Shift_exprContext.class, 0); + } + + public Bitwise_andContext bitwise_and() { + return getRuleContext(Bitwise_andContext.class, 0); + } + + public TerminalNode AMPER() { + return getToken(PythonParser.AMPER, 0); + } + + public Bitwise_andContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_bitwise_and; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterBitwise_and(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitBitwise_and(this); + } + } + + public final Bitwise_andContext bitwise_and() throws RecognitionException { + return bitwise_and(0); + } + + private Bitwise_andContext bitwise_and(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + Bitwise_andContext _localctx = new Bitwise_andContext(_ctx, _parentState); + Bitwise_andContext _prevctx = _localctx; + int _startState = 258; + enterRecursionRule(_localctx, 258, RULE_bitwise_and, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1478); + shift_expr(0); + } + _ctx.stop = _input.LT(-1); + setState(1485); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 169, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new Bitwise_andContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_bitwise_and); + setState(1480); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1481); + match(AMPER); + setState(1482); + shift_expr(0); + } + } + } + setState(1487); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 169, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Shift_exprContext extends ParserRuleContext { + public SumContext sum() { + return getRuleContext(SumContext.class, 0); + } + + public Shift_exprContext shift_expr() { + return getRuleContext(Shift_exprContext.class, 0); + } + + public TerminalNode LEFTSHIFT() { + return getToken(PythonParser.LEFTSHIFT, 0); + } + + public TerminalNode RIGHTSHIFT() { + return getToken(PythonParser.RIGHTSHIFT, 0); + } + + public Shift_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_shift_expr; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterShift_expr(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitShift_expr(this); + } + } + + public final Shift_exprContext shift_expr() throws RecognitionException { + return shift_expr(0); + } + + private Shift_exprContext shift_expr(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + Shift_exprContext _localctx = new Shift_exprContext(_ctx, _parentState); + Shift_exprContext _prevctx = _localctx; + int _startState = 260; + enterRecursionRule(_localctx, 260, RULE_shift_expr, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1489); + sum(0); + } + _ctx.stop = _input.LT(-1); + setState(1496); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new Shift_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shift_expr); + setState(1491); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1492); + _la = _input.LA(1); + if (!(_la == LEFTSHIFT || _la == RIGHTSHIFT)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1493); + sum(0); + } + } + } + setState(1498); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SumContext extends ParserRuleContext { + public TermContext term() { + return getRuleContext(TermContext.class, 0); + } + + public SumContext sum() { + return getRuleContext(SumContext.class, 0); + } + + public TerminalNode PLUS() { + return getToken(PythonParser.PLUS, 0); + } + + public TerminalNode MINUS() { + return getToken(PythonParser.MINUS, 0); + } + + public SumContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_sum; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSum(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSum(this); + } + } + + public final SumContext sum() throws RecognitionException { + return sum(0); + } + + private SumContext sum(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + SumContext _localctx = new SumContext(_ctx, _parentState); + SumContext _prevctx = _localctx; + int _startState = 262; + enterRecursionRule(_localctx, 262, RULE_sum, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1500); + term(0); + } + _ctx.stop = _input.LT(-1); + setState(1507); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 171, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new SumContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_sum); + setState(1502); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1503); + _la = _input.LA(1); + if (!(_la == PLUS || _la == MINUS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1504); + term(0); + } + } + } + setState(1509); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 171, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TermContext extends ParserRuleContext { + public FactorContext factor() { + return getRuleContext(FactorContext.class, 0); + } + + public TermContext term() { + return getRuleContext(TermContext.class, 0); + } + + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public TerminalNode SLASH() { + return getToken(PythonParser.SLASH, 0); + } + + public TerminalNode DOUBLESLASH() { + return getToken(PythonParser.DOUBLESLASH, 0); + } + + public TerminalNode PERCENT() { + return getToken(PythonParser.PERCENT, 0); + } + + public TerminalNode AT() { + return getToken(PythonParser.AT, 0); + } + + public TermContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_term; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterTerm(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitTerm(this); + } + } + + public final TermContext term() throws RecognitionException { + return term(0); + } + + private TermContext term(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + TermContext _localctx = new TermContext(_ctx, _parentState); + TermContext _prevctx = _localctx; + int _startState = 264; + enterRecursionRule(_localctx, 264, RULE_term, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1511); + factor(); + } + _ctx.stop = _input.LT(-1); + setState(1518); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 172, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new TermContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_term); + setState(1513); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1514); + _la = _input.LA(1); + if (!(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 1342177411L) != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1515); + factor(); + } + } + } + setState(1520); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 172, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FactorContext extends ParserRuleContext { + public TerminalNode PLUS() { + return getToken(PythonParser.PLUS, 0); + } + + public FactorContext factor() { + return getRuleContext(FactorContext.class, 0); + } + + public TerminalNode MINUS() { + return getToken(PythonParser.MINUS, 0); + } + + public TerminalNode TILDE() { + return getToken(PythonParser.TILDE, 0); + } + + public PowerContext power() { + return getRuleContext(PowerContext.class, 0); + } + + public FactorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_factor; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFactor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFactor(this); + } + } + + public final FactorContext factor() throws RecognitionException { + FactorContext _localctx = new FactorContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_factor); + try { + setState(1528); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PLUS: + enterOuterAlt(_localctx, 1); + { + setState(1521); + match(PLUS); + setState(1522); + factor(); + } + break; + case MINUS: + enterOuterAlt(_localctx, 2); + { + setState(1523); + match(MINUS); + setState(1524); + factor(); + } + break; + case TILDE: + enterOuterAlt(_localctx, 3); + { + setState(1525); + match(TILDE); + setState(1526); + factor(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LPAR: + case LSQB: + case LBRACE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 4); + { + setState(1527); + power(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PowerContext extends ParserRuleContext { + public Await_primaryContext await_primary() { + return getRuleContext(Await_primaryContext.class, 0); + } + + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public FactorContext factor() { + return getRuleContext(FactorContext.class, 0); + } + + public PowerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_power; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterPower(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitPower(this); + } + } + + public final PowerContext power() throws RecognitionException { + PowerContext _localctx = new PowerContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_power); + try { + enterOuterAlt(_localctx, 1); + { + setState(1530); + await_primary(); + setState(1533); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 174, _ctx)) { + case 1: { + setState(1531); + match(DOUBLESTAR); + setState(1532); + factor(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Await_primaryContext extends ParserRuleContext { + public TerminalNode AWAIT() { + return getToken(PythonParser.AWAIT, 0); + } + + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class, 0); + } + + public Await_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_await_primary; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAwait_primary(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAwait_primary(this); + } + } + + public final Await_primaryContext await_primary() throws RecognitionException { + Await_primaryContext _localctx = new Await_primaryContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_await_primary); + try { + setState(1538); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AWAIT: + enterOuterAlt(_localctx, 1); + { + setState(1535); + match(AWAIT); + setState(1536); + primary(0); + } + break; + case FSTRING_START: + case FALSE: + case NONE: + case TRUE: + case LPAR: + case LSQB: + case LBRACE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(1537); + primary(0); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrimaryContext extends ParserRuleContext { + public AtomContext atom() { + return getRuleContext(AtomContext.class, 0); + } + + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public GenexpContext genexp() { + return getRuleContext(GenexpContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public SlicesContext slices() { + return getRuleContext(SlicesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class, 0); + } + + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_primary; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterPrimary(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitPrimary(this); + } + } + + public final PrimaryContext primary() throws RecognitionException { + return primary(0); + } + + private PrimaryContext primary(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PrimaryContext _localctx = new PrimaryContext(_ctx, _parentState); + PrimaryContext _prevctx = _localctx; + int _startState = 272; + enterRecursionRule(_localctx, 272, RULE_primary, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1541); + atom(); + } + _ctx.stop = _input.LT(-1); + setState(1560); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 178, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PrimaryContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_primary); + setState(1543); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1556); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 177, _ctx)) { + case 1: { + setState(1544); + match(DOT); + setState(1545); + match(NAME); + } + break; + case 2: { + setState(1546); + genexp(); + } + break; + case 3: { + setState(1547); + match(LPAR); + setState(1549); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537681L) != 0)) { + { + setState(1548); + arguments(); + } + } + + setState(1551); + match(RPAR); + } + break; + case 4: { + setState(1552); + match(LSQB); + setState(1553); + slices(); + setState(1554); + match(RSQB); + } + break; + } + } + } + } + setState(1562); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 178, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SlicesContext extends ParserRuleContext { + public List slice() { + return getRuleContexts(SliceContext.class); + } + + public SliceContext slice(int i) { + return getRuleContext(SliceContext.class, i); + } + + public List starred_expression() { + return getRuleContexts(Starred_expressionContext.class); + } + + public Starred_expressionContext starred_expression(int i) { + return getRuleContext(Starred_expressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public SlicesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_slices; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSlices(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSlices(this); + } + } + + public final SlicesContext slices() throws RecognitionException { + SlicesContext _localctx = new SlicesContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_slices); + int _la; + try { + int _alt; + setState(1581); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 183, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1563); + slice(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1566); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case COLON: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1564); + slice(); + } + break; + case STAR: { + setState(1565); + starred_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1575); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 181, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1568); + match(COMMA); + setState(1571); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case COLON: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1569); + slice(); + } + break; + case STAR: { + setState(1570); + starred_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1577); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 181, _ctx); + } + setState(1579); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1578); + match(COMMA); + } + } + + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SliceContext extends ParserRuleContext { + public List COLON() { + return getTokens(PythonParser.COLON); + } + + public TerminalNode COLON(int i) { + return getToken(PythonParser.COLON, i); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public SliceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_slice; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSlice(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSlice(this); + } + } + + public final SliceContext slice() throws RecognitionException { + SliceContext _localctx = new SliceContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_slice); + int _la; + try { + setState(1597); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 188, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1584); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1583); + expression(); + } + } + + setState(1586); + match(COLON); + setState(1588); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1587); + expression(); + } + } + + setState(1594); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(1590); + match(COLON); + setState(1592); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1591); + expression(); + } + } + + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1596); + named_expression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AtomContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode TRUE() { + return getToken(PythonParser.TRUE, 0); + } + + public TerminalNode FALSE() { + return getToken(PythonParser.FALSE, 0); + } + + public TerminalNode NONE() { + return getToken(PythonParser.NONE, 0); + } + + public StringsContext strings() { + return getRuleContext(StringsContext.class, 0); + } + + public TerminalNode NUMBER() { + return getToken(PythonParser.NUMBER, 0); + } + + public TupleContext tuple() { + return getRuleContext(TupleContext.class, 0); + } + + public GroupContext group() { + return getRuleContext(GroupContext.class, 0); + } + + public GenexpContext genexp() { + return getRuleContext(GenexpContext.class, 0); + } + + public ListContext list() { + return getRuleContext(ListContext.class, 0); + } + + public ListcompContext listcomp() { + return getRuleContext(ListcompContext.class, 0); + } + + public DictContext dict() { + return getRuleContext(DictContext.class, 0); + } + + public SetContext set() { + return getRuleContext(SetContext.class, 0); + } + + public DictcompContext dictcomp() { + return getRuleContext(DictcompContext.class, 0); + } + + public SetcompContext setcomp() { + return getRuleContext(SetcompContext.class, 0); + } + + public TerminalNode ELLIPSIS() { + return getToken(PythonParser.ELLIPSIS, 0); + } + + public AtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_atom; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterAtom(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitAtom(this); + } + } + + public final AtomContext atom() throws RecognitionException { + AtomContext _localctx = new AtomContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_atom); + try { + setState(1621); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + enterOuterAlt(_localctx, 1); + { + setState(1599); + match(NAME); + } + break; + case TRUE: + enterOuterAlt(_localctx, 2); + { + setState(1600); + match(TRUE); + } + break; + case FALSE: + enterOuterAlt(_localctx, 3); + { + setState(1601); + match(FALSE); + } + break; + case NONE: + enterOuterAlt(_localctx, 4); + { + setState(1602); + match(NONE); + } + break; + case FSTRING_START: + case STRING: + enterOuterAlt(_localctx, 5); + { + setState(1603); + strings(); + } + break; + case NUMBER: + enterOuterAlt(_localctx, 6); + { + setState(1604); + match(NUMBER); + } + break; + case LPAR: + enterOuterAlt(_localctx, 7); + { + setState(1608); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 189, _ctx)) { + case 1: { + setState(1605); + tuple(); + } + break; + case 2: { + setState(1606); + group(); + } + break; + case 3: { + setState(1607); + genexp(); + } + break; + } + } + break; + case LSQB: + enterOuterAlt(_localctx, 8); + { + setState(1612); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 190, _ctx)) { + case 1: { + setState(1610); + list(); + } + break; + case 2: { + setState(1611); + listcomp(); + } + break; + } + } + break; + case LBRACE: + enterOuterAlt(_localctx, 9); + { + setState(1618); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 191, _ctx)) { + case 1: { + setState(1614); + dict(); + } + break; + case 2: { + setState(1615); + set(); + } + break; + case 3: { + setState(1616); + dictcomp(); + } + break; + case 4: { + setState(1617); + setcomp(); + } + break; + } + } + break; + case ELLIPSIS: + enterOuterAlt(_localctx, 10); + { + setState(1620); + match(ELLIPSIS); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GroupContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public GroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_group; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGroup(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGroup(this); + } + } + + public final GroupContext group() throws RecognitionException { + GroupContext _localctx = new GroupContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_group); + try { + enterOuterAlt(_localctx, 1); + { + setState(1623); + match(LPAR); + setState(1626); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: { + setState(1624); + yield_expr(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1625); + named_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1628); + match(RPAR); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LambdefContext extends ParserRuleContext { + public TerminalNode LAMBDA() { + return getToken(PythonParser.LAMBDA, 0); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Lambda_paramsContext lambda_params() { + return getRuleContext(Lambda_paramsContext.class, 0); + } + + public LambdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambdef; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLambdef(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambdef(this); + } + } + + public final LambdefContext lambdef() throws RecognitionException { + LambdefContext _localctx = new LambdefContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_lambdef); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1630); + match(LAMBDA); + setState(1632); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 68719542273L) != 0)) { + { + setState(1631); + lambda_params(); + } + } + + setState(1634); + match(COLON); + setState(1635); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_paramsContext extends ParserRuleContext { + public Lambda_parametersContext lambda_parameters() { + return getRuleContext(Lambda_parametersContext.class, 0); + } + + public Lambda_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_params; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLambda_params(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambda_params(this); + } + } + + public final Lambda_paramsContext lambda_params() throws RecognitionException { + Lambda_paramsContext _localctx = new Lambda_paramsContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_lambda_params); + try { + enterOuterAlt(_localctx, 1); + { + setState(1637); + lambda_parameters(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_parametersContext extends ParserRuleContext { + public Lambda_slash_no_defaultContext lambda_slash_no_default() { + return getRuleContext(Lambda_slash_no_defaultContext.class, 0); + } + + public List lambda_param_no_default() { + return getRuleContexts(Lambda_param_no_defaultContext.class); + } + + public Lambda_param_no_defaultContext lambda_param_no_default(int i) { + return getRuleContext(Lambda_param_no_defaultContext.class, i); + } + + public List lambda_param_with_default() { + return getRuleContexts(Lambda_param_with_defaultContext.class); + } + + public Lambda_param_with_defaultContext lambda_param_with_default(int i) { + return getRuleContext(Lambda_param_with_defaultContext.class, i); + } + + public Lambda_star_etcContext lambda_star_etc() { + return getRuleContext(Lambda_star_etcContext.class, 0); + } + + public Lambda_slash_with_defaultContext lambda_slash_with_default() { + return getRuleContext(Lambda_slash_with_defaultContext.class, 0); + } + + public Lambda_parametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_parameters; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_parameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambda_parameters(this); + } + } + + public final Lambda_parametersContext lambda_parameters() throws RecognitionException { + Lambda_parametersContext _localctx = new Lambda_parametersContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_lambda_parameters); + int _la; + try { + int _alt; + setState(1688); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 205, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1639); + lambda_slash_no_default(); + setState(1643); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 195, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1640); + lambda_param_no_default(); + } + } + } + setState(1645); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 195, _ctx); + } + setState(1649); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(1646); + lambda_param_with_default(); + } + } + setState(1651); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1653); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(1652); + lambda_star_etc(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1655); + lambda_slash_with_default(); + setState(1659); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(1656); + lambda_param_with_default(); + } + } + setState(1661); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1663); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(1662); + lambda_star_etc(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1666); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1665); + lambda_param_no_default(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1668); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 200, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1673); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(1670); + lambda_param_with_default(); + } + } + setState(1675); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1677); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(1676); + lambda_star_etc(); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1680); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1679); + lambda_param_with_default(); + } + } + setState(1682); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(1685); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == STAR || _la == DOUBLESTAR) { + { + setState(1684); + lambda_star_etc(); + } + } + + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1687); + lambda_star_etc(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_slash_no_defaultContext extends ParserRuleContext { + public TerminalNode SLASH() { + return getToken(PythonParser.SLASH, 0); + } + + public List lambda_param_no_default() { + return getRuleContexts(Lambda_param_no_defaultContext.class); + } + + public Lambda_param_no_defaultContext lambda_param_no_default(int i) { + return getRuleContext(Lambda_param_no_defaultContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_slash_no_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_slash_no_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_slash_no_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitLambda_slash_no_default(this); + } + } + + public final Lambda_slash_no_defaultContext lambda_slash_no_default() throws RecognitionException { + Lambda_slash_no_defaultContext _localctx = new Lambda_slash_no_defaultContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_lambda_slash_no_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1691); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1690); + lambda_param_no_default(); + } + } + setState(1693); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(1695); + match(SLASH); + setState(1697); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1696); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_slash_with_defaultContext extends ParserRuleContext { + public TerminalNode SLASH() { + return getToken(PythonParser.SLASH, 0); + } + + public List lambda_param_no_default() { + return getRuleContexts(Lambda_param_no_defaultContext.class); + } + + public Lambda_param_no_defaultContext lambda_param_no_default(int i) { + return getRuleContext(Lambda_param_no_defaultContext.class, i); + } + + public List lambda_param_with_default() { + return getRuleContexts(Lambda_param_with_defaultContext.class); + } + + public Lambda_param_with_defaultContext lambda_param_with_default(int i) { + return getRuleContext(Lambda_param_with_defaultContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_slash_with_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_slash_with_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_slash_with_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitLambda_slash_with_default(this); + } + } + + public final Lambda_slash_with_defaultContext lambda_slash_with_default() throws RecognitionException { + Lambda_slash_with_defaultContext _localctx = new Lambda_slash_with_defaultContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_lambda_slash_with_default); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1702); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 208, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1699); + lambda_param_no_default(); + } + } + } + setState(1704); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 208, _ctx); + } + setState(1706); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1705); + lambda_param_with_default(); + } + } + setState(1708); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(1710); + match(SLASH); + setState(1712); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1711); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_star_etcContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Lambda_param_no_defaultContext lambda_param_no_default() { + return getRuleContext(Lambda_param_no_defaultContext.class, 0); + } + + public List lambda_param_maybe_default() { + return getRuleContexts(Lambda_param_maybe_defaultContext.class); + } + + public Lambda_param_maybe_defaultContext lambda_param_maybe_default(int i) { + return getRuleContext(Lambda_param_maybe_defaultContext.class, i); + } + + public Lambda_kwdsContext lambda_kwds() { + return getRuleContext(Lambda_kwdsContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_star_etcContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_star_etc; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLambda_star_etc(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambda_star_etc(this); + } + } + + public final Lambda_star_etcContext lambda_star_etc() throws RecognitionException { + Lambda_star_etcContext _localctx = new Lambda_star_etcContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_lambda_star_etc); + int _la; + try { + setState(1736); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 215, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1714); + match(STAR); + setState(1715); + lambda_param_no_default(); + setState(1719); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NAME) { + { + { + setState(1716); + lambda_param_maybe_default(); + } + } + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1723); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == DOUBLESTAR) { + { + setState(1722); + lambda_kwds(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1725); + match(STAR); + setState(1726); + match(COMMA); + setState(1728); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1727); + lambda_param_maybe_default(); + } + } + setState(1730); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NAME); + setState(1733); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == DOUBLESTAR) { + { + setState(1732); + lambda_kwds(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1735); + lambda_kwds(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_kwdsContext extends ParserRuleContext { + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Lambda_param_no_defaultContext lambda_param_no_default() { + return getRuleContext(Lambda_param_no_defaultContext.class, 0); + } + + public Lambda_kwdsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_kwds; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLambda_kwds(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambda_kwds(this); + } + } + + public final Lambda_kwdsContext lambda_kwds() throws RecognitionException { + Lambda_kwdsContext _localctx = new Lambda_kwdsContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_lambda_kwds); + try { + enterOuterAlt(_localctx, 1); + { + setState(1738); + match(DOUBLESTAR); + setState(1739); + lambda_param_no_default(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_param_no_defaultContext extends ParserRuleContext { + public Lambda_paramContext lambda_param() { + return getRuleContext(Lambda_paramContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_param_no_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_param_no_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_param_no_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitLambda_param_no_default(this); + } + } + + public final Lambda_param_no_defaultContext lambda_param_no_default() throws RecognitionException { + Lambda_param_no_defaultContext _localctx = new Lambda_param_no_defaultContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_lambda_param_no_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1741); + lambda_param(); + setState(1743); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1742); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_param_with_defaultContext extends ParserRuleContext { + public Lambda_paramContext lambda_param() { + return getRuleContext(Lambda_paramContext.class, 0); + } + + public Default_assignmentContext default_assignment() { + return getRuleContext(Default_assignmentContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_param_with_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_param_with_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_param_with_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitLambda_param_with_default(this); + } + } + + public final Lambda_param_with_defaultContext lambda_param_with_default() throws RecognitionException { + Lambda_param_with_defaultContext _localctx = new Lambda_param_with_defaultContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_lambda_param_with_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1745); + lambda_param(); + setState(1746); + default_assignment(); + setState(1748); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1747); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_param_maybe_defaultContext extends ParserRuleContext { + public Lambda_paramContext lambda_param() { + return getRuleContext(Lambda_paramContext.class, 0); + } + + public Default_assignmentContext default_assignment() { + return getRuleContext(Default_assignmentContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Lambda_param_maybe_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_param_maybe_default; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterLambda_param_maybe_default(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitLambda_param_maybe_default(this); + } + } + + public final Lambda_param_maybe_defaultContext lambda_param_maybe_default() throws RecognitionException { + Lambda_param_maybe_defaultContext _localctx = new Lambda_param_maybe_defaultContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_lambda_param_maybe_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1750); + lambda_param(); + setState(1752); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EQUAL) { + { + setState(1751); + default_assignment(); + } + } + + setState(1755); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1754); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lambda_paramContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Lambda_paramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_lambda_param; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterLambda_param(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitLambda_param(this); + } + } + + public final Lambda_paramContext lambda_param() throws RecognitionException { + Lambda_paramContext _localctx = new Lambda_paramContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_lambda_param); + try { + enterOuterAlt(_localctx, 1); + { + setState(1757); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_middleContext extends ParserRuleContext { + public Fstring_replacement_fieldContext fstring_replacement_field() { + return getRuleContext(Fstring_replacement_fieldContext.class, 0); + } + + public TerminalNode FSTRING_MIDDLE() { + return getToken(PythonParser.FSTRING_MIDDLE, 0); + } + + public Fstring_middleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_middle; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFstring_middle(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFstring_middle(this); + } + } + + public final Fstring_middleContext fstring_middle() throws RecognitionException { + Fstring_middleContext _localctx = new Fstring_middleContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_fstring_middle); + try { + setState(1761); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(1759); + fstring_replacement_field(); + } + break; + case FSTRING_MIDDLE: + enterOuterAlt(_localctx, 2); + { + setState(1760); + match(FSTRING_MIDDLE); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_replacement_fieldContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class, 0); + } + + public Star_expressionsContext star_expressions() { + return getRuleContext(Star_expressionsContext.class, 0); + } + + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public Fstring_conversionContext fstring_conversion() { + return getRuleContext(Fstring_conversionContext.class, 0); + } + + public Fstring_full_format_specContext fstring_full_format_spec() { + return getRuleContext(Fstring_full_format_specContext.class, 0); + } + + public Fstring_replacement_fieldContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_replacement_field; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterFstring_replacement_field(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitFstring_replacement_field(this); + } + } + + public final Fstring_replacement_fieldContext fstring_replacement_field() throws RecognitionException { + Fstring_replacement_fieldContext _localctx = new Fstring_replacement_fieldContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_fstring_replacement_field); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1763); + match(LBRACE); + setState(1766); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: { + setState(1764); + yield_expr(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1765); + star_expressions(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1769); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EQUAL) { + { + setState(1768); + match(EQUAL); + } + } + + setState(1772); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == EXCLAMATION) { + { + setState(1771); + fstring_conversion(); + } + } + + setState(1775); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(1774); + fstring_full_format_spec(); + } + } + + setState(1777); + match(RBRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_conversionContext extends ParserRuleContext { + public TerminalNode EXCLAMATION() { + return getToken(PythonParser.EXCLAMATION, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Fstring_conversionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_conversion; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterFstring_conversion(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitFstring_conversion(this); + } + } + + public final Fstring_conversionContext fstring_conversion() throws RecognitionException { + Fstring_conversionContext _localctx = new Fstring_conversionContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_fstring_conversion); + try { + enterOuterAlt(_localctx, 1); + { + setState(1779); + match(EXCLAMATION); + setState(1780); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_full_format_specContext extends ParserRuleContext { + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public List fstring_format_spec() { + return getRuleContexts(Fstring_format_specContext.class); + } + + public Fstring_format_specContext fstring_format_spec(int i) { + return getRuleContext(Fstring_format_specContext.class, i); + } + + public Fstring_full_format_specContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_full_format_spec; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterFstring_full_format_spec(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitFstring_full_format_spec(this); + } + } + + public final Fstring_full_format_specContext fstring_full_format_spec() throws RecognitionException { + Fstring_full_format_specContext _localctx = new Fstring_full_format_specContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_fstring_full_format_spec); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1782); + match(COLON); + setState(1786); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == FSTRING_MIDDLE || _la == LBRACE) { + { + { + setState(1783); + fstring_format_spec(); + } + } + setState(1788); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fstring_format_specContext extends ParserRuleContext { + public TerminalNode FSTRING_MIDDLE() { + return getToken(PythonParser.FSTRING_MIDDLE, 0); + } + + public Fstring_replacement_fieldContext fstring_replacement_field() { + return getRuleContext(Fstring_replacement_fieldContext.class, 0); + } + + public Fstring_format_specContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring_format_spec; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterFstring_format_spec(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitFstring_format_spec(this); + } + } + + public final Fstring_format_specContext fstring_format_spec() throws RecognitionException { + Fstring_format_specContext _localctx = new Fstring_format_specContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_fstring_format_spec); + try { + setState(1791); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_MIDDLE: + enterOuterAlt(_localctx, 1); + { + setState(1789); + match(FSTRING_MIDDLE); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(1790); + fstring_replacement_field(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FstringContext extends ParserRuleContext { + public TerminalNode FSTRING_START() { + return getToken(PythonParser.FSTRING_START, 0); + } + + public TerminalNode FSTRING_END() { + return getToken(PythonParser.FSTRING_END, 0); + } + + public List fstring_middle() { + return getRuleContexts(Fstring_middleContext.class); + } + + public Fstring_middleContext fstring_middle(int i) { + return getRuleContext(Fstring_middleContext.class, i); + } + + public FstringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_fstring; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFstring(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFstring(this); + } + } + + public final FstringContext fstring() throws RecognitionException { + FstringContext _localctx = new FstringContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_fstring); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1793); + match(FSTRING_START); + setState(1797); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == FSTRING_MIDDLE || _la == LBRACE) { + { + { + setState(1794); + fstring_middle(); + } + } + setState(1799); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1800); + match(FSTRING_END); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringContext extends ParserRuleContext { + public TerminalNode STRING() { + return getToken(PythonParser.STRING, 0); + } + + public StringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_string; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterString(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitString(this); + } + } + + public final StringContext string() throws RecognitionException { + StringContext _localctx = new StringContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_string); + try { + enterOuterAlt(_localctx, 1); + { + setState(1802); + match(STRING); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringsContext extends ParserRuleContext { + public List fstring() { + return getRuleContexts(FstringContext.class); + } + + public FstringContext fstring(int i) { + return getRuleContext(FstringContext.class, i); + } + + public List string() { + return getRuleContexts(StringContext.class); + } + + public StringContext string(int i) { + return getRuleContext(StringContext.class, i); + } + + public StringsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_strings; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStrings(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStrings(this); + } + } + + public final StringsContext strings() throws RecognitionException { + StringsContext _localctx = new StringsContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_strings); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1806); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + setState(1806); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: { + setState(1804); + fstring(); + } + break; + case STRING: { + setState(1805); + string(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1808); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 229, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ListContext extends ParserRuleContext { + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Star_named_expressionsContext star_named_expressions() { + return getRuleContext(Star_named_expressionsContext.class, 0); + } + + public ListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_list; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitList(this); + } + } + + public final ListContext list() throws RecognitionException { + ListContext _localctx = new ListContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1810); + match(LSQB); + setState(1812); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1811); + star_named_expressions(); + } + } + + setState(1814); + match(RSQB); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Star_named_expressionContext star_named_expression() { + return getRuleContext(Star_named_expressionContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public Star_named_expressionsContext star_named_expressions() { + return getRuleContext(Star_named_expressionsContext.class, 0); + } + + public TupleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_tuple; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterTuple(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitTuple(this); + } + } + + public final TupleContext tuple() throws RecognitionException { + TupleContext _localctx = new TupleContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_tuple); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1816); + match(LPAR); + setState(1822); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1817); + star_named_expression(); + setState(1818); + match(COMMA); + setState(1820); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537665L) != 0)) { + { + setState(1819); + star_named_expressions(); + } + } + + } + } + + setState(1824); + match(RPAR); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public Star_named_expressionsContext star_named_expressions() { + return getRuleContext(Star_named_expressionsContext.class, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public SetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_set; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSet(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSet(this); + } + } + + public final SetContext set() throws RecognitionException { + SetContext _localctx = new SetContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_set); + try { + enterOuterAlt(_localctx, 1); + { + setState(1826); + match(LBRACE); + setState(1827); + star_named_expressions(); + setState(1828); + match(RBRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DictContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public Double_starred_kvpairsContext double_starred_kvpairs() { + return getRuleContext(Double_starred_kvpairsContext.class, 0); + } + + public DictContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_dict; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDict(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDict(this); + } + } + + public final DictContext dict() throws RecognitionException { + DictContext _localctx = new DictContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_dict); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1830); + match(LBRACE); + setState(1832); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 13541619601117584L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537681L) != 0)) { + { + setState(1831); + double_starred_kvpairs(); + } + } + + setState(1834); + match(RBRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Double_starred_kvpairsContext extends ParserRuleContext { + public List double_starred_kvpair() { + return getRuleContexts(Double_starred_kvpairContext.class); + } + + public Double_starred_kvpairContext double_starred_kvpair(int i) { + return getRuleContext(Double_starred_kvpairContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Double_starred_kvpairsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_double_starred_kvpairs; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterDouble_starred_kvpairs(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitDouble_starred_kvpairs(this); + } + } + + public final Double_starred_kvpairsContext double_starred_kvpairs() throws RecognitionException { + Double_starred_kvpairsContext _localctx = new Double_starred_kvpairsContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_double_starred_kvpairs); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1836); + double_starred_kvpair(); + setState(1841); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 234, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1837); + match(COMMA); + setState(1838); + double_starred_kvpair(); + } + } + } + setState(1843); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 234, _ctx); + } + setState(1845); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1844); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Double_starred_kvpairContext extends ParserRuleContext { + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Bitwise_orContext bitwise_or() { + return getRuleContext(Bitwise_orContext.class, 0); + } + + public KvpairContext kvpair() { + return getRuleContext(KvpairContext.class, 0); + } + + public Double_starred_kvpairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_double_starred_kvpair; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterDouble_starred_kvpair(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitDouble_starred_kvpair(this); + } + } + + public final Double_starred_kvpairContext double_starred_kvpair() throws RecognitionException { + Double_starred_kvpairContext _localctx = new Double_starred_kvpairContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_double_starred_kvpair); + try { + setState(1850); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOUBLESTAR: + enterOuterAlt(_localctx, 1); + { + setState(1847); + match(DOUBLESTAR); + setState(1848); + bitwise_or(0); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(1849); + kvpair(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KvpairContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode COLON() { + return getToken(PythonParser.COLON, 0); + } + + public KvpairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kvpair; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKvpair(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKvpair(this); + } + } + + public final KvpairContext kvpair() throws RecognitionException { + KvpairContext _localctx = new KvpairContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_kvpair); + try { + enterOuterAlt(_localctx, 1); + { + setState(1852); + expression(); + setState(1853); + match(COLON); + setState(1854); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_if_clausesContext extends ParserRuleContext { + public List for_if_clause() { + return getRuleContexts(For_if_clauseContext.class); + } + + public For_if_clauseContext for_if_clause(int i) { + return getRuleContext(For_if_clauseContext.class, i); + } + + public For_if_clausesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_for_if_clauses; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFor_if_clauses(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFor_if_clauses(this); + } + } + + public final For_if_clausesContext for_if_clauses() throws RecognitionException { + For_if_clausesContext _localctx = new For_if_clausesContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_for_if_clauses); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1857); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1856); + for_if_clause(); + } + } + setState(1859); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == FOR || _la == ASYNC); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_if_clauseContext extends ParserRuleContext { + public TerminalNode FOR() { + return getToken(PythonParser.FOR, 0); + } + + public Star_targetsContext star_targets() { + return getRuleContext(Star_targetsContext.class, 0); + } + + public TerminalNode IN() { + return getToken(PythonParser.IN, 0); + } + + public List disjunction() { + return getRuleContexts(DisjunctionContext.class); + } + + public DisjunctionContext disjunction(int i) { + return getRuleContext(DisjunctionContext.class, i); + } + + public TerminalNode ASYNC() { + return getToken(PythonParser.ASYNC, 0); + } + + public List IF() { + return getTokens(PythonParser.IF); + } + + public TerminalNode IF(int i) { + return getToken(PythonParser.IF, i); + } + + public For_if_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_for_if_clause; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterFor_if_clause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFor_if_clause(this); + } + } + + public final For_if_clauseContext for_if_clause() throws RecognitionException { + For_if_clauseContext _localctx = new For_if_clauseContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_for_if_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1862); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ASYNC) { + { + setState(1861); + match(ASYNC); + } + } + + setState(1864); + match(FOR); + setState(1865); + star_targets(); + setState(1866); + match(IN); + setState(1867); + disjunction(); + setState(1872); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == IF) { + { + { + setState(1868); + match(IF); + setState(1869); + disjunction(); + } + } + setState(1874); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ListcompContext extends ParserRuleContext { + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public For_if_clausesContext for_if_clauses() { + return getRuleContext(For_if_clausesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public ListcompContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_listcomp; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterListcomp(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitListcomp(this); + } + } + + public final ListcompContext listcomp() throws RecognitionException { + ListcompContext _localctx = new ListcompContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_listcomp); + try { + enterOuterAlt(_localctx, 1); + { + setState(1875); + match(LSQB); + setState(1876); + named_expression(); + setState(1877); + for_if_clauses(); + setState(1878); + match(RSQB); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetcompContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public Named_expressionContext named_expression() { + return getRuleContext(Named_expressionContext.class, 0); + } + + public For_if_clausesContext for_if_clauses() { + return getRuleContext(For_if_clausesContext.class, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public SetcompContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_setcomp; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSetcomp(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSetcomp(this); + } + } + + public final SetcompContext setcomp() throws RecognitionException { + SetcompContext _localctx = new SetcompContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_setcomp); + try { + enterOuterAlt(_localctx, 1); + { + setState(1880); + match(LBRACE); + setState(1881); + named_expression(); + setState(1882); + for_if_clauses(); + setState(1883); + match(RBRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GenexpContext extends ParserRuleContext { + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public For_if_clausesContext for_if_clauses() { + return getRuleContext(For_if_clausesContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Assignment_expressionContext assignment_expression() { + return getRuleContext(Assignment_expressionContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public GenexpContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_genexp; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterGenexp(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitGenexp(this); + } + } + + public final GenexpContext genexp() throws RecognitionException { + GenexpContext _localctx = new GenexpContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_genexp); + try { + enterOuterAlt(_localctx, 1); + { + setState(1885); + match(LPAR); + setState(1888); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 240, _ctx)) { + case 1: { + setState(1886); + assignment_expression(); + } + break; + case 2: { + setState(1887); + expression(); + } + break; + } + setState(1890); + for_if_clauses(); + setState(1891); + match(RPAR); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DictcompContext extends ParserRuleContext { + public TerminalNode LBRACE() { + return getToken(PythonParser.LBRACE, 0); + } + + public KvpairContext kvpair() { + return getRuleContext(KvpairContext.class, 0); + } + + public For_if_clausesContext for_if_clauses() { + return getRuleContext(For_if_clausesContext.class, 0); + } + + public TerminalNode RBRACE() { + return getToken(PythonParser.RBRACE, 0); + } + + public DictcompContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_dictcomp; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDictcomp(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDictcomp(this); + } + } + + public final DictcompContext dictcomp() throws RecognitionException { + DictcompContext _localctx = new DictcompContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_dictcomp); + try { + enterOuterAlt(_localctx, 1); + { + setState(1893); + match(LBRACE); + setState(1894); + kvpair(); + setState(1895); + for_if_clauses(); + setState(1896); + match(RBRACE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgumentsContext extends ParserRuleContext { + public ArgsContext args() { + return getRuleContext(ArgsContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(PythonParser.COMMA, 0); + } + + public ArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_arguments; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterArguments(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitArguments(this); + } + } + + public final ArgumentsContext arguments() throws RecognitionException { + ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_arguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1898); + args(); + setState(1900); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1899); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArgsContext extends ParserRuleContext { + public List starred_expression() { + return getRuleContexts(Starred_expressionContext.class); + } + + public Starred_expressionContext starred_expression(int i) { + return getRuleContext(Starred_expressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public KwargsContext kwargs() { + return getRuleContext(KwargsContext.class, 0); + } + + public List assignment_expression() { + return getRuleContexts(Assignment_expressionContext.class); + } + + public Assignment_expressionContext assignment_expression(int i) { + return getRuleContext(Assignment_expressionContext.class, i); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public ArgsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_args; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterArgs(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitArgs(this); + } + } + + public final ArgsContext args() throws RecognitionException { + ArgsContext _localctx = new ArgsContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_args); + try { + int _alt; + setState(1927); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 248, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1907); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: { + setState(1902); + starred_expression(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1905); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 242, _ctx)) { + case 1: { + setState(1903); + assignment_expression(); + } + break; + case 2: { + setState(1904); + expression(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1919); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1909); + match(COMMA); + setState(1915); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: { + setState(1910); + starred_expression(); + } + break; + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: { + setState(1913); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 244, _ctx)) { + case 1: { + setState(1911); + assignment_expression(); + } + break; + case 2: { + setState(1912); + expression(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1921); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 246, _ctx); + } + setState(1924); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 247, _ctx)) { + case 1: { + setState(1922); + match(COMMA); + setState(1923); + kwargs(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1926); + kwargs(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KwargsContext extends ParserRuleContext { + public List kwarg_or_starred() { + return getRuleContexts(Kwarg_or_starredContext.class); + } + + public Kwarg_or_starredContext kwarg_or_starred(int i) { + return getRuleContext(Kwarg_or_starredContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public List kwarg_or_double_starred() { + return getRuleContexts(Kwarg_or_double_starredContext.class); + } + + public Kwarg_or_double_starredContext kwarg_or_double_starred(int i) { + return getRuleContext(Kwarg_or_double_starredContext.class, i); + } + + public KwargsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kwargs; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKwargs(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKwargs(this); + } + } + + public final KwargsContext kwargs() throws RecognitionException { + KwargsContext _localctx = new KwargsContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_kwargs); + try { + int _alt; + setState(1956); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 253, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1929); + kwarg_or_starred(); + setState(1934); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 249, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1930); + match(COMMA); + setState(1931); + kwarg_or_starred(); + } + } + } + setState(1936); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 249, _ctx); + } + setState(1946); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 251, _ctx)) { + case 1: { + setState(1937); + match(COMMA); + setState(1938); + kwarg_or_double_starred(); + setState(1943); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 250, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1939); + match(COMMA); + setState(1940); + kwarg_or_double_starred(); + } + } + } + setState(1945); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 250, _ctx); + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1948); + kwarg_or_double_starred(); + setState(1953); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 252, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1949); + match(COMMA); + setState(1950); + kwarg_or_double_starred(); + } + } + } + setState(1955); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 252, _ctx); + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Starred_expressionContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Starred_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_starred_expression; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStarred_expression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitStarred_expression(this); + } + } + + public final Starred_expressionContext starred_expression() throws RecognitionException { + Starred_expressionContext _localctx = new Starred_expressionContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_starred_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1958); + match(STAR); + setState(1959); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Kwarg_or_starredContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public Starred_expressionContext starred_expression() { + return getRuleContext(Starred_expressionContext.class, 0); + } + + public Kwarg_or_starredContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kwarg_or_starred; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterKwarg_or_starred(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitKwarg_or_starred(this); + } + } + + public final Kwarg_or_starredContext kwarg_or_starred() throws RecognitionException { + Kwarg_or_starredContext _localctx = new Kwarg_or_starredContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_kwarg_or_starred); + try { + setState(1965); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + enterOuterAlt(_localctx, 1); + { + setState(1961); + match(NAME); + setState(1962); + match(EQUAL); + setState(1963); + expression(); + } + break; + case STAR: + enterOuterAlt(_localctx, 2); + { + setState(1964); + starred_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Kwarg_or_double_starredContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode EQUAL() { + return getToken(PythonParser.EQUAL, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Kwarg_or_double_starredContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_kwarg_or_double_starred; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterKwarg_or_double_starred(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitKwarg_or_double_starred(this); + } + } + + public final Kwarg_or_double_starredContext kwarg_or_double_starred() throws RecognitionException { + Kwarg_or_double_starredContext _localctx = new Kwarg_or_double_starredContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_kwarg_or_double_starred); + try { + setState(1972); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + enterOuterAlt(_localctx, 1); + { + setState(1967); + match(NAME); + setState(1968); + match(EQUAL); + setState(1969); + expression(); + } + break; + case DOUBLESTAR: + enterOuterAlt(_localctx, 2); + { + setState(1970); + match(DOUBLESTAR); + setState(1971); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_targetsContext extends ParserRuleContext { + public List star_target() { + return getRuleContexts(Star_targetContext.class); + } + + public Star_targetContext star_target(int i) { + return getRuleContext(Star_targetContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Star_targetsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_targets; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_targets(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_targets(this); + } + } + + public final Star_targetsContext star_targets() throws RecognitionException { + Star_targetsContext _localctx = new Star_targetsContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_star_targets); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1974); + star_target(); + setState(1979); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 256, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1975); + match(COMMA); + setState(1976); + star_target(); + } + } + } + setState(1981); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 256, _ctx); + } + setState(1983); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1982); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_targets_list_seqContext extends ParserRuleContext { + public List star_target() { + return getRuleContexts(Star_targetContext.class); + } + + public Star_targetContext star_target(int i) { + return getRuleContext(Star_targetContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Star_targets_list_seqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_targets_list_seq; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStar_targets_list_seq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitStar_targets_list_seq(this); + } + } + + public final Star_targets_list_seqContext star_targets_list_seq() throws RecognitionException { + Star_targets_list_seqContext _localctx = new Star_targets_list_seqContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_star_targets_list_seq); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1985); + star_target(); + setState(1988); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1986); + match(COMMA); + setState(1987); + star_target(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1990); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 258, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1993); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1992); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_targets_tuple_seqContext extends ParserRuleContext { + public List star_target() { + return getRuleContexts(Star_targetContext.class); + } + + public Star_targetContext star_target(int i) { + return getRuleContext(Star_targetContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Star_targets_tuple_seqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_targets_tuple_seq; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterStar_targets_tuple_seq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitStar_targets_tuple_seq(this); + } + } + + public final Star_targets_tuple_seqContext star_targets_tuple_seq() throws RecognitionException { + Star_targets_tuple_seqContext _localctx = new Star_targets_tuple_seqContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_star_targets_tuple_seq); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1995); + star_target(); + setState(2006); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 262, _ctx)) { + case 1: { + setState(1996); + match(COMMA); + } + break; + case 2: { + setState(1999); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: { + { + setState(1997); + match(COMMA); + setState(1998); + star_target(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(2001); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 260, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(2004); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2003); + match(COMMA); + } + } + + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_targetContext extends ParserRuleContext { + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public Star_targetContext star_target() { + return getRuleContext(Star_targetContext.class, 0); + } + + public Target_with_star_atomContext target_with_star_atom() { + return getRuleContext(Target_with_star_atomContext.class, 0); + } + + public Star_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_target(this); + } + } + + public final Star_targetContext star_target() throws RecognitionException { + Star_targetContext _localctx = new Star_targetContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_star_target); + try { + setState(2011); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + enterOuterAlt(_localctx, 1); + { + setState(2008); + match(STAR); + { + setState(2009); + star_target(); + } + } + break; + case FSTRING_START: + case FALSE: + case NONE: + case TRUE: + case LPAR: + case LSQB: + case LBRACE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 2); + { + setState(2010); + target_with_star_atom(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Target_with_star_atomContext extends ParserRuleContext { + public T_primaryContext t_primary() { + return getRuleContext(T_primaryContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public SlicesContext slices() { + return getRuleContext(SlicesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Star_atomContext star_atom() { + return getRuleContext(Star_atomContext.class, 0); + } + + public Target_with_star_atomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_target_with_star_atom; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterTarget_with_star_atom(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitTarget_with_star_atom(this); + } + } + + public final Target_with_star_atomContext target_with_star_atom() throws RecognitionException { + Target_with_star_atomContext _localctx = new Target_with_star_atomContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_target_with_star_atom); + try { + setState(2023); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 265, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2013); + t_primary(0); + setState(2020); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: { + setState(2014); + match(DOT); + setState(2015); + match(NAME); + } + break; + case LSQB: { + setState(2016); + match(LSQB); + setState(2017); + slices(); + setState(2018); + match(RSQB); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2022); + star_atom(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Star_atomContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public Target_with_star_atomContext target_with_star_atom() { + return getRuleContext(Target_with_star_atomContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Star_targets_tuple_seqContext star_targets_tuple_seq() { + return getRuleContext(Star_targets_tuple_seqContext.class, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Star_targets_list_seqContext star_targets_list_seq() { + return getRuleContext(Star_targets_list_seqContext.class, 0); + } + + public Star_atomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_star_atom; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterStar_atom(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitStar_atom(this); + } + } + + public final Star_atomContext star_atom() throws RecognitionException { + Star_atomContext _localctx = new Star_atomContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_star_atom); + int _la; + try { + setState(2040); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 268, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2025); + match(NAME); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2026); + match(LPAR); + setState(2027); + target_with_star_atom(); + setState(2028); + match(RPAR); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2030); + match(LPAR); + setState(2032); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 18045184835195024L) != 0) || ((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 57L) != 0)) { + { + setState(2031); + star_targets_tuple_seq(); + } + } + + setState(2034); + match(RPAR); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2035); + match(LSQB); + setState(2037); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 18045184835195024L) != 0) || ((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 57L) != 0)) { + { + setState(2036); + star_targets_list_seq(); + } + } + + setState(2039); + match(RSQB); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Single_targetContext extends ParserRuleContext { + public Single_subscript_attribute_targetContext single_subscript_attribute_target() { + return getRuleContext(Single_subscript_attribute_targetContext.class, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public Single_targetContext single_target() { + return getRuleContext(Single_targetContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Single_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_single_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSingle_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSingle_target(this); + } + } + + public final Single_targetContext single_target() throws RecognitionException { + Single_targetContext _localctx = new Single_targetContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_single_target); + try { + setState(2048); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 269, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2042); + single_subscript_attribute_target(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2043); + match(NAME); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2044); + match(LPAR); + setState(2045); + single_target(); + setState(2046); + match(RPAR); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Single_subscript_attribute_targetContext extends ParserRuleContext { + public T_primaryContext t_primary() { + return getRuleContext(T_primaryContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public SlicesContext slices() { + return getRuleContext(SlicesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Single_subscript_attribute_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_single_subscript_attribute_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterSingle_subscript_attribute_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitSingle_subscript_attribute_target(this); + } + } + + public final Single_subscript_attribute_targetContext single_subscript_attribute_target() throws RecognitionException { + Single_subscript_attribute_targetContext _localctx = new Single_subscript_attribute_targetContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_single_subscript_attribute_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(2050); + t_primary(0); + setState(2057); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: { + setState(2051); + match(DOT); + setState(2052); + match(NAME); + } + break; + case LSQB: { + setState(2053); + match(LSQB); + setState(2054); + slices(); + setState(2055); + match(RSQB); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class T_primaryContext extends ParserRuleContext { + public AtomContext atom() { + return getRuleContext(AtomContext.class, 0); + } + + public T_primaryContext t_primary() { + return getRuleContext(T_primaryContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public SlicesContext slices() { + return getRuleContext(SlicesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public GenexpContext genexp() { + return getRuleContext(GenexpContext.class, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class, 0); + } + + public T_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_t_primary; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterT_primary(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitT_primary(this); + } + } + + public final T_primaryContext t_primary() throws RecognitionException { + return t_primary(0); + } + + private T_primaryContext t_primary(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + T_primaryContext _localctx = new T_primaryContext(_ctx, _parentState); + T_primaryContext _prevctx = _localctx; + int _startState = 374; + enterRecursionRule(_localctx, 374, RULE_t_primary, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2060); + atom(); + } + _ctx.stop = _input.LT(-1); + setState(2079); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 273, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + if (_parseListeners != null) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new T_primaryContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_t_primary); + setState(2062); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2075); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 272, _ctx)) { + case 1: { + setState(2063); + match(DOT); + setState(2064); + match(NAME); + } + break; + case 2: { + setState(2065); + match(LSQB); + setState(2066); + slices(); + setState(2067); + match(RSQB); + } + break; + case 3: { + setState(2069); + genexp(); + } + break; + case 4: { + setState(2070); + match(LPAR); + setState(2072); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 31556018110599568L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 119537681L) != 0)) { + { + setState(2071); + arguments(); + } + } + + setState(2074); + match(RPAR); + } + break; + } + } + } + } + setState(2081); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 273, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Del_targetsContext extends ParserRuleContext { + public List del_target() { + return getRuleContexts(Del_targetContext.class); + } + + public Del_targetContext del_target(int i) { + return getRuleContext(Del_targetContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public Del_targetsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_del_targets; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDel_targets(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDel_targets(this); + } + } + + public final Del_targetsContext del_targets() throws RecognitionException { + Del_targetsContext _localctx = new Del_targetsContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_del_targets); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2082); + del_target(); + setState(2087); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 274, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2083); + match(COMMA); + setState(2084); + del_target(); + } + } + } + setState(2089); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 274, _ctx); + } + setState(2091); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2090); + match(COMMA); + } + } + + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Del_targetContext extends ParserRuleContext { + public T_primaryContext t_primary() { + return getRuleContext(T_primaryContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(PythonParser.DOT, 0); + } + + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public SlicesContext slices() { + return getRuleContext(SlicesContext.class, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Del_t_atomContext del_t_atom() { + return getRuleContext(Del_t_atomContext.class, 0); + } + + public Del_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_del_target; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDel_target(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDel_target(this); + } + } + + public final Del_targetContext del_target() throws RecognitionException { + Del_targetContext _localctx = new Del_targetContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_del_target); + try { + setState(2103); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 277, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2093); + t_primary(0); + setState(2100); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: { + setState(2094); + match(DOT); + setState(2095); + match(NAME); + } + break; + case LSQB: { + setState(2096); + match(LSQB); + setState(2097); + slices(); + setState(2098); + match(RSQB); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2102); + del_t_atom(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Del_t_atomContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public TerminalNode LPAR() { + return getToken(PythonParser.LPAR, 0); + } + + public Del_targetContext del_target() { + return getRuleContext(Del_targetContext.class, 0); + } + + public TerminalNode RPAR() { + return getToken(PythonParser.RPAR, 0); + } + + public Del_targetsContext del_targets() { + return getRuleContext(Del_targetsContext.class, 0); + } + + public TerminalNode LSQB() { + return getToken(PythonParser.LSQB, 0); + } + + public TerminalNode RSQB() { + return getToken(PythonParser.RSQB, 0); + } + + public Del_t_atomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_del_t_atom; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterDel_t_atom(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitDel_t_atom(this); + } + } + + public final Del_t_atomContext del_t_atom() throws RecognitionException { + Del_t_atomContext _localctx = new Del_t_atomContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_del_t_atom); + int _la; + try { + setState(2120); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 280, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2105); + match(NAME); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2106); + match(LPAR); + setState(2107); + del_target(); + setState(2108); + match(RPAR); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2110); + match(LPAR); + setState(2112); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 30786325713040L) != 0) || ((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 57L) != 0)) { + { + setState(2111); + del_targets(); + } + } + + setState(2114); + match(RPAR); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2115); + match(LSQB); + setState(2117); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 30786325713040L) != 0) || ((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 57L) != 0)) { + { + setState(2116); + del_targets(); + } + } + + setState(2119); + match(RSQB); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_expressionsContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(PythonParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(PythonParser.COMMA, i); + } + + public TerminalNode STAR() { + return getToken(PythonParser.STAR, 0); + } + + public TerminalNode DOUBLESTAR() { + return getToken(PythonParser.DOUBLESTAR, 0); + } + + public Type_expressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_type_expressions; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterType_expressions(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitType_expressions(this); + } + } + + public final Type_expressionsContext type_expressions() throws RecognitionException { + Type_expressionsContext _localctx = new Type_expressionsContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_type_expressions); + int _la; + try { + int _alt; + setState(2153); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FSTRING_START: + case FALSE: + case AWAIT: + case NONE: + case TRUE: + case LAMBDA: + case NOT: + case LPAR: + case LSQB: + case LBRACE: + case PLUS: + case MINUS: + case TILDE: + case ELLIPSIS: + case NAME: + case NUMBER: + case STRING: + enterOuterAlt(_localctx, 1); + { + setState(2122); + expression(); + setState(2127); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 281, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2123); + match(COMMA); + setState(2124); + expression(); + } + } + } + setState(2129); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 281, _ctx); + } + setState(2142); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2130); + match(COMMA); + setState(2140); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: { + setState(2131); + match(STAR); + setState(2132); + expression(); + setState(2136); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2133); + match(COMMA); + setState(2134); + match(DOUBLESTAR); + setState(2135); + expression(); + } + } + + } + break; + case DOUBLESTAR: { + setState(2138); + match(DOUBLESTAR); + setState(2139); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + } + break; + case STAR: + enterOuterAlt(_localctx, 2); + { + setState(2144); + match(STAR); + setState(2145); + expression(); + setState(2149); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(2146); + match(COMMA); + setState(2147); + match(DOUBLESTAR); + setState(2148); + expression(); + } + } + + } + break; + case DOUBLESTAR: + enterOuterAlt(_localctx, 3); + { + setState(2151); + match(DOUBLESTAR); + setState(2152); + expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_type_commentContext extends ParserRuleContext { + public TerminalNode NEWLINE() { + return getToken(PythonParser.NEWLINE, 0); + } + + public TerminalNode TYPE_COMMENT() { + return getToken(PythonParser.TYPE_COMMENT, 0); + } + + public Func_type_commentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_func_type_comment; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterFunc_type_comment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitFunc_type_comment(this); + } + } + + public final Func_type_commentContext func_type_comment() throws RecognitionException { + Func_type_commentContext _localctx = new Func_type_commentContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_func_type_comment); + try { + setState(2158); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEWLINE: + enterOuterAlt(_localctx, 1); + { + setState(2155); + match(NEWLINE); + setState(2156); + match(TYPE_COMMENT); + } + break; + case TYPE_COMMENT: + enterOuterAlt(_localctx, 2); + { + setState(2157); + match(TYPE_COMMENT); + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Soft_kw_typeContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Soft_kw_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_soft_kw_type; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSoft_kw_type(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSoft_kw_type(this); + } + } + + public final Soft_kw_typeContext soft_kw_type() throws RecognitionException { + Soft_kw_typeContext _localctx = new Soft_kw_typeContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_soft_kw_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(2160); + if (!(this.isEqualToCurrentTokenText("type"))) + throw new FailedPredicateException(this, "this.isEqualToCurrentTokenText(\"type\")"); + setState(2161); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Soft_kw_matchContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Soft_kw_matchContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_soft_kw_match; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSoft_kw_match(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSoft_kw_match(this); + } + } + + public final Soft_kw_matchContext soft_kw_match() throws RecognitionException { + Soft_kw_matchContext _localctx = new Soft_kw_matchContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_soft_kw_match); + try { + enterOuterAlt(_localctx, 1); + { + setState(2163); + if (!(this.isEqualToCurrentTokenText("match"))) + throw new FailedPredicateException(this, "this.isEqualToCurrentTokenText(\"match\")"); + setState(2164); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Soft_kw_caseContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Soft_kw_caseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_soft_kw_case; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSoft_kw_case(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSoft_kw_case(this); + } + } + + public final Soft_kw_caseContext soft_kw_case() throws RecognitionException { + Soft_kw_caseContext _localctx = new Soft_kw_caseContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_soft_kw_case); + try { + enterOuterAlt(_localctx, 1); + { + setState(2166); + if (!(this.isEqualToCurrentTokenText("case"))) + throw new FailedPredicateException(this, "this.isEqualToCurrentTokenText(\"case\")"); + setState(2167); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Soft_kw_wildcardContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Soft_kw_wildcardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_soft_kw_wildcard; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).enterSoft_kw_wildcard(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) ((PythonParserListener) listener).exitSoft_kw_wildcard(this); + } + } + + public final Soft_kw_wildcardContext soft_kw_wildcard() throws RecognitionException { + Soft_kw_wildcardContext _localctx = new Soft_kw_wildcardContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_soft_kw_wildcard); + try { + enterOuterAlt(_localctx, 1); + { + setState(2169); + if (!(this.isEqualToCurrentTokenText("_"))) + throw new FailedPredicateException(this, "this.isEqualToCurrentTokenText(\"_\")"); + setState(2170); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Soft_kw__not__wildcardContext extends ParserRuleContext { + public TerminalNode NAME() { + return getToken(PythonParser.NAME, 0); + } + + public Soft_kw__not__wildcardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + @Override + public int getRuleIndex() { + return RULE_soft_kw__not__wildcard; + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).enterSoft_kw__not__wildcard(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof PythonParserListener) + ((PythonParserListener) listener).exitSoft_kw__not__wildcard(this); + } + } + + public final Soft_kw__not__wildcardContext soft_kw__not__wildcard() throws RecognitionException { + Soft_kw__not__wildcardContext _localctx = new Soft_kw__not__wildcardContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_soft_kw__not__wildcard); + try { + enterOuterAlt(_localctx, 1); + { + setState(2172); + if (!(this.isnotEqualToCurrentTokenText("_"))) + throw new FailedPredicateException(this, "this.isnotEqualToCurrentTokenText(\"_\")"); + setState(2173); + match(NAME); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 29: + return dotted_name_sempred((Dotted_nameContext) _localctx, predIndex); + case 127: + return bitwise_or_sempred((Bitwise_orContext) _localctx, predIndex); + case 128: + return bitwise_xor_sempred((Bitwise_xorContext) _localctx, predIndex); + case 129: + return bitwise_and_sempred((Bitwise_andContext) _localctx, predIndex); + case 130: + return shift_expr_sempred((Shift_exprContext) _localctx, predIndex); + case 131: + return sum_sempred((SumContext) _localctx, predIndex); + case 132: + return term_sempred((TermContext) _localctx, predIndex); + case 136: + return primary_sempred((PrimaryContext) _localctx, predIndex); + case 187: + return t_primary_sempred((T_primaryContext) _localctx, predIndex); + case 193: + return soft_kw_type_sempred((Soft_kw_typeContext) _localctx, predIndex); + case 194: + return soft_kw_match_sempred((Soft_kw_matchContext) _localctx, predIndex); + case 195: + return soft_kw_case_sempred((Soft_kw_caseContext) _localctx, predIndex); + case 196: + return soft_kw_wildcard_sempred((Soft_kw_wildcardContext) _localctx, predIndex); + case 197: + return soft_kw__not__wildcard_sempred((Soft_kw__not__wildcardContext) _localctx, predIndex); + } + return true; + } + + private boolean dotted_name_sempred(Dotted_nameContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 2); + } + return true; + } + + private boolean bitwise_or_sempred(Bitwise_orContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 2); + } + return true; + } + + private boolean bitwise_xor_sempred(Bitwise_xorContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return precpred(_ctx, 2); + } + return true; + } + + private boolean bitwise_and_sempred(Bitwise_andContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return precpred(_ctx, 2); + } + return true; + } + + private boolean shift_expr_sempred(Shift_exprContext _localctx, int predIndex) { + switch (predIndex) { + case 4: + return precpred(_ctx, 2); + } + return true; + } + + private boolean sum_sempred(SumContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return precpred(_ctx, 2); + } + return true; + } + + private boolean term_sempred(TermContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return precpred(_ctx, 2); + } + return true; + } + + private boolean primary_sempred(PrimaryContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return precpred(_ctx, 2); + } + return true; + } + + private boolean t_primary_sempred(T_primaryContext _localctx, int predIndex) { + switch (predIndex) { + case 8: + return precpred(_ctx, 2); + } + return true; + } + + private boolean soft_kw_type_sempred(Soft_kw_typeContext _localctx, int predIndex) { + switch (predIndex) { + case 9: + return this.isEqualToCurrentTokenText("type"); + } + return true; + } + + private boolean soft_kw_match_sempred(Soft_kw_matchContext _localctx, int predIndex) { + switch (predIndex) { + case 10: + return this.isEqualToCurrentTokenText("match"); + } + return true; + } + + private boolean soft_kw_case_sempred(Soft_kw_caseContext _localctx, int predIndex) { + switch (predIndex) { + case 11: + return this.isEqualToCurrentTokenText("case"); + } + return true; + } + + private boolean soft_kw_wildcard_sempred(Soft_kw_wildcardContext _localctx, int predIndex) { + switch (predIndex) { + case 12: + return this.isEqualToCurrentTokenText("_"); + } + return true; + } + + private boolean soft_kw__not__wildcard_sempred(Soft_kw__not__wildcardContext _localctx, int predIndex) { + switch (predIndex) { + case 13: + return this.isnotEqualToCurrentTokenText("_"); + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0001a\u0880\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002" + + "\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002" + + "\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002" + + "\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002" + + "\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f" + + "\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012" + + "\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015" + + "\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018" + + "\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b" + + "\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e" + + "\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002" + + "#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002" + + "(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002" + + "-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002" + + "2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002" + + "7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002" + + "<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002" + + "A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002" + + "F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002" + + "K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002" + + "P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002" + + "U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002" + + "Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002" + + "_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002" + + "d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002" + + "i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002" + + "n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002" + + "s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002" + + "x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002" + + "}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007\u0080" + + "\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007\u0083" + + "\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007\u0086" + + "\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007\u0089" + + "\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007\u008c" + + "\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007\u008f" + + "\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007\u0092" + + "\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007\u0095" + + "\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007\u0098" + + "\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007\u009b" + + "\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007\u009e" + + "\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007\u00a1" + + "\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007\u00a4" + + "\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007\u00a7" + + "\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007\u00aa" + + "\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007\u00ad" + + "\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007\u00b0" + + "\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007\u00b3" + + "\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007\u00b6" + + "\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007\u00b9" + + "\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007\u00bc" + + "\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007\u00bf" + + "\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007\u00c2" + + "\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007\u00c5" + + "\u0001\u0000\u0003\u0000\u018e\b\u0000\u0001\u0000\u0001\u0000\u0001\u0001" + + "\u0001\u0001\u0001\u0002\u0001\u0002\u0005\u0002\u0196\b\u0002\n\u0002" + + "\f\u0002\u0199\t\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003" + + "\u0003\u0003\u019f\b\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003" + + "\u0005\u0003\u01a5\b\u0003\n\u0003\f\u0003\u01a8\t\u0003\u0001\u0003\u0001" + + "\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0004\u0005\u01af\b\u0005\u000b" + + "\u0005\f\u0005\u01b0\u0001\u0006\u0001\u0006\u0003\u0006\u01b5\b\u0006" + + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007" + + "\u0003\u0007\u01bd\b\u0007\u0001\b\u0001\b\u0001\b\u0005\b\u01c2\b\b\n" + + "\b\f\b\u01c5\t\b\u0001\b\u0003\b\u01c8\b\b\u0001\b\u0001\b\u0001\t\u0001" + + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001" + + "\t\u0001\t\u0001\t\u0001\t\u0003\t\u01da\b\t\u0001\n\u0001\n\u0001\n\u0001" + + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u01e4\b\n\u0001\u000b\u0001" + + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u01eb\b\u000b\u0001" + + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u01f2" + + "\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u01f8" + + "\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0004\u000b\u01fd\b\u000b" + + "\u000b\u000b\f\u000b\u01fe\u0001\u000b\u0001\u000b\u0003\u000b\u0203\b" + + "\u000b\u0001\u000b\u0003\u000b\u0206\b\u000b\u0001\u000b\u0001\u000b\u0001" + + "\u000b\u0001\u000b\u0003\u000b\u020c\b\u000b\u0003\u000b\u020e\b\u000b" + + "\u0001\f\u0001\f\u0003\f\u0212\b\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e" + + "\u0003\u000e\u0218\b\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f" + + "\u0003\u000f\u021e\b\u000f\u0003\u000f\u0220\b\u000f\u0001\u0010\u0001" + + "\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u0226\b\u0010\n\u0010\f\u0010" + + "\u0229\t\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011" + + "\u022f\b\u0011\n\u0011\f\u0011\u0232\t\u0011\u0001\u0012\u0001\u0012\u0001" + + "\u0012\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001" + + "\u0014\u0003\u0014\u023d\b\u0014\u0001\u0015\u0001\u0015\u0003\u0015\u0241" + + "\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0005" + + "\u0017\u0248\b\u0017\n\u0017\f\u0017\u024b\t\u0017\u0001\u0017\u0001\u0017" + + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0004\u0017\u0253\b\u0017" + + "\u000b\u0017\f\u0017\u0254\u0001\u0017\u0001\u0017\u0003\u0017\u0259\b" + + "\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u025e\b\u0018\u0001" + + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u0264\b\u0018\u0001" + + "\u0019\u0001\u0019\u0001\u0019\u0005\u0019\u0269\b\u0019\n\u0019\f\u0019" + + "\u026c\t\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0271\b" + + "\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0005\u001b\u0276\b\u001b\n" + + "\u001b\f\u001b\u0279\t\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0003" + + "\u001c\u027e\b\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001" + + "\u001d\u0001\u001d\u0005\u001d\u0286\b\u001d\n\u001d\f\u001d\u0289\t\u001d" + + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e" + + "\u0003\u001e\u0291\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f" + + "\u0004\u001f\u0297\b\u001f\u000b\u001f\f\u001f\u0298\u0001 \u0001 \u0001" + + " \u0001 \u0003 \u029f\b \u0001!\u0001!\u0001!\u0003!\u02a4\b!\u0001!\u0001" + + "!\u0003!\u02a8\b!\u0001!\u0003!\u02ab\b!\u0001!\u0001!\u0001!\u0001\"" + + "\u0001\"\u0001\"\u0001\"\u0003\"\u02b4\b\"\u0001#\u0001#\u0001#\u0003" + + "#\u02b9\b#\u0001#\u0001#\u0003#\u02bd\b#\u0001#\u0001#\u0001#\u0003#\u02c2" + + "\b#\u0001#\u0001#\u0003#\u02c6\b#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003" + + "#\u02cd\b#\u0001#\u0001#\u0003#\u02d1\b#\u0001#\u0001#\u0001#\u0003#\u02d6" + + "\b#\u0001#\u0001#\u0003#\u02da\b#\u0001#\u0003#\u02dd\b#\u0001$\u0001" + + "$\u0001%\u0001%\u0005%\u02e3\b%\n%\f%\u02e6\t%\u0001%\u0005%\u02e9\b%" + + "\n%\f%\u02ec\t%\u0001%\u0003%\u02ef\b%\u0001%\u0001%\u0005%\u02f3\b%\n" + + "%\f%\u02f6\t%\u0001%\u0003%\u02f9\b%\u0001%\u0004%\u02fc\b%\u000b%\f%" + + "\u02fd\u0001%\u0005%\u0301\b%\n%\f%\u0304\t%\u0001%\u0003%\u0307\b%\u0001" + + "%\u0004%\u030a\b%\u000b%\f%\u030b\u0001%\u0003%\u030f\b%\u0001%\u0003" + + "%\u0312\b%\u0001&\u0004&\u0315\b&\u000b&\f&\u0316\u0001&\u0001&\u0003" + + "&\u031b\b&\u0001\'\u0005\'\u031e\b\'\n\'\f\'\u0321\t\'\u0001\'\u0004\'" + + "\u0324\b\'\u000b\'\f\'\u0325\u0001\'\u0001\'\u0003\'\u032a\b\'\u0001(" + + "\u0001(\u0001(\u0005(\u032f\b(\n(\f(\u0332\t(\u0001(\u0003(\u0335\b(\u0001" + + "(\u0001(\u0001(\u0005(\u033a\b(\n(\f(\u033d\t(\u0001(\u0003(\u0340\b(" + + "\u0001(\u0001(\u0001(\u0004(\u0345\b(\u000b(\f(\u0346\u0001(\u0003(\u034a" + + "\b(\u0001(\u0003(\u034d\b(\u0001)\u0001)\u0001)\u0001*\u0001*\u0003*\u0354" + + "\b*\u0001*\u0003*\u0357\b*\u0001+\u0001+\u0003+\u035b\b+\u0001+\u0003" + + "+\u035e\b+\u0001,\u0001,\u0001,\u0003,\u0363\b,\u0001,\u0003,\u0366\b" + + ",\u0001-\u0001-\u0003-\u036a\b-\u0001-\u0003-\u036d\b-\u0001-\u0003-\u0370" + + "\b-\u0001.\u0001.\u0003.\u0374\b.\u0001/\u0001/\u0001/\u00010\u00010\u0001" + + "0\u00011\u00011\u00011\u00012\u00012\u00012\u00013\u00013\u00013\u0001" + + "3\u00013\u00013\u00033\u0388\b3\u00033\u038a\b3\u00014\u00014\u00014\u0001" + + "4\u00014\u00014\u00034\u0392\b4\u00034\u0394\b4\u00015\u00015\u00015\u0001" + + "5\u00016\u00016\u00016\u00016\u00016\u00036\u039f\b6\u00017\u00037\u03a2" + + "\b7\u00017\u00017\u00017\u00017\u00017\u00017\u00037\u03aa\b7\u00017\u0001" + + "7\u00037\u03ae\b7\u00018\u00038\u03b1\b8\u00018\u00018\u00018\u00018\u0001" + + "8\u00058\u03b8\b8\n8\f8\u03bb\t8\u00018\u00038\u03be\b8\u00018\u00018" + + "\u00018\u00018\u00018\u00018\u00058\u03c6\b8\n8\f8\u03c9\t8\u00018\u0001" + + "8\u00038\u03cd\b8\u00038\u03cf\b8\u00018\u00018\u00019\u00019\u00019\u0003" + + "9\u03d6\b9\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001" + + ":\u0004:\u03e1\b:\u000b:\f:\u03e2\u0001:\u0003:\u03e6\b:\u0001:\u0003" + + ":\u03e9\b:\u0001:\u0001:\u0001:\u0001:\u0004:\u03ef\b:\u000b:\f:\u03f0" + + "\u0001:\u0003:\u03f4\b:\u0001:\u0003:\u03f7\b:\u0003:\u03f9\b:\u0001;" + + "\u0001;\u0001;\u0001;\u0003;\u03ff\b;\u0003;\u0401\b;\u0001;\u0001;\u0001" + + ";\u0001<\u0001<\u0001<\u0001<\u0001<\u0003<\u040b\b<\u0001<\u0001<\u0001" + + "<\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001" + + ">\u0004>\u041a\b>\u000b>\f>\u041b\u0001>\u0001>\u0001?\u0001?\u0001?\u0003" + + "?\u0423\b?\u0001?\u0003?\u0426\b?\u0001@\u0001@\u0001@\u0003@\u042b\b" + + "@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001B\u0001B\u0003B\u0435" + + "\bB\u0001C\u0001C\u0003C\u0439\bC\u0001D\u0001D\u0001D\u0001D\u0001E\u0001" + + "E\u0001E\u0005E\u0442\bE\nE\fE\u0445\tE\u0001F\u0001F\u0001F\u0001F\u0001" + + "F\u0001F\u0001F\u0001F\u0003F\u044f\bF\u0001G\u0001G\u0001G\u0001G\u0001" + + "G\u0001G\u0003G\u0457\bG\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0003" + + "H\u045f\bH\u0001I\u0001I\u0001I\u0001I\u0001J\u0003J\u0466\bJ\u0001J\u0001" + + "J\u0001K\u0003K\u046b\bK\u0001K\u0001K\u0001L\u0001L\u0001M\u0001M\u0001" + + "N\u0001N\u0001O\u0001O\u0001P\u0001P\u0001Q\u0001Q\u0001R\u0001R\u0001" + + "R\u0004R\u047e\bR\u000bR\fR\u047f\u0001S\u0001S\u0001S\u0005S\u0485\b" + + "S\nS\fS\u0488\tS\u0001T\u0001T\u0001T\u0001T\u0001U\u0001U\u0003U\u0490" + + "\bU\u0001U\u0001U\u0001U\u0003U\u0495\bU\u0001U\u0003U\u0498\bU\u0001" + + "V\u0001V\u0001V\u0003V\u049d\bV\u0001W\u0001W\u0001W\u0005W\u04a2\bW\n" + + "W\fW\u04a5\tW\u0001W\u0003W\u04a8\bW\u0001X\u0001X\u0003X\u04ac\bX\u0001" + + "Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u04b6\bZ\u0001" + + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u04be\bZ\u0001Z\u0003Z\u04c1" + + "\bZ\u0001Z\u0001Z\u0003Z\u04c5\bZ\u0001[\u0001[\u0001[\u0005[\u04ca\b" + + "[\n[\f[\u04cd\t[\u0001\\\u0001\\\u0003\\\u04d1\b\\\u0001\\\u0001\\\u0001" + + "\\\u0001]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0003^\u04de" + + "\b^\u0001^\u0003^\u04e1\b^\u0001^\u0003^\u04e4\b^\u0003^\u04e6\b^\u0001" + + "^\u0001^\u0001_\u0001_\u0001_\u0005_\u04ed\b_\n_\f_\u04f0\t_\u0001`\u0001" + + "`\u0001`\u0005`\u04f5\b`\n`\f`\u04f8\t`\u0001a\u0001a\u0001a\u0001a\u0001" + + "b\u0001b\u0001b\u0003b\u0501\bb\u0001b\u0001b\u0001b\u0001c\u0001c\u0001" + + "c\u0001c\u0001d\u0001d\u0001d\u0005d\u050d\bd\nd\fd\u0510\td\u0001d\u0003" + + "d\u0513\bd\u0001e\u0001e\u0003e\u0517\be\u0001e\u0001e\u0001e\u0001e\u0003" + + "e\u051d\be\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0005g\u0525\bg\n" + + "g\fg\u0528\tg\u0001g\u0003g\u052b\bg\u0001h\u0001h\u0001h\u0001h\u0001" + + "h\u0001h\u0003h\u0533\bh\u0001h\u0003h\u0536\bh\u0001i\u0001i\u0001i\u0001" + + "i\u0003i\u053c\bi\u0003i\u053e\bi\u0001j\u0001j\u0001j\u0005j\u0543\b" + + "j\nj\fj\u0546\tj\u0001j\u0003j\u0549\bj\u0001k\u0001k\u0001k\u0003k\u054e" + + "\bk\u0001l\u0001l\u0001l\u0005l\u0553\bl\nl\fl\u0556\tl\u0001l\u0003l" + + "\u0559\bl\u0001m\u0001m\u0001m\u0003m\u055e\bm\u0001n\u0001n\u0001n\u0001" + + "n\u0001o\u0001o\u0003o\u0566\bo\u0001p\u0001p\u0001p\u0005p\u056b\bp\n" + + "p\fp\u056e\tp\u0001q\u0001q\u0001q\u0005q\u0573\bq\nq\fq\u0576\tq\u0001" + + "r\u0001r\u0001r\u0003r\u057b\br\u0001s\u0001s\u0005s\u057f\bs\ns\fs\u0582" + + "\ts\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001" + + "t\u0003t\u058e\bt\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001w\u0001" + + "w\u0001w\u0001x\u0001x\u0001x\u0001y\u0001y\u0001y\u0001z\u0001z\u0001" + + "z\u0001{\u0001{\u0001{\u0001{\u0001|\u0001|\u0001|\u0001}\u0001}\u0001" + + "}\u0001}\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f\u0001" + + "\u007f\u0001\u007f\u0001\u007f\u0005\u007f\u05b6\b\u007f\n\u007f\f\u007f" + + "\u05b9\t\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080" + + "\u0001\u0080\u0005\u0080\u05c1\b\u0080\n\u0080\f\u0080\u05c4\t\u0080\u0001" + + "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0005" + + "\u0081\u05cc\b\u0081\n\u0081\f\u0081\u05cf\t\u0081\u0001\u0082\u0001\u0082" + + "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0005\u0082\u05d7\b\u0082" + + "\n\u0082\f\u0082\u05da\t\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001" + + "\u0083\u0001\u0083\u0001\u0083\u0005\u0083\u05e2\b\u0083\n\u0083\f\u0083" + + "\u05e5\t\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084" + + "\u0001\u0084\u0005\u0084\u05ed\b\u0084\n\u0084\f\u0084\u05f0\t\u0084\u0001" + + "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001" + + "\u0085\u0003\u0085\u05f9\b\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0003" + + "\u0086\u05fe\b\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0003\u0087\u0603" + + "\b\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001" + + "\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u060e\b\u0088\u0001" + + "\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u0615" + + "\b\u0088\u0005\u0088\u0617\b\u0088\n\u0088\f\u0088\u061a\t\u0088\u0001" + + "\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u061f\b\u0089\u0001\u0089\u0001" + + "\u0089\u0001\u0089\u0003\u0089\u0624\b\u0089\u0005\u0089\u0626\b\u0089" + + "\n\u0089\f\u0089\u0629\t\u0089\u0001\u0089\u0003\u0089\u062c\b\u0089\u0003" + + "\u0089\u062e\b\u0089\u0001\u008a\u0003\u008a\u0631\b\u008a\u0001\u008a" + + "\u0001\u008a\u0003\u008a\u0635\b\u008a\u0001\u008a\u0001\u008a\u0003\u008a" + + "\u0639\b\u008a\u0003\u008a\u063b\b\u008a\u0001\u008a\u0003\u008a\u063e" + + "\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001" + + "\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0649\b\u008b\u0001" + + "\u008b\u0001\u008b\u0003\u008b\u064d\b\u008b\u0001\u008b\u0001\u008b\u0001" + + "\u008b\u0001\u008b\u0003\u008b\u0653\b\u008b\u0001\u008b\u0003\u008b\u0656" + + "\b\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u065b\b\u008c" + + "\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0003\u008d\u0661\b\u008d" + + "\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e\u0001\u008f" + + "\u0001\u008f\u0005\u008f\u066a\b\u008f\n\u008f\f\u008f\u066d\t\u008f\u0001" + + "\u008f\u0005\u008f\u0670\b\u008f\n\u008f\f\u008f\u0673\t\u008f\u0001\u008f" + + "\u0003\u008f\u0676\b\u008f\u0001\u008f\u0001\u008f\u0005\u008f\u067a\b" + + "\u008f\n\u008f\f\u008f\u067d\t\u008f\u0001\u008f\u0003\u008f\u0680\b\u008f" + + "\u0001\u008f\u0004\u008f\u0683\b\u008f\u000b\u008f\f\u008f\u0684\u0001" + + "\u008f\u0005\u008f\u0688\b\u008f\n\u008f\f\u008f\u068b\t\u008f\u0001\u008f" + + "\u0003\u008f\u068e\b\u008f\u0001\u008f\u0004\u008f\u0691\b\u008f\u000b" + + "\u008f\f\u008f\u0692\u0001\u008f\u0003\u008f\u0696\b\u008f\u0001\u008f" + + "\u0003\u008f\u0699\b\u008f\u0001\u0090\u0004\u0090\u069c\b\u0090\u000b" + + "\u0090\f\u0090\u069d\u0001\u0090\u0001\u0090\u0003\u0090\u06a2\b\u0090" + + "\u0001\u0091\u0005\u0091\u06a5\b\u0091\n\u0091\f\u0091\u06a8\t\u0091\u0001" + + "\u0091\u0004\u0091\u06ab\b\u0091\u000b\u0091\f\u0091\u06ac\u0001\u0091" + + "\u0001\u0091\u0003\u0091\u06b1\b\u0091\u0001\u0092\u0001\u0092\u0001\u0092" + + "\u0005\u0092\u06b6\b\u0092\n\u0092\f\u0092\u06b9\t\u0092\u0001\u0092\u0003" + + "\u0092\u06bc\b\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0004\u0092\u06c1" + + "\b\u0092\u000b\u0092\f\u0092\u06c2\u0001\u0092\u0003\u0092\u06c6\b\u0092" + + "\u0001\u0092\u0003\u0092\u06c9\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093" + + "\u0001\u0094\u0001\u0094\u0003\u0094\u06d0\b\u0094\u0001\u0095\u0001\u0095" + + "\u0001\u0095\u0003\u0095\u06d5\b\u0095\u0001\u0096\u0001\u0096\u0003\u0096" + + "\u06d9\b\u0096\u0001\u0096\u0003\u0096\u06dc\b\u0096\u0001\u0097\u0001" + + "\u0097\u0001\u0098\u0001\u0098\u0003\u0098\u06e2\b\u0098\u0001\u0099\u0001" + + "\u0099\u0001\u0099\u0003\u0099\u06e7\b\u0099\u0001\u0099\u0003\u0099\u06ea" + + "\b\u0099\u0001\u0099\u0003\u0099\u06ed\b\u0099\u0001\u0099\u0003\u0099" + + "\u06f0\b\u0099\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001\u009a" + + "\u0001\u009b\u0001\u009b\u0005\u009b\u06f9\b\u009b\n\u009b\f\u009b\u06fc" + + "\t\u009b\u0001\u009c\u0001\u009c\u0003\u009c\u0700\b\u009c\u0001\u009d" + + "\u0001\u009d\u0005\u009d\u0704\b\u009d\n\u009d\f\u009d\u0707\t\u009d\u0001" + + "\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0004" + + "\u009f\u070f\b\u009f\u000b\u009f\f\u009f\u0710\u0001\u00a0\u0001\u00a0" + + "\u0003\u00a0\u0715\b\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1\u0001\u00a1" + + "\u0001\u00a1\u0001\u00a1\u0003\u00a1\u071d\b\u00a1\u0003\u00a1\u071f\b" + + "\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001" + + "\u00a2\u0001\u00a3\u0001\u00a3\u0003\u00a3\u0729\b\u00a3\u0001\u00a3\u0001" + + "\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0005\u00a4\u0730\b\u00a4\n" + + "\u00a4\f\u00a4\u0733\t\u00a4\u0001\u00a4\u0003\u00a4\u0736\b\u00a4\u0001" + + "\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u073b\b\u00a5\u0001\u00a6\u0001" + + "\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a7\u0004\u00a7\u0742\b\u00a7\u000b" + + "\u00a7\f\u00a7\u0743\u0001\u00a8\u0003\u00a8\u0747\b\u00a8\u0001\u00a8" + + "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0005\u00a8" + + "\u074f\b\u00a8\n\u00a8\f\u00a8\u0752\t\u00a8\u0001\u00a9\u0001\u00a9\u0001" + + "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001" + + "\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0003\u00ab\u0761" + + "\b\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001" + + "\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0003\u00ad\u076d" + + "\b\u00ad\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0772\b\u00ae" + + "\u0003\u00ae\u0774\b\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae" + + "\u0003\u00ae\u077a\b\u00ae\u0003\u00ae\u077c\b\u00ae\u0005\u00ae\u077e" + + "\b\u00ae\n\u00ae\f\u00ae\u0781\t\u00ae\u0001\u00ae\u0001\u00ae\u0003\u00ae" + + "\u0785\b\u00ae\u0001\u00ae\u0003\u00ae\u0788\b\u00ae\u0001\u00af\u0001" + + "\u00af\u0001\u00af\u0005\u00af\u078d\b\u00af\n\u00af\f\u00af\u0790\t\u00af" + + "\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0005\u00af\u0796\b\u00af" + + "\n\u00af\f\u00af\u0799\t\u00af\u0003\u00af\u079b\b\u00af\u0001\u00af\u0001" + + "\u00af\u0001\u00af\u0005\u00af\u07a0\b\u00af\n\u00af\f\u00af\u07a3\t\u00af" + + "\u0003\u00af\u07a5\b\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b1" + + "\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u07ae\b\u00b1\u0001\u00b2" + + "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0003\u00b2\u07b5\b\u00b2" + + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0005\u00b3\u07ba\b\u00b3\n\u00b3" + + "\f\u00b3\u07bd\t\u00b3\u0001\u00b3\u0003\u00b3\u07c0\b\u00b3\u0001\u00b4" + + "\u0001\u00b4\u0001\u00b4\u0004\u00b4\u07c5\b\u00b4\u000b\u00b4\f\u00b4" + + "\u07c6\u0001\u00b4\u0003\u00b4\u07ca\b\u00b4\u0001\u00b5\u0001\u00b5\u0001" + + "\u00b5\u0001\u00b5\u0004\u00b5\u07d0\b\u00b5\u000b\u00b5\f\u00b5\u07d1" + + "\u0001\u00b5\u0003\u00b5\u07d5\b\u00b5\u0003\u00b5\u07d7\b\u00b5\u0001" + + "\u00b6\u0001\u00b6\u0001\u00b6\u0003\u00b6\u07dc\b\u00b6\u0001\u00b7\u0001" + + "\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0003" + + "\u00b7\u07e5\b\u00b7\u0001\u00b7\u0003\u00b7\u07e8\b\u00b7\u0001\u00b8" + + "\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8" + + "\u0003\u00b8\u07f1\b\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8" + + "\u07f6\b\u00b8\u0001\u00b8\u0003\u00b8\u07f9\b\u00b8\u0001\u00b9\u0001" + + "\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u0801" + + "\b\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001" + + "\u00ba\u0001\u00ba\u0003\u00ba\u080a\b\u00ba\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001" + + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb\u0819" + + "\b\u00bb\u0001\u00bb\u0003\u00bb\u081c\b\u00bb\u0005\u00bb\u081e\b\u00bb" + + "\n\u00bb\f\u00bb\u0821\t\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0005" + + "\u00bc\u0826\b\u00bc\n\u00bc\f\u00bc\u0829\t\u00bc\u0001\u00bc\u0003\u00bc" + + "\u082c\b\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd" + + "\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0835\b\u00bd\u0001\u00bd\u0003\u00bd" + + "\u0838\b\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be" + + "\u0001\u00be\u0001\u00be\u0003\u00be\u0841\b\u00be\u0001\u00be\u0001\u00be" + + "\u0001\u00be\u0003\u00be\u0846\b\u00be\u0001\u00be\u0003\u00be\u0849\b" + + "\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0005\u00bf\u084e\b\u00bf\n" + + "\u00bf\f\u00bf\u0851\t\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001" + + "\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u0859\b\u00bf\u0001\u00bf\u0001" + + "\u00bf\u0003\u00bf\u085d\b\u00bf\u0003\u00bf\u085f\b\u00bf\u0001\u00bf" + + "\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u0866\b\u00bf" + + "\u0001\u00bf\u0001\u00bf\u0003\u00bf\u086a\b\u00bf\u0001\u00c0\u0001\u00c0" + + "\u0001\u00c0\u0003\u00c0\u086f\b\u00c0\u0001\u00c1\u0001\u00c1\u0001\u00c1" + + "\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3" + + "\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5" + + "\u0001\u00c5\u0000\t:\u00fe\u0100\u0102\u0104\u0106\u0108\u0110\u0176" + + "\u00c6\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018" + + "\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080" + + "\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098" + + "\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0" + + "\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8" + + "\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0" + + "\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8" + + "\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110" + + "\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128" + + "\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140" + + "\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158" + + "\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170" + + "\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188" + + "\u018a\u0000\u0005\u0003\u0000GQSSUU\u0002\u000000WW\u0001\u000045\u0001" + + "\u0000DE\u0004\u000067==RRTT\u0929\u0000\u018d\u0001\u0000\u0000\u0000" + + "\u0002\u0191\u0001\u0000\u0000\u0000\u0004\u0193\u0001\u0000\u0000\u0000" + + "\u0006\u019c\u0001\u0000\u0000\u0000\b\u01ab\u0001\u0000\u0000\u0000\n" + + "\u01ae\u0001\u0000\u0000\u0000\f\u01b4\u0001\u0000\u0000\u0000\u000e\u01bc" + + "\u0001\u0000\u0000\u0000\u0010\u01be\u0001\u0000\u0000\u0000\u0012\u01d9" + + "\u0001\u0000\u0000\u0000\u0014\u01e3\u0001\u0000\u0000\u0000\u0016\u020d" + + "\u0001\u0000\u0000\u0000\u0018\u0211\u0001\u0000\u0000\u0000\u001a\u0213" + + "\u0001\u0000\u0000\u0000\u001c\u0215\u0001\u0000\u0000\u0000\u001e\u0219" + + "\u0001\u0000\u0000\u0000 \u0221\u0001\u0000\u0000\u0000\"\u022a\u0001" + + "\u0000\u0000\u0000$\u0233\u0001\u0000\u0000\u0000&\u0236\u0001\u0000\u0000" + + "\u0000(\u0238\u0001\u0000\u0000\u0000*\u0240\u0001\u0000\u0000\u0000," + + "\u0242\u0001\u0000\u0000\u0000.\u0258\u0001\u0000\u0000\u00000\u0263\u0001" + + "\u0000\u0000\u00002\u0265\u0001\u0000\u0000\u00004\u026d\u0001\u0000\u0000" + + "\u00006\u0272\u0001\u0000\u0000\u00008\u027a\u0001\u0000\u0000\u0000:" + + "\u027f\u0001\u0000\u0000\u0000<\u0290\u0001\u0000\u0000\u0000>\u0296\u0001" + + "\u0000\u0000\u0000@\u029e\u0001\u0000\u0000\u0000B\u02a0\u0001\u0000\u0000" + + "\u0000D\u02b3\u0001\u0000\u0000\u0000F\u02dc\u0001\u0000\u0000\u0000H" + + "\u02de\u0001\u0000\u0000\u0000J\u0311\u0001\u0000\u0000\u0000L\u0314\u0001" + + "\u0000\u0000\u0000N\u031f\u0001\u0000\u0000\u0000P\u034c\u0001\u0000\u0000" + + "\u0000R\u034e\u0001\u0000\u0000\u0000T\u0351\u0001\u0000\u0000\u0000V" + + "\u0358\u0001\u0000\u0000\u0000X\u035f\u0001\u0000\u0000\u0000Z\u0367\u0001" + + "\u0000\u0000\u0000\\\u0371\u0001\u0000\u0000\u0000^\u0375\u0001\u0000" + + "\u0000\u0000`\u0378\u0001\u0000\u0000\u0000b\u037b\u0001\u0000\u0000\u0000" + + "d\u037e\u0001\u0000\u0000\u0000f\u0381\u0001\u0000\u0000\u0000h\u038b" + + "\u0001\u0000\u0000\u0000j\u0395\u0001\u0000\u0000\u0000l\u0399\u0001\u0000" + + "\u0000\u0000n\u03a1\u0001\u0000\u0000\u0000p\u03b0\u0001\u0000\u0000\u0000" + + "r\u03d2\u0001\u0000\u0000\u0000t\u03f8\u0001\u0000\u0000\u0000v\u03fa" + + "\u0001\u0000\u0000\u0000x\u0405\u0001\u0000\u0000\u0000z\u040f\u0001\u0000" + + "\u0000\u0000|\u0413\u0001\u0000\u0000\u0000~\u0425\u0001\u0000\u0000\u0000" + + "\u0080\u0427\u0001\u0000\u0000\u0000\u0082\u042f\u0001\u0000\u0000\u0000" + + "\u0084\u0434\u0001\u0000\u0000\u0000\u0086\u0438\u0001\u0000\u0000\u0000" + + "\u0088\u043a\u0001\u0000\u0000\u0000\u008a\u043e\u0001\u0000\u0000\u0000" + + "\u008c\u044e\u0001\u0000\u0000\u0000\u008e\u0456\u0001\u0000\u0000\u0000" + + "\u0090\u045e\u0001\u0000\u0000\u0000\u0092\u0460\u0001\u0000\u0000\u0000" + + "\u0094\u0465\u0001\u0000\u0000\u0000\u0096\u046a\u0001\u0000\u0000\u0000" + + "\u0098\u046e\u0001\u0000\u0000\u0000\u009a\u0470\u0001\u0000\u0000\u0000" + + "\u009c\u0472\u0001\u0000\u0000\u0000\u009e\u0474\u0001\u0000\u0000\u0000" + + "\u00a0\u0476\u0001\u0000\u0000\u0000\u00a2\u0478\u0001\u0000\u0000\u0000" + + "\u00a4\u047a\u0001\u0000\u0000\u0000\u00a6\u0481\u0001\u0000\u0000\u0000" + + "\u00a8\u0489\u0001\u0000\u0000\u0000\u00aa\u0497\u0001\u0000\u0000\u0000" + + "\u00ac\u0499\u0001\u0000\u0000\u0000\u00ae\u049e\u0001\u0000\u0000\u0000" + + "\u00b0\u04ab\u0001\u0000\u0000\u0000\u00b2\u04ad\u0001\u0000\u0000\u0000" + + "\u00b4\u04c4\u0001\u0000\u0000\u0000\u00b6\u04c6\u0001\u0000\u0000\u0000" + + "\u00b8\u04d0\u0001\u0000\u0000\u0000\u00ba\u04d5\u0001\u0000\u0000\u0000" + + "\u00bc\u04d8\u0001\u0000\u0000\u0000\u00be\u04e9\u0001\u0000\u0000\u0000" + + "\u00c0\u04f1\u0001\u0000\u0000\u0000\u00c2\u04f9\u0001\u0000\u0000\u0000" + + "\u00c4\u04fd\u0001\u0000\u0000\u0000\u00c6\u0505\u0001\u0000\u0000\u0000" + + "\u00c8\u0509\u0001\u0000\u0000\u0000\u00ca\u051c\u0001\u0000\u0000\u0000" + + "\u00cc\u051e\u0001\u0000\u0000\u0000\u00ce\u0521\u0001\u0000\u0000\u0000" + + "\u00d0\u0535\u0001\u0000\u0000\u0000\u00d2\u0537\u0001\u0000\u0000\u0000" + + "\u00d4\u053f\u0001\u0000\u0000\u0000\u00d6\u054d\u0001\u0000\u0000\u0000" + + "\u00d8\u054f\u0001\u0000\u0000\u0000\u00da\u055d\u0001\u0000\u0000\u0000" + + "\u00dc\u055f\u0001\u0000\u0000\u0000\u00de\u0565\u0001\u0000\u0000\u0000" + + "\u00e0\u0567\u0001\u0000\u0000\u0000\u00e2\u056f\u0001\u0000\u0000\u0000" + + "\u00e4\u057a\u0001\u0000\u0000\u0000\u00e6\u057c\u0001\u0000\u0000\u0000" + + "\u00e8\u058d\u0001\u0000\u0000\u0000\u00ea\u058f\u0001\u0000\u0000\u0000" + + "\u00ec\u0592\u0001\u0000\u0000\u0000\u00ee\u0595\u0001\u0000\u0000\u0000" + + "\u00f0\u0598\u0001\u0000\u0000\u0000\u00f2\u059b\u0001\u0000\u0000\u0000" + + "\u00f4\u059e\u0001\u0000\u0000\u0000\u00f6\u05a1\u0001\u0000\u0000\u0000" + + "\u00f8\u05a5\u0001\u0000\u0000\u0000\u00fa\u05a8\u0001\u0000\u0000\u0000" + + "\u00fc\u05ac\u0001\u0000\u0000\u0000\u00fe\u05af\u0001\u0000\u0000\u0000" + + "\u0100\u05ba\u0001\u0000\u0000\u0000\u0102\u05c5\u0001\u0000\u0000\u0000" + + "\u0104\u05d0\u0001\u0000\u0000\u0000\u0106\u05db\u0001\u0000\u0000\u0000" + + "\u0108\u05e6\u0001\u0000\u0000\u0000\u010a\u05f8\u0001\u0000\u0000\u0000" + + "\u010c\u05fa\u0001\u0000\u0000\u0000\u010e\u0602\u0001\u0000\u0000\u0000" + + "\u0110\u0604\u0001\u0000\u0000\u0000\u0112\u062d\u0001\u0000\u0000\u0000" + + "\u0114\u063d\u0001\u0000\u0000\u0000\u0116\u0655\u0001\u0000\u0000\u0000" + + "\u0118\u0657\u0001\u0000\u0000\u0000\u011a\u065e\u0001\u0000\u0000\u0000" + + "\u011c\u0665\u0001\u0000\u0000\u0000\u011e\u0698\u0001\u0000\u0000\u0000" + + "\u0120\u069b\u0001\u0000\u0000\u0000\u0122\u06a6\u0001\u0000\u0000\u0000" + + "\u0124\u06c8\u0001\u0000\u0000\u0000\u0126\u06ca\u0001\u0000\u0000\u0000" + + "\u0128\u06cd\u0001\u0000\u0000\u0000\u012a\u06d1\u0001\u0000\u0000\u0000" + + "\u012c\u06d6\u0001\u0000\u0000\u0000\u012e\u06dd\u0001\u0000\u0000\u0000" + + "\u0130\u06e1\u0001\u0000\u0000\u0000\u0132\u06e3\u0001\u0000\u0000\u0000" + + "\u0134\u06f3\u0001\u0000\u0000\u0000\u0136\u06f6\u0001\u0000\u0000\u0000" + + "\u0138\u06ff\u0001\u0000\u0000\u0000\u013a\u0701\u0001\u0000\u0000\u0000" + + "\u013c\u070a\u0001\u0000\u0000\u0000\u013e\u070e\u0001\u0000\u0000\u0000" + + "\u0140\u0712\u0001\u0000\u0000\u0000\u0142\u0718\u0001\u0000\u0000\u0000" + + "\u0144\u0722\u0001\u0000\u0000\u0000\u0146\u0726\u0001\u0000\u0000\u0000" + + "\u0148\u072c\u0001\u0000\u0000\u0000\u014a\u073a\u0001\u0000\u0000\u0000" + + "\u014c\u073c\u0001\u0000\u0000\u0000\u014e\u0741\u0001\u0000\u0000\u0000" + + "\u0150\u0746\u0001\u0000\u0000\u0000\u0152\u0753\u0001\u0000\u0000\u0000" + + "\u0154\u0758\u0001\u0000\u0000\u0000\u0156\u075d\u0001\u0000\u0000\u0000" + + "\u0158\u0765\u0001\u0000\u0000\u0000\u015a\u076a\u0001\u0000\u0000\u0000" + + "\u015c\u0787\u0001\u0000\u0000\u0000\u015e\u07a4\u0001\u0000\u0000\u0000" + + "\u0160\u07a6\u0001\u0000\u0000\u0000\u0162\u07ad\u0001\u0000\u0000\u0000" + + "\u0164\u07b4\u0001\u0000\u0000\u0000\u0166\u07b6\u0001\u0000\u0000\u0000" + + "\u0168\u07c1\u0001\u0000\u0000\u0000\u016a\u07cb\u0001\u0000\u0000\u0000" + + "\u016c\u07db\u0001\u0000\u0000\u0000\u016e\u07e7\u0001\u0000\u0000\u0000" + + "\u0170\u07f8\u0001\u0000\u0000\u0000\u0172\u0800\u0001\u0000\u0000\u0000" + + "\u0174\u0802\u0001\u0000\u0000\u0000\u0176\u080b\u0001\u0000\u0000\u0000" + + "\u0178\u0822\u0001\u0000\u0000\u0000\u017a\u0837\u0001\u0000\u0000\u0000" + + "\u017c\u0848\u0001\u0000\u0000\u0000\u017e\u0869\u0001\u0000\u0000\u0000" + + "\u0180\u086e\u0001\u0000\u0000\u0000\u0182\u0870\u0001\u0000\u0000\u0000" + + "\u0184\u0873\u0001\u0000\u0000\u0000\u0186\u0876\u0001\u0000\u0000\u0000" + + "\u0188\u0879\u0001\u0000\u0000\u0000\u018a\u087c\u0001\u0000\u0000\u0000" + + "\u018c\u018e\u0003\n\u0005\u0000\u018d\u018c\u0001\u0000\u0000\u0000\u018d" + + "\u018e\u0001\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000\u0000\u018f" + + "\u0190\u0005\u0000\u0000\u0001\u0190\u0001\u0001\u0000\u0000\u0000\u0191" + + "\u0192\u0003\u000e\u0007\u0000\u0192\u0003\u0001\u0000\u0000\u0000\u0193" + + "\u0197\u0003\u00ceg\u0000\u0194\u0196\u0005]\u0000\u0000\u0195\u0194\u0001" + + "\u0000\u0000\u0000\u0196\u0199\u0001\u0000\u0000\u0000\u0197\u0195\u0001" + + "\u0000\u0000\u0000\u0197\u0198\u0001\u0000\u0000\u0000\u0198\u019a\u0001" + + "\u0000\u0000\u0000\u0199\u0197\u0001\u0000\u0000\u0000\u019a\u019b\u0005" + + "\u0000\u0000\u0001\u019b\u0005\u0001\u0000\u0000\u0000\u019c\u019e\u0005" + + "*\u0000\u0000\u019d\u019f\u0003\u017e\u00bf\u0000\u019e\u019d\u0001\u0000" + + "\u0000\u0000\u019e\u019f\u0001\u0000\u0000\u0000\u019f\u01a0\u0001\u0000" + + "\u0000\u0000\u01a0\u01a1\u0005-\u0000\u0000\u01a1\u01a2\u0005V\u0000\u0000" + + "\u01a2\u01a6\u0003\u00d0h\u0000\u01a3\u01a5\u0005]\u0000\u0000\u01a4\u01a3" + + "\u0001\u0000\u0000\u0000\u01a5\u01a8\u0001\u0000\u0000\u0000\u01a6\u01a4" + + "\u0001\u0000\u0000\u0000\u01a6\u01a7\u0001\u0000\u0000\u0000\u01a7\u01a9" + + "\u0001\u0000\u0000\u0000\u01a8\u01a6\u0001\u0000\u0000\u0000\u01a9\u01aa" + + "\u0005\u0000\u0000\u0001\u01aa\u0007\u0001\u0000\u0000\u0000\u01ab\u01ac" + + "\u0003\u00d4j\u0000\u01ac\t\u0001\u0000\u0000\u0000\u01ad\u01af\u0003" + + "\f\u0006\u0000\u01ae\u01ad\u0001\u0000\u0000\u0000\u01af\u01b0\u0001\u0000" + + "\u0000\u0000\u01b0\u01ae\u0001\u0000\u0000\u0000\u01b0\u01b1\u0001\u0000" + + "\u0000\u0000\u01b1\u000b\u0001\u0000\u0000\u0000\u01b2\u01b5\u0003\u0014" + + "\n\u0000\u01b3\u01b5\u0003\u0010\b\u0000\u01b4\u01b2\u0001\u0000\u0000" + + "\u0000\u01b4\u01b3\u0001\u0000\u0000\u0000\u01b5\r\u0001\u0000\u0000\u0000" + + "\u01b6\u01b7\u0003\u0014\n\u0000\u01b7\u01b8\u0005]\u0000\u0000\u01b8" + + "\u01bd\u0001\u0000\u0000\u0000\u01b9\u01bd\u0003\u0010\b\u0000\u01ba\u01bd" + + "\u0005]\u0000\u0000\u01bb\u01bd\u0005\u0000\u0000\u0001\u01bc\u01b6\u0001" + + "\u0000\u0000\u0000\u01bc\u01b9\u0001\u0000\u0000\u0000\u01bc\u01ba\u0001" + + "\u0000\u0000\u0000\u01bc\u01bb\u0001\u0000\u0000\u0000\u01bd\u000f\u0001" + + "\u0000\u0000\u0000\u01be\u01c3\u0003\u0012\t\u0000\u01bf\u01c0\u00053" + + "\u0000\u0000\u01c0\u01c2\u0003\u0012\t\u0000\u01c1\u01bf\u0001\u0000\u0000" + + "\u0000\u01c2\u01c5\u0001\u0000\u0000\u0000\u01c3\u01c1\u0001\u0000\u0000" + + "\u0000\u01c3\u01c4\u0001\u0000\u0000\u0000\u01c4\u01c7\u0001\u0000\u0000" + + "\u0000\u01c5\u01c3\u0001\u0000\u0000\u0000\u01c6\u01c8\u00053\u0000\u0000" + + "\u01c7\u01c6\u0001\u0000\u0000\u0000\u01c7\u01c8\u0001\u0000\u0000\u0000" + + "\u01c8\u01c9\u0001\u0000\u0000\u0000\u01c9\u01ca\u0005]\u0000\u0000\u01ca" + + "\u0011\u0001\u0000\u0000\u0000\u01cb\u01da\u0003\u0016\u000b\u0000\u01cc" + + "\u01da\u0003\u00c4b\u0000\u01cd\u01da\u0003\u00d4j\u0000\u01ce\u01da\u0003" + + "\u001c\u000e\u0000\u01cf\u01da\u0003*\u0015\u0000\u01d0\u01da\u0003\u001e" + + "\u000f\u0000\u01d1\u01da\u0005\u000b\u0000\u0000\u01d2\u01da\u0003$\u0012" + + "\u0000\u01d3\u01da\u0003&\u0013\u0000\u01d4\u01da\u0003(\u0014\u0000\u01d5" + + "\u01da\u0005\r\u0000\u0000\u01d6\u01da\u0005\u0017\u0000\u0000\u01d7\u01da" + + "\u0003 \u0010\u0000\u01d8\u01da\u0003\"\u0011\u0000\u01d9\u01cb\u0001" + + "\u0000\u0000\u0000\u01d9\u01cc\u0001\u0000\u0000\u0000\u01d9\u01cd\u0001" + + "\u0000\u0000\u0000\u01d9\u01ce\u0001\u0000\u0000\u0000\u01d9\u01cf\u0001" + + "\u0000\u0000\u0000\u01d9\u01d0\u0001\u0000\u0000\u0000\u01d9\u01d1\u0001" + + "\u0000\u0000\u0000\u01d9\u01d2\u0001\u0000\u0000\u0000\u01d9\u01d3\u0001" + + "\u0000\u0000\u0000\u01d9\u01d4\u0001\u0000\u0000\u0000\u01d9\u01d5\u0001" + + "\u0000\u0000\u0000\u01d9\u01d6\u0001\u0000\u0000\u0000\u01d9\u01d7\u0001" + + "\u0000\u0000\u0000\u01d9\u01d8\u0001\u0000\u0000\u0000\u01da\u0013\u0001" + + "\u0000\u0000\u0000\u01db\u01e4\u0003D\"\u0000\u01dc\u01e4\u0003f3\u0000" + + "\u01dd\u01e4\u0003@ \u0000\u01de\u01e4\u0003p8\u0000\u01df\u01e4\u0003" + + "n7\u0000\u01e0\u01e4\u0003t:\u0000\u01e1\u01e4\u0003l6\u0000\u01e2\u01e4" + + "\u0003|>\u0000\u01e3\u01db\u0001\u0000\u0000\u0000\u01e3\u01dc\u0001\u0000" + + "\u0000\u0000\u01e3\u01dd\u0001\u0000\u0000\u0000\u01e3\u01de\u0001\u0000" + + "\u0000\u0000\u01e3\u01df\u0001\u0000\u0000\u0000\u01e3\u01e0\u0001\u0000" + + "\u0000\u0000\u01e3\u01e1\u0001\u0000\u0000\u0000\u01e3\u01e2\u0001\u0000" + + "\u0000\u0000\u01e4\u0015\u0001\u0000\u0000\u0000\u01e5\u01e6\u0005Z\u0000" + + "\u0000\u01e6\u01e7\u00051\u0000\u0000\u01e7\u01ea\u0003\u00d0h\u0000\u01e8" + + "\u01e9\u0005<\u0000\u0000\u01e9\u01eb\u0003\u0018\f\u0000\u01ea\u01e8" + + "\u0001\u0000\u0000\u0000\u01ea\u01eb\u0001\u0000\u0000\u0000\u01eb\u020e" + + "\u0001\u0000\u0000\u0000\u01ec\u01ed\u0005*\u0000\u0000\u01ed\u01ee\u0003" + + "\u0172\u00b9\u0000\u01ee\u01ef\u0005-\u0000\u0000\u01ef\u01f2\u0001\u0000" + + "\u0000\u0000\u01f0\u01f2\u0003\u0174\u00ba\u0000\u01f1\u01ec\u0001\u0000" + + "\u0000\u0000\u01f1\u01f0\u0001\u0000\u0000\u0000\u01f2\u01f3\u0001\u0000" + + "\u0000\u0000\u01f3\u01f4\u00051\u0000\u0000\u01f4\u01f7\u0003\u00d0h\u0000" + + "\u01f5\u01f6\u0005<\u0000\u0000\u01f6\u01f8\u0003\u0018\f\u0000\u01f7" + + "\u01f5\u0001\u0000\u0000\u0000\u01f7\u01f8\u0001\u0000\u0000\u0000\u01f8" + + "\u020e\u0001\u0000\u0000\u0000\u01f9\u01fa\u0003\u0166\u00b3\u0000\u01fa" + + "\u01fb\u0005<\u0000\u0000\u01fb\u01fd\u0001\u0000\u0000\u0000\u01fc\u01f9" + + "\u0001\u0000\u0000\u0000\u01fd\u01fe\u0001\u0000\u0000\u0000\u01fe\u01fc" + + "\u0001\u0000\u0000\u0000\u01fe\u01ff\u0001\u0000\u0000\u0000\u01ff\u0202" + + "\u0001\u0000\u0000\u0000\u0200\u0203\u0003\u00d2i\u0000\u0201\u0203\u0003" + + "\u00d4j\u0000\u0202\u0200\u0001\u0000\u0000\u0000\u0202\u0201\u0001\u0000" + + "\u0000\u0000\u0203\u0205\u0001\u0000\u0000\u0000\u0204\u0206\u0005\u0003" + + "\u0000\u0000\u0205\u0204\u0001\u0000\u0000\u0000\u0205\u0206\u0001\u0000" + + "\u0000\u0000\u0206\u020e\u0001\u0000\u0000\u0000\u0207\u0208\u0003\u0172" + + "\u00b9\u0000\u0208\u020b\u0003\u001a\r\u0000\u0209\u020c\u0003\u00d2i" + + "\u0000\u020a\u020c\u0003\u00d4j\u0000\u020b\u0209\u0001\u0000\u0000\u0000" + + "\u020b\u020a\u0001\u0000\u0000\u0000\u020c\u020e\u0001\u0000\u0000\u0000" + + "\u020d\u01e5\u0001\u0000\u0000\u0000\u020d\u01f1\u0001\u0000\u0000\u0000" + + "\u020d\u01fc\u0001\u0000\u0000\u0000\u020d\u0207\u0001\u0000\u0000\u0000" + + "\u020e\u0017\u0001\u0000\u0000\u0000\u020f\u0212\u0003\u00d2i\u0000\u0210" + + "\u0212\u0003\u00d4j\u0000\u0211\u020f\u0001\u0000\u0000\u0000\u0211\u0210" + + "\u0001\u0000\u0000\u0000\u0212\u0019\u0001\u0000\u0000\u0000\u0213\u0214" + + "\u0007\u0000\u0000\u0000\u0214\u001b\u0001\u0000\u0000\u0000\u0215\u0217" + + "\u0005\u0015\u0000\u0000\u0216\u0218\u0003\u00d4j\u0000\u0217\u0216\u0001" + + "\u0000\u0000\u0000\u0217\u0218\u0001\u0000\u0000\u0000\u0218\u001d\u0001" + + "\u0000\u0000\u0000\u0219\u021f\u0005\u0010\u0000\u0000\u021a\u021d\u0003" + + "\u00d0h\u0000\u021b\u021c\u0005\u001d\u0000\u0000\u021c\u021e\u0003\u00d0" + + "h\u0000\u021d\u021b\u0001\u0000\u0000\u0000\u021d\u021e\u0001\u0000\u0000" + + "\u0000\u021e\u0220\u0001\u0000\u0000\u0000\u021f\u021a\u0001\u0000\u0000" + + "\u0000\u021f\u0220\u0001\u0000\u0000\u0000\u0220\u001f\u0001\u0000\u0000" + + "\u0000\u0221\u0222\u0005\"\u0000\u0000\u0222\u0227\u0005Z\u0000\u0000" + + "\u0223\u0224\u00052\u0000\u0000\u0224\u0226\u0005Z\u0000\u0000\u0225\u0223" + + "\u0001\u0000\u0000\u0000\u0226\u0229\u0001\u0000\u0000\u0000\u0227\u0225" + + "\u0001\u0000\u0000\u0000\u0227\u0228\u0001\u0000\u0000\u0000\u0228!\u0001" + + "\u0000\u0000\u0000\u0229\u0227\u0001\u0000\u0000\u0000\u022a\u022b\u0005" + + "\u001e\u0000\u0000\u022b\u0230\u0005Z\u0000\u0000\u022c\u022d\u00052\u0000" + + "\u0000\u022d\u022f\u0005Z\u0000\u0000\u022e\u022c\u0001\u0000\u0000\u0000" + + "\u022f\u0232\u0001\u0000\u0000\u0000\u0230\u022e\u0001\u0000\u0000\u0000" + + "\u0230\u0231\u0001\u0000\u0000\u0000\u0231#\u0001\u0000\u0000\u0000\u0232" + + "\u0230\u0001\u0000\u0000\u0000\u0233\u0234\u0005!\u0000\u0000\u0234\u0235" + + "\u0003\u0178\u00bc\u0000\u0235%\u0001\u0000\u0000\u0000\u0236\u0237\u0003" + + "\u00d2i\u0000\u0237\'\u0001\u0000\u0000\u0000\u0238\u0239\u0005 \u0000" + + "\u0000\u0239\u023c\u0003\u00d0h\u0000\u023a\u023b\u00052\u0000\u0000\u023b" + + "\u023d\u0003\u00d0h\u0000\u023c\u023a\u0001\u0000\u0000\u0000\u023c\u023d" + + "\u0001\u0000\u0000\u0000\u023d)\u0001\u0000\u0000\u0000\u023e\u0241\u0003" + + ",\u0016\u0000\u023f\u0241\u0003.\u0017\u0000\u0240\u023e\u0001\u0000\u0000" + + "\u0000\u0240\u023f\u0001\u0000\u0000\u0000\u0241+\u0001\u0000\u0000\u0000" + + "\u0242\u0243\u0005\n\u0000\u0000\u0243\u0244\u00036\u001b\u0000\u0244" + + "-\u0001\u0000\u0000\u0000\u0245\u0249\u0005\u001d\u0000\u0000\u0246\u0248" + + "\u0007\u0001\u0000\u0000\u0247\u0246\u0001\u0000\u0000\u0000\u0248\u024b" + + "\u0001\u0000\u0000\u0000\u0249\u0247\u0001\u0000\u0000\u0000\u0249\u024a" + + "\u0001\u0000\u0000\u0000\u024a\u024c\u0001\u0000\u0000\u0000\u024b\u0249" + + "\u0001\u0000\u0000\u0000\u024c\u024d\u0003:\u001d\u0000\u024d\u024e\u0005" + + "\n\u0000\u0000\u024e\u024f\u00030\u0018\u0000\u024f\u0259\u0001\u0000" + + "\u0000\u0000\u0250\u0252\u0005\u001d\u0000\u0000\u0251\u0253\u0007\u0001" + + "\u0000\u0000\u0252\u0251\u0001\u0000\u0000\u0000\u0253\u0254\u0001\u0000" + + "\u0000\u0000\u0254\u0252\u0001\u0000\u0000\u0000\u0254\u0255\u0001\u0000" + + "\u0000\u0000\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0257\u0005\n\u0000" + + "\u0000\u0257\u0259\u00030\u0018\u0000\u0258\u0245\u0001\u0000\u0000\u0000" + + "\u0258\u0250\u0001\u0000\u0000\u0000\u0259/\u0001\u0000\u0000\u0000\u025a" + + "\u025b\u0005*\u0000\u0000\u025b\u025d\u00032\u0019\u0000\u025c\u025e\u0005" + + "2\u0000\u0000\u025d\u025c\u0001\u0000\u0000\u0000\u025d\u025e\u0001\u0000" + + "\u0000\u0000\u025e\u025f\u0001\u0000\u0000\u0000\u025f\u0260\u0005-\u0000" + + "\u0000\u0260\u0264\u0001\u0000\u0000\u0000\u0261\u0264\u00032\u0019\u0000" + + "\u0262\u0264\u00056\u0000\u0000\u0263\u025a\u0001\u0000\u0000\u0000\u0263" + + "\u0261\u0001\u0000\u0000\u0000\u0263\u0262\u0001\u0000\u0000\u0000\u0264" + + "1\u0001\u0000\u0000\u0000\u0265\u026a\u00034\u001a\u0000\u0266\u0267\u0005" + + "2\u0000\u0000\u0267\u0269\u00034\u001a\u0000\u0268\u0266\u0001\u0000\u0000" + + "\u0000\u0269\u026c\u0001\u0000\u0000\u0000\u026a\u0268\u0001\u0000\u0000" + + "\u0000\u026a\u026b\u0001\u0000\u0000\u0000\u026b3\u0001\u0000\u0000\u0000" + + "\u026c\u026a\u0001\u0000\u0000\u0000\u026d\u0270\u0005Z\u0000\u0000\u026e" + + "\u026f\u0005\u001b\u0000\u0000\u026f\u0271\u0005Z\u0000\u0000\u0270\u026e" + + "\u0001\u0000\u0000\u0000\u0270\u0271\u0001\u0000\u0000\u0000\u02715\u0001" + + "\u0000\u0000\u0000\u0272\u0277\u00038\u001c\u0000\u0273\u0274\u00052\u0000" + + "\u0000\u0274\u0276\u00038\u001c\u0000\u0275\u0273\u0001\u0000\u0000\u0000" + + "\u0276\u0279\u0001\u0000\u0000\u0000\u0277\u0275\u0001\u0000\u0000\u0000" + + "\u0277\u0278\u0001\u0000\u0000\u0000\u02787\u0001\u0000\u0000\u0000\u0279" + + "\u0277\u0001\u0000\u0000\u0000\u027a\u027d\u0003:\u001d\u0000\u027b\u027c" + + "\u0005\u001b\u0000\u0000\u027c\u027e\u0005Z\u0000\u0000\u027d\u027b\u0001" + + "\u0000\u0000\u0000\u027d\u027e\u0001\u0000\u0000\u0000\u027e9\u0001\u0000" + + "\u0000\u0000\u027f\u0280\u0006\u001d\uffff\uffff\u0000\u0280\u0281\u0005" + + "Z\u0000\u0000\u0281\u0287\u0001\u0000\u0000\u0000\u0282\u0283\n\u0002" + + "\u0000\u0000\u0283\u0284\u00050\u0000\u0000\u0284\u0286\u0005Z\u0000\u0000" + + "\u0285\u0282\u0001\u0000\u0000\u0000\u0286\u0289\u0001\u0000\u0000\u0000" + + "\u0287\u0285\u0001\u0000\u0000\u0000\u0287\u0288\u0001\u0000\u0000\u0000" + + "\u0288;\u0001\u0000\u0000\u0000\u0289\u0287\u0001\u0000\u0000\u0000\u028a" + + "\u028b\u0005]\u0000\u0000\u028b\u028c\u0005\u0001\u0000\u0000\u028c\u028d" + + "\u0003\n\u0005\u0000\u028d\u028e\u0005\u0002\u0000\u0000\u028e\u0291\u0001" + + "\u0000\u0000\u0000\u028f\u0291\u0003\u0010\b\u0000\u0290\u028a\u0001\u0000" + + "\u0000\u0000\u0290\u028f\u0001\u0000\u0000\u0000\u0291=\u0001\u0000\u0000" + + "\u0000\u0292\u0293\u0005T\u0000\u0000\u0293\u0294\u0003\u00deo\u0000\u0294" + + "\u0295\u0005]\u0000\u0000\u0295\u0297\u0001\u0000\u0000\u0000\u0296\u0292" + + "\u0001\u0000\u0000\u0000\u0297\u0298\u0001\u0000\u0000\u0000\u0298\u0296" + + "\u0001\u0000\u0000\u0000\u0298\u0299\u0001\u0000\u0000\u0000\u0299?\u0001" + + "\u0000\u0000\u0000\u029a\u029b\u0003>\u001f\u0000\u029b\u029c\u0003B!" + + "\u0000\u029c\u029f\u0001\u0000\u0000\u0000\u029d\u029f\u0003B!\u0000\u029e" + + "\u029a\u0001\u0000\u0000\u0000\u029e\u029d\u0001\u0000\u0000\u0000\u029f" + + "A\u0001\u0000\u0000\u0000\u02a0\u02a1\u0005\u0012\u0000\u0000\u02a1\u02a3" + + "\u0005Z\u0000\u0000\u02a2\u02a4\u0003\u00c6c\u0000\u02a3\u02a2\u0001\u0000" + + "\u0000\u0000\u02a3\u02a4\u0001\u0000\u0000\u0000\u02a4\u02aa\u0001\u0000" + + "\u0000\u0000\u02a5\u02a7\u0005*\u0000\u0000\u02a6\u02a8\u0003\u015a\u00ad" + + "\u0000\u02a7\u02a6\u0001\u0000\u0000\u0000\u02a7\u02a8\u0001\u0000\u0000" + + "\u0000\u02a8\u02a9\u0001\u0000\u0000\u0000\u02a9\u02ab\u0005-\u0000\u0000" + + "\u02aa\u02a5\u0001\u0000\u0000\u0000\u02aa\u02ab\u0001\u0000\u0000\u0000" + + "\u02ab\u02ac\u0001\u0000\u0000\u0000\u02ac\u02ad\u00051\u0000\u0000\u02ad" + + "\u02ae\u0003<\u001e\u0000\u02aeC\u0001\u0000\u0000\u0000\u02af\u02b0\u0003" + + ">\u001f\u0000\u02b0\u02b1\u0003F#\u0000\u02b1\u02b4\u0001\u0000\u0000" + + "\u0000\u02b2\u02b4\u0003F#\u0000\u02b3\u02af\u0001\u0000\u0000\u0000\u02b3" + + "\u02b2\u0001\u0000\u0000\u0000\u02b4E\u0001\u0000\u0000\u0000\u02b5\u02b6" + + "\u0005\u001c\u0000\u0000\u02b6\u02b8\u0005Z\u0000\u0000\u02b7\u02b9\u0003" + + "\u00c6c\u0000\u02b8\u02b7\u0001\u0000\u0000\u0000\u02b8\u02b9\u0001\u0000" + + "\u0000\u0000\u02b9\u02ba\u0001\u0000\u0000\u0000\u02ba\u02bc\u0005*\u0000" + + "\u0000\u02bb\u02bd\u0003H$\u0000\u02bc\u02bb\u0001\u0000\u0000\u0000\u02bc" + + "\u02bd\u0001\u0000\u0000\u0000\u02bd\u02be\u0001\u0000\u0000\u0000\u02be" + + "\u02c1\u0005-\u0000\u0000\u02bf\u02c0\u0005V\u0000\u0000\u02c0\u02c2\u0003" + + "\u00d0h\u0000\u02c1\u02bf\u0001\u0000\u0000\u0000\u02c1\u02c2\u0001\u0000" + + "\u0000\u0000\u02c2\u02c3\u0001\u0000\u0000\u0000\u02c3\u02c5\u00051\u0000" + + "\u0000\u02c4\u02c6\u0003\u0180\u00c0\u0000\u02c5\u02c4\u0001\u0000\u0000" + + "\u0000\u02c5\u02c6\u0001\u0000\u0000\u0000\u02c6\u02c7\u0001\u0000\u0000" + + "\u0000\u02c7\u02dd\u0003<\u001e\u0000\u02c8\u02c9\u0005%\u0000\u0000\u02c9" + + "\u02ca\u0005\u001c\u0000\u0000\u02ca\u02cc\u0005Z\u0000\u0000\u02cb\u02cd" + + "\u0003\u00c6c\u0000\u02cc\u02cb\u0001\u0000\u0000\u0000\u02cc\u02cd\u0001" + + "\u0000\u0000\u0000\u02cd\u02ce\u0001\u0000\u0000\u0000\u02ce\u02d0\u0005" + + "*\u0000\u0000\u02cf\u02d1\u0003H$\u0000\u02d0\u02cf\u0001\u0000\u0000" + + "\u0000\u02d0\u02d1\u0001\u0000\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000" + + "\u0000\u02d2\u02d5\u0005-\u0000\u0000\u02d3\u02d4\u0005V\u0000\u0000\u02d4" + + "\u02d6\u0003\u00d0h\u0000\u02d5\u02d3\u0001\u0000\u0000\u0000\u02d5\u02d6" + + "\u0001\u0000\u0000\u0000\u02d6\u02d7\u0001\u0000\u0000\u0000\u02d7\u02d9" + + "\u00051\u0000\u0000\u02d8\u02da\u0003\u0180\u00c0\u0000\u02d9\u02d8\u0001" + + "\u0000\u0000\u0000\u02d9\u02da\u0001\u0000\u0000\u0000\u02da\u02db\u0001" + + "\u0000\u0000\u0000\u02db\u02dd\u0003<\u001e\u0000\u02dc\u02b5\u0001\u0000" + + "\u0000\u0000\u02dc\u02c8\u0001\u0000\u0000\u0000\u02ddG\u0001\u0000\u0000" + + "\u0000\u02de\u02df\u0003J%\u0000\u02dfI\u0001\u0000\u0000\u0000\u02e0" + + "\u02e4\u0003L&\u0000\u02e1\u02e3\u0003T*\u0000\u02e2\u02e1\u0001\u0000" + + "\u0000\u0000\u02e3\u02e6\u0001\u0000\u0000\u0000\u02e4\u02e2\u0001\u0000" + + "\u0000\u0000\u02e4\u02e5\u0001\u0000\u0000\u0000\u02e5\u02ea\u0001\u0000" + + "\u0000\u0000\u02e6\u02e4\u0001\u0000\u0000\u0000\u02e7\u02e9\u0003X,\u0000" + + "\u02e8\u02e7\u0001\u0000\u0000\u0000\u02e9\u02ec\u0001\u0000\u0000\u0000" + + "\u02ea\u02e8\u0001\u0000\u0000\u0000\u02ea\u02eb\u0001\u0000\u0000\u0000" + + "\u02eb\u02ee\u0001\u0000\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000" + + "\u02ed\u02ef\u0003P(\u0000\u02ee\u02ed\u0001\u0000\u0000\u0000\u02ee\u02ef" + + "\u0001\u0000\u0000\u0000\u02ef\u0312\u0001\u0000\u0000\u0000\u02f0\u02f4" + + "\u0003N\'\u0000\u02f1\u02f3\u0003X,\u0000\u02f2\u02f1\u0001\u0000\u0000" + + "\u0000\u02f3\u02f6\u0001\u0000\u0000\u0000\u02f4\u02f2\u0001\u0000\u0000" + + "\u0000\u02f4\u02f5\u0001\u0000\u0000\u0000\u02f5\u02f8\u0001\u0000\u0000" + + "\u0000\u02f6\u02f4\u0001\u0000\u0000\u0000\u02f7\u02f9\u0003P(\u0000\u02f8" + + "\u02f7\u0001\u0000\u0000\u0000\u02f8\u02f9\u0001\u0000\u0000\u0000\u02f9" + + "\u0312\u0001\u0000\u0000\u0000\u02fa\u02fc\u0003T*\u0000\u02fb\u02fa\u0001" + + "\u0000\u0000\u0000\u02fc\u02fd\u0001\u0000\u0000\u0000\u02fd\u02fb\u0001" + + "\u0000\u0000\u0000\u02fd\u02fe\u0001\u0000\u0000\u0000\u02fe\u0302\u0001" + + "\u0000\u0000\u0000\u02ff\u0301\u0003X,\u0000\u0300\u02ff\u0001\u0000\u0000" + + "\u0000\u0301\u0304\u0001\u0000\u0000\u0000\u0302\u0300\u0001\u0000\u0000" + + "\u0000\u0302\u0303\u0001\u0000\u0000\u0000\u0303\u0306\u0001\u0000\u0000" + + "\u0000\u0304\u0302\u0001\u0000\u0000\u0000\u0305\u0307\u0003P(\u0000\u0306" + + "\u0305\u0001\u0000\u0000\u0000\u0306\u0307\u0001\u0000\u0000\u0000\u0307" + + "\u0312\u0001\u0000\u0000\u0000\u0308\u030a\u0003X,\u0000\u0309\u0308\u0001" + + "\u0000\u0000\u0000\u030a\u030b\u0001\u0000\u0000\u0000\u030b\u0309\u0001" + + "\u0000\u0000\u0000\u030b\u030c\u0001\u0000\u0000\u0000\u030c\u030e\u0001" + + "\u0000\u0000\u0000\u030d\u030f\u0003P(\u0000\u030e\u030d\u0001\u0000\u0000" + + "\u0000\u030e\u030f\u0001\u0000\u0000\u0000\u030f\u0312\u0001\u0000\u0000" + + "\u0000\u0310\u0312\u0003P(\u0000\u0311\u02e0\u0001\u0000\u0000\u0000\u0311" + + "\u02f0\u0001\u0000\u0000\u0000\u0311\u02fb\u0001\u0000\u0000\u0000\u0311" + + "\u0309\u0001\u0000\u0000\u0000\u0311\u0310\u0001\u0000\u0000\u0000\u0312" + + "K\u0001\u0000\u0000\u0000\u0313\u0315\u0003T*\u0000\u0314\u0313\u0001" + + "\u0000\u0000\u0000\u0315\u0316\u0001\u0000\u0000\u0000\u0316\u0314\u0001" + + "\u0000\u0000\u0000\u0316\u0317\u0001\u0000\u0000\u0000\u0317\u0318\u0001" + + "\u0000\u0000\u0000\u0318\u031a\u00057\u0000\u0000\u0319\u031b\u00052\u0000" + + "\u0000\u031a\u0319\u0001\u0000\u0000\u0000\u031a\u031b\u0001\u0000\u0000" + + "\u0000\u031bM\u0001\u0000\u0000\u0000\u031c\u031e\u0003T*\u0000\u031d" + + "\u031c\u0001\u0000\u0000\u0000\u031e\u0321\u0001\u0000\u0000\u0000\u031f" + + "\u031d\u0001\u0000\u0000\u0000\u031f\u0320\u0001\u0000\u0000\u0000\u0320" + + "\u0323\u0001\u0000\u0000\u0000\u0321\u031f\u0001\u0000\u0000\u0000\u0322" + + "\u0324\u0003X,\u0000\u0323\u0322\u0001\u0000\u0000\u0000\u0324\u0325\u0001" + + "\u0000\u0000\u0000\u0325\u0323\u0001\u0000\u0000\u0000\u0325\u0326\u0001" + + "\u0000\u0000\u0000\u0326\u0327\u0001\u0000\u0000\u0000\u0327\u0329\u0005" + + "7\u0000\u0000\u0328\u032a\u00052\u0000\u0000\u0329\u0328\u0001\u0000\u0000" + + "\u0000\u0329\u032a\u0001\u0000\u0000\u0000\u032aO\u0001\u0000\u0000\u0000" + + "\u032b\u032c\u00056\u0000\u0000\u032c\u0330\u0003T*\u0000\u032d\u032f" + + "\u0003Z-\u0000\u032e\u032d\u0001\u0000\u0000\u0000\u032f\u0332\u0001\u0000" + + "\u0000\u0000\u0330\u032e\u0001\u0000\u0000\u0000\u0330\u0331\u0001\u0000" + + "\u0000\u0000\u0331\u0334\u0001\u0000\u0000\u0000\u0332\u0330\u0001\u0000" + + "\u0000\u0000\u0333\u0335\u0003R)\u0000\u0334\u0333\u0001\u0000\u0000\u0000" + + "\u0334\u0335\u0001\u0000\u0000\u0000\u0335\u034d\u0001\u0000\u0000\u0000" + + "\u0336\u0337\u00056\u0000\u0000\u0337\u033b\u0003V+\u0000\u0338\u033a" + + "\u0003Z-\u0000\u0339\u0338\u0001\u0000\u0000\u0000\u033a\u033d\u0001\u0000" + + "\u0000\u0000\u033b\u0339\u0001\u0000\u0000\u0000\u033b\u033c\u0001\u0000" + + "\u0000\u0000\u033c\u033f\u0001\u0000\u0000\u0000\u033d\u033b\u0001\u0000" + + "\u0000\u0000\u033e\u0340\u0003R)\u0000\u033f\u033e\u0001\u0000\u0000\u0000" + + "\u033f\u0340\u0001\u0000\u0000\u0000\u0340\u034d\u0001\u0000\u0000\u0000" + + "\u0341\u0342\u00056\u0000\u0000\u0342\u0344\u00052\u0000\u0000\u0343\u0345" + + "\u0003Z-\u0000\u0344\u0343\u0001\u0000\u0000\u0000\u0345\u0346\u0001\u0000" + + "\u0000\u0000\u0346\u0344\u0001\u0000\u0000\u0000\u0346\u0347\u0001\u0000" + + "\u0000\u0000\u0347\u0349\u0001\u0000\u0000\u0000\u0348\u034a\u0003R)\u0000" + + "\u0349\u0348\u0001\u0000\u0000\u0000\u0349\u034a\u0001\u0000\u0000\u0000" + + "\u034a\u034d\u0001\u0000\u0000\u0000\u034b\u034d\u0003R)\u0000\u034c\u032b" + + "\u0001\u0000\u0000\u0000\u034c\u0336\u0001\u0000\u0000\u0000\u034c\u0341" + + "\u0001\u0000\u0000\u0000\u034c\u034b\u0001\u0000\u0000\u0000\u034dQ\u0001" + + "\u0000\u0000\u0000\u034e\u034f\u0005F\u0000\u0000\u034f\u0350\u0003T*" + + "\u0000\u0350S\u0001\u0000\u0000\u0000\u0351\u0353\u0003\\.\u0000\u0352" + + "\u0354\u00052\u0000\u0000\u0353\u0352\u0001\u0000\u0000\u0000\u0353\u0354" + + "\u0001\u0000\u0000\u0000\u0354\u0356\u0001\u0000\u0000\u0000\u0355\u0357" + + "\u0005\u0003\u0000\u0000\u0356\u0355\u0001\u0000\u0000\u0000\u0356\u0357" + + "\u0001\u0000\u0000\u0000\u0357U\u0001\u0000\u0000\u0000\u0358\u035a\u0003" + + "^/\u0000\u0359\u035b\u00052\u0000\u0000\u035a\u0359\u0001\u0000\u0000" + + "\u0000\u035a\u035b\u0001\u0000\u0000\u0000\u035b\u035d\u0001\u0000\u0000" + + "\u0000\u035c\u035e\u0005\u0003\u0000\u0000\u035d\u035c\u0001\u0000\u0000" + + "\u0000\u035d\u035e\u0001\u0000\u0000\u0000\u035eW\u0001\u0000\u0000\u0000" + + "\u035f\u0360\u0003\\.\u0000\u0360\u0362\u0003d2\u0000\u0361\u0363\u0005" + + "2\u0000\u0000\u0362\u0361\u0001\u0000\u0000\u0000\u0362\u0363\u0001\u0000" + + "\u0000\u0000\u0363\u0365\u0001\u0000\u0000\u0000\u0364\u0366\u0005\u0003" + + "\u0000\u0000\u0365\u0364\u0001\u0000\u0000\u0000\u0365\u0366\u0001\u0000" + + "\u0000\u0000\u0366Y\u0001\u0000\u0000\u0000\u0367\u0369\u0003\\.\u0000" + + "\u0368\u036a\u0003d2\u0000\u0369\u0368\u0001\u0000\u0000\u0000\u0369\u036a" + + "\u0001\u0000\u0000\u0000\u036a\u036c\u0001\u0000\u0000\u0000\u036b\u036d" + + "\u00052\u0000\u0000\u036c\u036b\u0001\u0000\u0000\u0000\u036c\u036d\u0001" + + "\u0000\u0000\u0000\u036d\u036f\u0001\u0000\u0000\u0000\u036e\u0370\u0005" + + "\u0003\u0000\u0000\u036f\u036e\u0001\u0000\u0000\u0000\u036f\u0370\u0001" + + "\u0000\u0000\u0000\u0370[\u0001\u0000\u0000\u0000\u0371\u0373\u0005Z\u0000" + + "\u0000\u0372\u0374\u0003`0\u0000\u0373\u0372\u0001\u0000\u0000\u0000\u0373" + + "\u0374\u0001\u0000\u0000\u0000\u0374]\u0001\u0000\u0000\u0000\u0375\u0376" + + "\u0005Z\u0000\u0000\u0376\u0377\u0003b1\u0000\u0377_\u0001\u0000\u0000" + + "\u0000\u0378\u0379\u00051\u0000\u0000\u0379\u037a\u0003\u00d0h\u0000\u037a" + + "a\u0001\u0000\u0000\u0000\u037b\u037c\u00051\u0000\u0000\u037c\u037d\u0003" + + "\u00d6k\u0000\u037dc\u0001\u0000\u0000\u0000\u037e\u037f\u0005<\u0000" + + "\u0000\u037f\u0380\u0003\u00d0h\u0000\u0380e\u0001\u0000\u0000\u0000\u0381" + + "\u0382\u0005\'\u0000\u0000\u0382\u0383\u0003\u00deo\u0000\u0383\u0384" + + "\u00051\u0000\u0000\u0384\u0389\u0003<\u001e\u0000\u0385\u038a\u0003h" + + "4\u0000\u0386\u0388\u0003j5\u0000\u0387\u0386\u0001\u0000\u0000\u0000" + + "\u0387\u0388\u0001\u0000\u0000\u0000\u0388\u038a\u0001\u0000\u0000\u0000" + + "\u0389\u0385\u0001\u0000\u0000\u0000\u0389\u0387\u0001\u0000\u0000\u0000" + + "\u038ag\u0001\u0000\u0000\u0000\u038b\u038c\u0005&\u0000\u0000\u038c\u038d" + + "\u0003\u00deo\u0000\u038d\u038e\u00051\u0000\u0000\u038e\u0393\u0003<" + + "\u001e\u0000\u038f\u0394\u0003h4\u0000\u0390\u0392\u0003j5\u0000\u0391" + + "\u0390\u0001\u0000\u0000\u0000\u0391\u0392\u0001\u0000\u0000\u0000\u0392" + + "\u0394\u0001\u0000\u0000\u0000\u0393\u038f\u0001\u0000\u0000\u0000\u0393" + + "\u0391\u0001\u0000\u0000\u0000\u0394i\u0001\u0000\u0000\u0000\u0395\u0396" + + "\u0005\t\u0000\u0000\u0396\u0397\u00051\u0000\u0000\u0397\u0398\u0003" + + "<\u001e\u0000\u0398k\u0001\u0000\u0000\u0000\u0399\u039a\u0005\u001f\u0000" + + "\u0000\u039a\u039b\u0003\u00deo\u0000\u039b\u039c\u00051\u0000\u0000\u039c" + + "\u039e\u0003<\u001e\u0000\u039d\u039f\u0003j5\u0000\u039e\u039d\u0001" + + "\u0000\u0000\u0000\u039e\u039f\u0001\u0000\u0000\u0000\u039fm\u0001\u0000" + + "\u0000\u0000\u03a0\u03a2\u0005%\u0000\u0000\u03a1\u03a0\u0001\u0000\u0000" + + "\u0000\u03a1\u03a2\u0001\u0000\u0000\u0000\u03a2\u03a3\u0001\u0000\u0000" + + "\u0000\u03a3\u03a4\u0005\u0018\u0000\u0000\u03a4\u03a5\u0003\u0166\u00b3" + + "\u0000\u03a5\u03a6\u0005\u000f\u0000\u0000\u03a6\u03a7\u0003\u00d4j\u0000" + + "\u03a7\u03a9\u00051\u0000\u0000\u03a8\u03aa\u0005\u0003\u0000\u0000\u03a9" + + "\u03a8\u0001\u0000\u0000\u0000\u03a9\u03aa\u0001\u0000\u0000\u0000\u03aa" + + "\u03ab\u0001\u0000\u0000\u0000\u03ab\u03ad\u0003<\u001e\u0000\u03ac\u03ae" + + "\u0003j5\u0000\u03ad\u03ac\u0001\u0000\u0000\u0000\u03ad\u03ae\u0001\u0000" + + "\u0000\u0000\u03aeo\u0001\u0000\u0000\u0000\u03af\u03b1\u0005%\u0000\u0000" + + "\u03b0\u03af\u0001\u0000\u0000\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000" + + "\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2\u03ce\u0005$\u0000\u0000\u03b3" + + "\u03b4\u0005*\u0000\u0000\u03b4\u03b9\u0003r9\u0000\u03b5\u03b6\u0005" + + "2\u0000\u0000\u03b6\u03b8\u0003r9\u0000\u03b7\u03b5\u0001\u0000\u0000" + + "\u0000\u03b8\u03bb\u0001\u0000\u0000\u0000\u03b9\u03b7\u0001\u0000\u0000" + + "\u0000\u03b9\u03ba\u0001\u0000\u0000\u0000\u03ba\u03bd\u0001\u0000\u0000" + + "\u0000\u03bb\u03b9\u0001\u0000\u0000\u0000\u03bc\u03be\u00052\u0000\u0000" + + "\u03bd\u03bc\u0001\u0000\u0000\u0000\u03bd\u03be\u0001\u0000\u0000\u0000" + + "\u03be\u03bf\u0001\u0000\u0000\u0000\u03bf\u03c0\u0005-\u0000\u0000\u03c0" + + "\u03c1\u00051\u0000\u0000\u03c1\u03cf\u0001\u0000\u0000\u0000\u03c2\u03c7" + + "\u0003r9\u0000\u03c3\u03c4\u00052\u0000\u0000\u03c4\u03c6\u0003r9\u0000" + + "\u03c5\u03c3\u0001\u0000\u0000\u0000\u03c6\u03c9\u0001\u0000\u0000\u0000" + + "\u03c7\u03c5\u0001\u0000\u0000\u0000\u03c7\u03c8\u0001\u0000\u0000\u0000" + + "\u03c8\u03ca\u0001\u0000\u0000\u0000\u03c9\u03c7\u0001\u0000\u0000\u0000" + + "\u03ca\u03cc\u00051\u0000\u0000\u03cb\u03cd\u0005\u0003\u0000\u0000\u03cc" + + "\u03cb\u0001\u0000\u0000\u0000\u03cc\u03cd\u0001\u0000\u0000\u0000\u03cd" + + "\u03cf\u0001\u0000\u0000\u0000\u03ce\u03b3\u0001\u0000\u0000\u0000\u03ce" + + "\u03c2\u0001\u0000\u0000\u0000\u03cf\u03d0\u0001\u0000\u0000\u0000\u03d0" + + "\u03d1\u0003<\u001e\u0000\u03d1q\u0001\u0000\u0000\u0000\u03d2\u03d5\u0003" + + "\u00d0h\u0000\u03d3\u03d4\u0005\u001b\u0000\u0000\u03d4\u03d6\u0003\u016c" + + "\u00b6\u0000\u03d5\u03d3\u0001\u0000\u0000\u0000\u03d5\u03d6\u0001\u0000" + + "\u0000\u0000\u03d6s\u0001\u0000\u0000\u0000\u03d7\u03d8\u0005\u001a\u0000" + + "\u0000\u03d8\u03d9\u00051\u0000\u0000\u03d9\u03da\u0003<\u001e\u0000\u03da" + + "\u03db\u0003z=\u0000\u03db\u03f9\u0001\u0000\u0000\u0000\u03dc\u03dd\u0005" + + "\u001a\u0000\u0000\u03dd\u03de\u00051\u0000\u0000\u03de\u03e0\u0003<\u001e" + + "\u0000\u03df\u03e1\u0003v;\u0000\u03e0\u03df\u0001\u0000\u0000\u0000\u03e1" + + "\u03e2\u0001\u0000\u0000\u0000\u03e2\u03e0\u0001\u0000\u0000\u0000\u03e2" + + "\u03e3\u0001\u0000\u0000\u0000\u03e3\u03e5\u0001\u0000\u0000\u0000\u03e4" + + "\u03e6\u0003j5\u0000\u03e5\u03e4\u0001\u0000\u0000\u0000\u03e5\u03e6\u0001" + + "\u0000\u0000\u0000\u03e6\u03e8\u0001\u0000\u0000\u0000\u03e7\u03e9\u0003" + + "z=\u0000\u03e8\u03e7\u0001\u0000\u0000\u0000\u03e8\u03e9\u0001\u0000\u0000" + + "\u0000\u03e9\u03f9\u0001\u0000\u0000\u0000\u03ea\u03eb\u0005\u001a\u0000" + + "\u0000\u03eb\u03ec\u00051\u0000\u0000\u03ec\u03ee\u0003<\u001e\u0000\u03ed" + + "\u03ef\u0003x<\u0000\u03ee\u03ed\u0001\u0000\u0000\u0000\u03ef\u03f0\u0001" + + "\u0000\u0000\u0000\u03f0\u03ee\u0001\u0000\u0000\u0000\u03f0\u03f1\u0001" + + "\u0000\u0000\u0000\u03f1\u03f3\u0001\u0000\u0000\u0000\u03f2\u03f4\u0003" + + "j5\u0000\u03f3\u03f2\u0001\u0000\u0000\u0000\u03f3\u03f4\u0001\u0000\u0000" + + "\u0000\u03f4\u03f6\u0001\u0000\u0000\u0000\u03f5\u03f7\u0003z=\u0000\u03f6" + + "\u03f5\u0001\u0000\u0000\u0000\u03f6\u03f7\u0001\u0000\u0000\u0000\u03f7" + + "\u03f9\u0001\u0000\u0000\u0000\u03f8\u03d7\u0001\u0000\u0000\u0000\u03f8" + + "\u03dc\u0001\u0000\u0000\u0000\u03f8\u03ea\u0001\u0000\u0000\u0000\u03f9" + + "u\u0001\u0000\u0000\u0000\u03fa\u0400\u0005\u000e\u0000\u0000\u03fb\u03fe" + + "\u0003\u00d0h\u0000\u03fc\u03fd\u0005\u001b\u0000\u0000\u03fd\u03ff\u0005" + + "Z\u0000\u0000\u03fe\u03fc\u0001\u0000\u0000\u0000\u03fe\u03ff\u0001\u0000" + + "\u0000\u0000\u03ff\u0401\u0001\u0000\u0000\u0000\u0400\u03fb\u0001\u0000" + + "\u0000\u0000\u0400\u0401\u0001\u0000\u0000\u0000\u0401\u0402\u0001\u0000" + + "\u0000\u0000\u0402\u0403\u00051\u0000\u0000\u0403\u0404\u0003<\u001e\u0000" + + "\u0404w\u0001\u0000\u0000\u0000\u0405\u0406\u0005\u000e\u0000\u0000\u0406" + + "\u0407\u00056\u0000\u0000\u0407\u040a\u0003\u00d0h\u0000\u0408\u0409\u0005" + + "\u001b\u0000\u0000\u0409\u040b\u0005Z\u0000\u0000\u040a\u0408\u0001\u0000" + + "\u0000\u0000\u040a\u040b\u0001\u0000\u0000\u0000\u040b\u040c\u0001\u0000" + + "\u0000\u0000\u040c\u040d\u00051\u0000\u0000\u040d\u040e\u0003<\u001e\u0000" + + "\u040ey\u0001\u0000\u0000\u0000\u040f\u0410\u0005\u0013\u0000\u0000\u0410" + + "\u0411\u00051\u0000\u0000\u0411\u0412\u0003<\u001e\u0000\u0412{\u0001" + + "\u0000\u0000\u0000\u0413\u0414\u0003\u0184\u00c2\u0000\u0414\u0415\u0003" + + "~?\u0000\u0415\u0416\u00051\u0000\u0000\u0416\u0417\u0005]\u0000\u0000" + + "\u0417\u0419\u0005\u0001\u0000\u0000\u0418\u041a\u0003\u0080@\u0000\u0419" + + "\u0418\u0001\u0000\u0000\u0000\u041a\u041b\u0001\u0000\u0000\u0000\u041b" + + "\u0419\u0001\u0000\u0000\u0000\u041b\u041c\u0001\u0000\u0000\u0000\u041c" + + "\u041d\u0001\u0000\u0000\u0000\u041d\u041e\u0005\u0002\u0000\u0000\u041e" + + "}\u0001\u0000\u0000\u0000\u041f\u0420\u0003\u00dam\u0000\u0420\u0422\u0005" + + "2\u0000\u0000\u0421\u0423\u0003\u00d8l\u0000\u0422\u0421\u0001\u0000\u0000" + + "\u0000\u0422\u0423\u0001\u0000\u0000\u0000\u0423\u0426\u0001\u0000\u0000" + + "\u0000\u0424\u0426\u0003\u00deo\u0000\u0425\u041f\u0001\u0000\u0000\u0000" + + "\u0425\u0424\u0001\u0000\u0000\u0000\u0426\u007f\u0001\u0000\u0000\u0000" + + "\u0427\u0428\u0003\u0186\u00c3\u0000\u0428\u042a\u0003\u0084B\u0000\u0429" + + "\u042b\u0003\u0082A\u0000\u042a\u0429\u0001\u0000\u0000\u0000\u042a\u042b" + + "\u0001\u0000\u0000\u0000\u042b\u042c\u0001\u0000\u0000\u0000\u042c\u042d" + + "\u00051\u0000\u0000\u042d\u042e\u0003<\u001e\u0000\u042e\u0081\u0001\u0000" + + "\u0000\u0000\u042f\u0430\u0005\'\u0000\u0000\u0430\u0431\u0003\u00deo" + + "\u0000\u0431\u0083\u0001\u0000\u0000\u0000\u0432\u0435\u0003\u00acV\u0000" + + "\u0433\u0435\u0003\u0086C\u0000\u0434\u0432\u0001\u0000\u0000\u0000\u0434" + + "\u0433\u0001\u0000\u0000\u0000\u0435\u0085\u0001\u0000\u0000\u0000\u0436" + + "\u0439\u0003\u0088D\u0000\u0437\u0439\u0003\u008aE\u0000\u0438\u0436\u0001" + + "\u0000\u0000\u0000\u0438\u0437\u0001\u0000\u0000\u0000\u0439\u0087\u0001" + + "\u0000\u0000\u0000\u043a\u043b\u0003\u008aE\u0000\u043b\u043c\u0005\u001b" + + "\u0000\u0000\u043c\u043d\u0003\u009eO\u0000\u043d\u0089\u0001\u0000\u0000" + + "\u0000\u043e\u0443\u0003\u008cF\u0000\u043f\u0440\u00058\u0000\u0000\u0440" + + "\u0442\u0003\u008cF\u0000\u0441\u043f\u0001\u0000\u0000\u0000\u0442\u0445" + + "\u0001\u0000\u0000\u0000\u0443\u0441\u0001\u0000\u0000\u0000\u0443\u0444" + + "\u0001\u0000\u0000\u0000\u0444\u008b\u0001\u0000\u0000\u0000\u0445\u0443" + + "\u0001\u0000\u0000\u0000\u0446\u044f\u0003\u008eG\u0000\u0447\u044f\u0003" + + "\u009cN\u0000\u0448\u044f\u0003\u00a0P\u0000\u0449\u044f\u0003\u00a2Q" + + "\u0000\u044a\u044f\u0003\u00a8T\u0000\u044b\u044f\u0003\u00aaU\u0000\u044c" + + "\u044f\u0003\u00b4Z\u0000\u044d\u044f\u0003\u00bc^\u0000\u044e\u0446\u0001" + + "\u0000\u0000\u0000\u044e\u0447\u0001\u0000\u0000\u0000\u044e\u0448\u0001" + + "\u0000\u0000\u0000\u044e\u0449\u0001\u0000\u0000\u0000\u044e\u044a\u0001" + + "\u0000\u0000\u0000\u044e\u044b\u0001\u0000\u0000\u0000\u044e\u044c\u0001" + + "\u0000\u0000\u0000\u044e\u044d\u0001\u0000\u0000\u0000\u044f\u008d\u0001" + + "\u0000\u0000\u0000\u0450\u0457\u0003\u0094J\u0000\u0451\u0457\u0003\u0092" + + "I\u0000\u0452\u0457\u0003\u013e\u009f\u0000\u0453\u0457\u0005\f\u0000" + + "\u0000\u0454\u0457\u0005\u0011\u0000\u0000\u0455\u0457\u0005\u0007\u0000" + + "\u0000\u0456\u0450\u0001\u0000\u0000\u0000\u0456\u0451\u0001\u0000\u0000" + + "\u0000\u0456\u0452\u0001\u0000\u0000\u0000\u0456\u0453\u0001\u0000\u0000" + + "\u0000\u0456\u0454\u0001\u0000\u0000\u0000\u0456\u0455\u0001\u0000\u0000" + + "\u0000\u0457\u008f\u0001\u0000\u0000\u0000\u0458\u045f\u0003\u0094J\u0000" + + "\u0459\u045f\u0003\u0092I\u0000\u045a\u045f\u0003\u013e\u009f\u0000\u045b" + + "\u045f\u0005\f\u0000\u0000\u045c\u045f\u0005\u0011\u0000\u0000\u045d\u045f" + + "\u0005\u0007\u0000\u0000\u045e\u0458\u0001\u0000\u0000\u0000\u045e\u0459" + + "\u0001\u0000\u0000\u0000\u045e\u045a\u0001\u0000\u0000\u0000\u045e\u045b" + + "\u0001\u0000\u0000\u0000\u045e\u045c\u0001\u0000\u0000\u0000\u045e\u045d" + + "\u0001\u0000\u0000\u0000\u045f\u0091\u0001\u0000\u0000\u0000\u0460\u0461" + + "\u0003\u0096K\u0000\u0461\u0462\u0007\u0002\u0000\u0000\u0462\u0463\u0003" + + "\u009aM\u0000\u0463\u0093\u0001\u0000\u0000\u0000\u0464\u0466\u00055\u0000" + + "\u0000\u0465\u0464\u0001\u0000\u0000\u0000\u0465\u0466\u0001\u0000\u0000" + + "\u0000\u0466\u0467\u0001\u0000\u0000\u0000\u0467\u0468\u0005[\u0000\u0000" + + "\u0468\u0095\u0001\u0000\u0000\u0000\u0469\u046b\u00055\u0000\u0000\u046a" + + "\u0469\u0001\u0000\u0000\u0000\u046a\u046b\u0001\u0000\u0000\u0000\u046b" + + "\u046c\u0001\u0000\u0000\u0000\u046c\u046d\u0003\u0098L\u0000\u046d\u0097" + + "\u0001\u0000\u0000\u0000\u046e\u046f\u0005[\u0000\u0000\u046f\u0099\u0001" + + "\u0000\u0000\u0000\u0470\u0471\u0005[\u0000\u0000\u0471\u009b\u0001\u0000" + + "\u0000\u0000\u0472\u0473\u0003\u009eO\u0000\u0473\u009d\u0001\u0000\u0000" + + "\u0000\u0474\u0475\u0003\u018a\u00c5\u0000\u0475\u009f\u0001\u0000\u0000" + + "\u0000\u0476\u0477\u0003\u0188\u00c4\u0000\u0477\u00a1\u0001\u0000\u0000" + + "\u0000\u0478\u0479\u0003\u00a4R\u0000\u0479\u00a3\u0001\u0000\u0000\u0000" + + "\u047a\u047d\u0005Z\u0000\u0000\u047b\u047c\u00050\u0000\u0000\u047c\u047e" + + "\u0005Z\u0000\u0000\u047d\u047b\u0001\u0000\u0000\u0000\u047e\u047f\u0001" + + "\u0000\u0000\u0000\u047f\u047d\u0001\u0000\u0000\u0000\u047f\u0480\u0001" + + "\u0000\u0000\u0000\u0480\u00a5\u0001\u0000\u0000\u0000\u0481\u0486\u0005" + + "Z\u0000\u0000\u0482\u0483\u00050\u0000\u0000\u0483\u0485\u0005Z\u0000" + + "\u0000\u0484\u0482\u0001\u0000\u0000\u0000\u0485\u0488\u0001\u0000\u0000" + + "\u0000\u0486\u0484\u0001\u0000\u0000\u0000\u0486\u0487\u0001\u0000\u0000" + + "\u0000\u0487\u00a7\u0001\u0000\u0000\u0000\u0488\u0486\u0001\u0000\u0000" + + "\u0000\u0489\u048a\u0005*\u0000\u0000\u048a\u048b\u0003\u0086C\u0000\u048b" + + "\u048c\u0005-\u0000\u0000\u048c\u00a9\u0001\u0000\u0000\u0000\u048d\u048f" + + "\u0005+\u0000\u0000\u048e\u0490\u0003\u00aeW\u0000\u048f\u048e\u0001\u0000" + + "\u0000\u0000\u048f\u0490\u0001\u0000\u0000\u0000\u0490\u0491\u0001\u0000" + + "\u0000\u0000\u0491\u0498\u0005.\u0000\u0000\u0492\u0494\u0005*\u0000\u0000" + + "\u0493\u0495\u0003\u00acV\u0000\u0494\u0493\u0001\u0000\u0000\u0000\u0494" + + "\u0495\u0001\u0000\u0000\u0000\u0495\u0496\u0001\u0000\u0000\u0000\u0496" + + "\u0498\u0005-\u0000\u0000\u0497\u048d\u0001\u0000\u0000\u0000\u0497\u0492" + + "\u0001\u0000\u0000\u0000\u0498\u00ab\u0001\u0000\u0000\u0000\u0499\u049a" + + "\u0003\u00b0X\u0000\u049a\u049c\u00052\u0000\u0000\u049b\u049d\u0003\u00ae" + + "W\u0000\u049c\u049b\u0001\u0000\u0000\u0000\u049c\u049d\u0001\u0000\u0000" + + "\u0000\u049d\u00ad\u0001\u0000\u0000\u0000\u049e\u04a3\u0003\u00b0X\u0000" + + "\u049f\u04a0\u00052\u0000\u0000\u04a0\u04a2\u0003\u00b0X\u0000\u04a1\u049f" + + "\u0001\u0000\u0000\u0000\u04a2\u04a5\u0001\u0000\u0000\u0000\u04a3\u04a1" + + "\u0001\u0000\u0000\u0000\u04a3\u04a4\u0001\u0000\u0000\u0000\u04a4\u04a7" + + "\u0001\u0000\u0000\u0000\u04a5\u04a3\u0001\u0000\u0000\u0000\u04a6\u04a8" + + "\u00052\u0000\u0000\u04a7\u04a6\u0001\u0000\u0000\u0000\u04a7\u04a8\u0001" + + "\u0000\u0000\u0000\u04a8\u00af\u0001\u0000\u0000\u0000\u04a9\u04ac\u0003" + + "\u00b2Y\u0000\u04aa\u04ac\u0003\u0086C\u0000\u04ab\u04a9\u0001\u0000\u0000" + + "\u0000\u04ab\u04aa\u0001\u0000\u0000\u0000\u04ac\u00b1\u0001\u0000\u0000" + + "\u0000\u04ad\u04ae\u00056\u0000\u0000\u04ae\u04af\u0005Z\u0000\u0000\u04af" + + "\u00b3\u0001\u0000\u0000\u0000\u04b0\u04b1\u0005,\u0000\u0000\u04b1\u04c5" + + "\u0005/\u0000\u0000\u04b2\u04b3\u0005,\u0000\u0000\u04b3\u04b5\u0003\u00ba" + + "]\u0000\u04b4\u04b6\u00052\u0000\u0000\u04b5\u04b4\u0001\u0000\u0000\u0000" + + "\u04b5\u04b6\u0001\u0000\u0000\u0000\u04b6\u04b7\u0001\u0000\u0000\u0000" + + "\u04b7\u04b8\u0005/\u0000\u0000\u04b8\u04c5\u0001\u0000\u0000\u0000\u04b9" + + "\u04ba\u0005,\u0000\u0000\u04ba\u04bd\u0003\u00b6[\u0000\u04bb\u04bc\u0005" + + "2\u0000\u0000\u04bc\u04be\u0003\u00ba]\u0000\u04bd\u04bb\u0001\u0000\u0000" + + "\u0000\u04bd\u04be\u0001\u0000\u0000\u0000\u04be\u04c0\u0001\u0000\u0000" + + "\u0000\u04bf\u04c1\u00052\u0000\u0000\u04c0\u04bf\u0001\u0000\u0000\u0000" + + "\u04c0\u04c1\u0001\u0000\u0000\u0000\u04c1\u04c2\u0001\u0000\u0000\u0000" + + "\u04c2\u04c3\u0005/\u0000\u0000\u04c3\u04c5\u0001\u0000\u0000\u0000\u04c4" + + "\u04b0\u0001\u0000\u0000\u0000\u04c4\u04b2\u0001\u0000\u0000\u0000\u04c4" + + "\u04b9\u0001\u0000\u0000\u0000\u04c5\u00b5\u0001\u0000\u0000\u0000\u04c6" + + "\u04cb\u0003\u00b8\\\u0000\u04c7\u04c8\u00052\u0000\u0000\u04c8\u04ca" + + "\u0003\u00b8\\\u0000\u04c9\u04c7\u0001\u0000\u0000\u0000\u04ca\u04cd\u0001" + + "\u0000\u0000\u0000\u04cb\u04c9\u0001\u0000\u0000\u0000\u04cb\u04cc\u0001" + + "\u0000\u0000\u0000\u04cc\u00b7\u0001\u0000\u0000\u0000\u04cd\u04cb\u0001" + + "\u0000\u0000\u0000\u04ce\u04d1\u0003\u0090H\u0000\u04cf\u04d1\u0003\u00a4" + + "R\u0000\u04d0\u04ce\u0001\u0000\u0000\u0000\u04d0\u04cf\u0001\u0000\u0000" + + "\u0000\u04d1\u04d2\u0001\u0000\u0000\u0000\u04d2\u04d3\u00051\u0000\u0000" + + "\u04d3\u04d4\u0003\u0086C\u0000\u04d4\u00b9\u0001\u0000\u0000\u0000\u04d5" + + "\u04d6\u0005F\u0000\u0000\u04d6\u04d7\u0003\u009eO\u0000\u04d7\u00bb\u0001" + + "\u0000\u0000\u0000\u04d8\u04d9\u0003\u00a6S\u0000\u04d9\u04e5\u0005*\u0000" + + "\u0000\u04da\u04dd\u0003\u00be_\u0000\u04db\u04dc\u00052\u0000\u0000\u04dc" + + "\u04de\u0003\u00c0`\u0000\u04dd\u04db\u0001\u0000\u0000\u0000\u04dd\u04de" + + "\u0001\u0000\u0000\u0000\u04de\u04e1\u0001\u0000\u0000\u0000\u04df\u04e1" + + "\u0003\u00c0`\u0000\u04e0\u04da\u0001\u0000\u0000\u0000\u04e0\u04df\u0001" + + "\u0000\u0000\u0000\u04e1\u04e3\u0001\u0000\u0000\u0000\u04e2\u04e4\u0005" + + "2\u0000\u0000\u04e3\u04e2\u0001\u0000\u0000\u0000\u04e3\u04e4\u0001\u0000" + + "\u0000\u0000\u04e4\u04e6\u0001\u0000\u0000\u0000\u04e5\u04e0\u0001\u0000" + + "\u0000\u0000\u04e5\u04e6\u0001\u0000\u0000\u0000\u04e6\u04e7\u0001\u0000" + + "\u0000\u0000\u04e7\u04e8\u0005-\u0000\u0000\u04e8\u00bd\u0001\u0000\u0000" + + "\u0000\u04e9\u04ee\u0003\u0086C\u0000\u04ea\u04eb\u00052\u0000\u0000\u04eb" + + "\u04ed\u0003\u0086C\u0000\u04ec\u04ea\u0001\u0000\u0000\u0000\u04ed\u04f0" + + "\u0001\u0000\u0000\u0000\u04ee\u04ec\u0001\u0000\u0000\u0000\u04ee\u04ef" + + "\u0001\u0000\u0000\u0000\u04ef\u00bf\u0001\u0000\u0000\u0000\u04f0\u04ee" + + "\u0001\u0000\u0000\u0000\u04f1\u04f6\u0003\u00c2a\u0000\u04f2\u04f3\u0005" + + "2\u0000\u0000\u04f3\u04f5\u0003\u00c2a\u0000\u04f4\u04f2\u0001\u0000\u0000" + + "\u0000\u04f5\u04f8\u0001\u0000\u0000\u0000\u04f6\u04f4\u0001\u0000\u0000" + + "\u0000\u04f6\u04f7\u0001\u0000\u0000\u0000\u04f7\u00c1\u0001\u0000\u0000" + + "\u0000\u04f8\u04f6\u0001\u0000\u0000\u0000\u04f9\u04fa\u0005Z\u0000\u0000" + + "\u04fa\u04fb\u0005<\u0000\u0000\u04fb\u04fc\u0003\u0086C\u0000\u04fc\u00c3" + + "\u0001\u0000\u0000\u0000\u04fd\u04fe\u0003\u0182\u00c1\u0000\u04fe\u0500" + + "\u0005Z\u0000\u0000\u04ff\u0501\u0003\u00c6c\u0000\u0500\u04ff\u0001\u0000" + + "\u0000\u0000\u0500\u0501\u0001\u0000\u0000\u0000\u0501\u0502\u0001\u0000" + + "\u0000\u0000\u0502\u0503\u0005<\u0000\u0000\u0503\u0504\u0003\u00d0h\u0000" + + "\u0504\u00c5\u0001\u0000\u0000\u0000\u0505\u0506\u0005+\u0000\u0000\u0506" + + "\u0507\u0003\u00c8d\u0000\u0507\u0508\u0005.\u0000\u0000\u0508\u00c7\u0001" + + "\u0000\u0000\u0000\u0509\u050e\u0003\u00cae\u0000\u050a\u050b\u00052\u0000" + + "\u0000\u050b\u050d\u0003\u00cae\u0000\u050c\u050a\u0001\u0000\u0000\u0000" + + "\u050d\u0510\u0001\u0000\u0000\u0000\u050e\u050c\u0001\u0000\u0000\u0000" + + "\u050e\u050f\u0001\u0000\u0000\u0000\u050f\u0512\u0001\u0000\u0000\u0000" + + "\u0510\u050e\u0001\u0000\u0000\u0000\u0511\u0513\u00052\u0000\u0000\u0512" + + "\u0511\u0001\u0000\u0000\u0000\u0512\u0513\u0001\u0000\u0000\u0000\u0513" + + "\u00c9\u0001\u0000\u0000\u0000\u0514\u0516\u0005Z\u0000\u0000\u0515\u0517" + + "\u0003\u00ccf\u0000\u0516\u0515\u0001\u0000\u0000\u0000\u0516\u0517\u0001" + + "\u0000\u0000\u0000\u0517\u051d\u0001\u0000\u0000\u0000\u0518\u0519\u0005" + + "6\u0000\u0000\u0519\u051d\u0005Z\u0000\u0000\u051a\u051b\u0005F\u0000" + + "\u0000\u051b\u051d\u0005Z\u0000\u0000\u051c\u0514\u0001\u0000\u0000\u0000" + + "\u051c\u0518\u0001\u0000\u0000\u0000\u051c\u051a\u0001\u0000\u0000\u0000" + + "\u051d\u00cb\u0001\u0000\u0000\u0000\u051e\u051f\u00051\u0000\u0000\u051f" + + "\u0520\u0003\u00d0h\u0000\u0520\u00cd\u0001\u0000\u0000\u0000\u0521\u0526" + + "\u0003\u00d0h\u0000\u0522\u0523\u00052\u0000\u0000\u0523\u0525\u0003\u00d0" + + "h\u0000\u0524\u0522\u0001\u0000\u0000\u0000\u0525\u0528\u0001\u0000\u0000" + + "\u0000\u0526\u0524\u0001\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000" + + "\u0000\u0527\u052a\u0001\u0000\u0000\u0000\u0528\u0526\u0001\u0000\u0000" + + "\u0000\u0529\u052b\u00052\u0000\u0000\u052a\u0529\u0001\u0000\u0000\u0000" + + "\u052a\u052b\u0001\u0000\u0000\u0000\u052b\u00cf\u0001\u0000\u0000\u0000" + + "\u052c\u0532\u0003\u00e0p\u0000\u052d\u052e\u0005\'\u0000\u0000\u052e" + + "\u052f\u0003\u00e0p\u0000\u052f\u0530\u0005\t\u0000\u0000\u0530\u0531" + + "\u0003\u00d0h\u0000\u0531\u0533\u0001\u0000\u0000\u0000\u0532\u052d\u0001" + + "\u0000\u0000\u0000\u0532\u0533\u0001\u0000\u0000\u0000\u0533\u0536\u0001" + + "\u0000\u0000\u0000\u0534\u0536\u0003\u011a\u008d\u0000\u0535\u052c\u0001" + + "\u0000\u0000\u0000\u0535\u0534\u0001\u0000\u0000\u0000\u0536\u00d1\u0001" + + "\u0000\u0000\u0000\u0537\u053d\u0005)\u0000\u0000\u0538\u0539\u0005\u001d" + + "\u0000\u0000\u0539\u053e\u0003\u00d0h\u0000\u053a\u053c\u0003\u00d4j\u0000" + + "\u053b\u053a\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000\u0000\u0000" + + "\u053c\u053e\u0001\u0000\u0000\u0000\u053d\u0538\u0001\u0000\u0000\u0000" + + "\u053d\u053b\u0001\u0000\u0000\u0000\u053e\u00d3\u0001\u0000\u0000\u0000" + + "\u053f\u0544\u0003\u00d6k\u0000\u0540\u0541\u00052\u0000\u0000\u0541\u0543" + + "\u0003\u00d6k\u0000\u0542\u0540\u0001\u0000\u0000\u0000\u0543\u0546\u0001" + + "\u0000\u0000\u0000\u0544\u0542\u0001\u0000\u0000\u0000\u0544\u0545\u0001" + + "\u0000\u0000\u0000\u0545\u0548\u0001\u0000\u0000\u0000\u0546\u0544\u0001" + + "\u0000\u0000\u0000\u0547\u0549\u00052\u0000\u0000\u0548\u0547\u0001\u0000" + + "\u0000\u0000\u0548\u0549\u0001\u0000\u0000\u0000\u0549\u00d5\u0001\u0000" + + "\u0000\u0000\u054a\u054b\u00056\u0000\u0000\u054b\u054e\u0003\u00fe\u007f" + + "\u0000\u054c\u054e\u0003\u00d0h\u0000\u054d\u054a\u0001\u0000\u0000\u0000" + + "\u054d\u054c\u0001\u0000\u0000\u0000\u054e\u00d7\u0001\u0000\u0000\u0000" + + "\u054f\u0554\u0003\u00dam\u0000\u0550\u0551\u00052\u0000\u0000\u0551\u0553" + + "\u0003\u00dam\u0000\u0552\u0550\u0001\u0000\u0000\u0000\u0553\u0556\u0001" + + "\u0000\u0000\u0000\u0554\u0552\u0001\u0000\u0000\u0000\u0554\u0555\u0001" + + "\u0000\u0000\u0000\u0555\u0558\u0001\u0000\u0000\u0000\u0556\u0554\u0001" + + "\u0000\u0000\u0000\u0557\u0559\u00052\u0000\u0000\u0558\u0557\u0001\u0000" + + "\u0000\u0000\u0558\u0559\u0001\u0000\u0000\u0000\u0559\u00d9\u0001\u0000" + + "\u0000\u0000\u055a\u055b\u00056\u0000\u0000\u055b\u055e\u0003\u00fe\u007f" + + "\u0000\u055c\u055e\u0003\u00deo\u0000\u055d\u055a\u0001\u0000\u0000\u0000" + + "\u055d\u055c\u0001\u0000\u0000\u0000\u055e\u00db\u0001\u0000\u0000\u0000" + + "\u055f\u0560\u0005Z\u0000\u0000\u0560\u0561\u0005X\u0000\u0000\u0561\u0562" + + "\u0003\u00d0h\u0000\u0562\u00dd\u0001\u0000\u0000\u0000\u0563\u0566\u0003" + + "\u00dcn\u0000\u0564\u0566\u0003\u00d0h\u0000\u0565\u0563\u0001\u0000\u0000" + + "\u0000\u0565\u0564\u0001\u0000\u0000\u0000\u0566\u00df\u0001\u0000\u0000" + + "\u0000\u0567\u056c\u0003\u00e2q\u0000\u0568\u0569\u0005(\u0000\u0000\u0569" + + "\u056b\u0003\u00e2q\u0000\u056a\u0568\u0001\u0000\u0000\u0000\u056b\u056e" + + "\u0001\u0000\u0000\u0000\u056c\u056a\u0001\u0000\u0000\u0000\u056c\u056d" + + "\u0001\u0000\u0000\u0000\u056d\u00e1\u0001\u0000\u0000\u0000\u056e\u056c" + + "\u0001\u0000\u0000\u0000\u056f\u0574\u0003\u00e4r\u0000\u0570\u0571\u0005" + + "\u0016\u0000\u0000\u0571\u0573\u0003\u00e4r\u0000\u0572\u0570\u0001\u0000" + + "\u0000\u0000\u0573\u0576\u0001\u0000\u0000\u0000\u0574\u0572\u0001\u0000" + + "\u0000\u0000\u0574\u0575\u0001\u0000\u0000\u0000\u0575\u00e3\u0001\u0000" + + "\u0000\u0000\u0576\u0574\u0001\u0000\u0000\u0000\u0577\u0578\u0005#\u0000" + + "\u0000\u0578\u057b\u0003\u00e4r\u0000\u0579\u057b\u0003\u00e6s\u0000\u057a" + + "\u0577\u0001\u0000\u0000\u0000\u057a\u0579\u0001\u0000\u0000\u0000\u057b" + + "\u00e5\u0001\u0000\u0000\u0000\u057c\u0580\u0003\u00fe\u007f\u0000\u057d" + + "\u057f\u0003\u00e8t\u0000\u057e\u057d\u0001\u0000\u0000\u0000\u057f\u0582" + + "\u0001\u0000\u0000\u0000\u0580\u057e\u0001\u0000\u0000\u0000\u0580\u0581" + + "\u0001\u0000\u0000\u0000\u0581\u00e7\u0001\u0000\u0000\u0000\u0582\u0580" + + "\u0001\u0000\u0000\u0000\u0583\u058e\u0003\u00eau\u0000\u0584\u058e\u0003" + + "\u00ecv\u0000\u0585\u058e\u0003\u00eew\u0000\u0586\u058e\u0003\u00f0x" + + "\u0000\u0587\u058e\u0003\u00f2y\u0000\u0588\u058e\u0003\u00f4z\u0000\u0589" + + "\u058e\u0003\u00f6{\u0000\u058a\u058e\u0003\u00f8|\u0000\u058b\u058e\u0003" + + "\u00fa}\u0000\u058c\u058e\u0003\u00fc~\u0000\u058d\u0583\u0001\u0000\u0000" + + "\u0000\u058d\u0584\u0001\u0000\u0000\u0000\u058d\u0585\u0001\u0000\u0000" + + "\u0000\u058d\u0586\u0001\u0000\u0000\u0000\u058d\u0587\u0001\u0000\u0000" + + "\u0000\u058d\u0588\u0001\u0000\u0000\u0000\u058d\u0589\u0001\u0000\u0000" + + "\u0000\u058d\u058a\u0001\u0000\u0000\u0000\u058d\u058b\u0001\u0000\u0000" + + "\u0000\u058d\u058c\u0001\u0000\u0000\u0000\u058e\u00e9\u0001\u0000\u0000" + + "\u0000\u058f\u0590\u0005>\u0000\u0000\u0590\u0591\u0003\u00fe\u007f\u0000" + + "\u0591\u00eb\u0001\u0000\u0000\u0000\u0592\u0593\u0005?\u0000\u0000\u0593" + + "\u0594\u0003\u00fe\u007f\u0000\u0594\u00ed\u0001\u0000\u0000\u0000\u0595" + + "\u0596\u0005@\u0000\u0000\u0596\u0597\u0003\u00fe\u007f\u0000\u0597\u00ef" + + "\u0001\u0000\u0000\u0000\u0598\u0599\u0005:\u0000\u0000\u0599\u059a\u0003" + + "\u00fe\u007f\u0000\u059a\u00f1\u0001\u0000\u0000\u0000\u059b\u059c\u0005" + + "A\u0000\u0000\u059c\u059d\u0003\u00fe\u007f\u0000\u059d\u00f3\u0001\u0000" + + "\u0000\u0000\u059e\u059f\u0005;\u0000\u0000\u059f\u05a0\u0003\u00fe\u007f" + + "\u0000\u05a0\u00f5\u0001\u0000\u0000\u0000\u05a1\u05a2\u0005#\u0000\u0000" + + "\u05a2\u05a3\u0005\u000f\u0000\u0000\u05a3\u05a4\u0003\u00fe\u007f\u0000" + + "\u05a4\u00f7\u0001\u0000\u0000\u0000\u05a5\u05a6\u0005\u000f\u0000\u0000" + + "\u05a6\u05a7\u0003\u00fe\u007f\u0000\u05a7\u00f9\u0001\u0000\u0000\u0000" + + "\u05a8\u05a9\u0005\u0014\u0000\u0000\u05a9\u05aa\u0005#\u0000\u0000\u05aa" + + "\u05ab\u0003\u00fe\u007f\u0000\u05ab\u00fb\u0001\u0000\u0000\u0000\u05ac" + + "\u05ad\u0005\u0014\u0000\u0000\u05ad\u05ae\u0003\u00fe\u007f\u0000\u05ae" + + "\u00fd\u0001\u0000\u0000\u0000\u05af\u05b0\u0006\u007f\uffff\uffff\u0000" + + "\u05b0\u05b1\u0003\u0100\u0080\u0000\u05b1\u05b7\u0001\u0000\u0000\u0000" + + "\u05b2\u05b3\n\u0002\u0000\u0000\u05b3\u05b4\u00058\u0000\u0000\u05b4" + + "\u05b6\u0003\u0100\u0080\u0000\u05b5\u05b2\u0001\u0000\u0000\u0000\u05b6" + + "\u05b9\u0001\u0000\u0000\u0000\u05b7\u05b5\u0001\u0000\u0000\u0000\u05b7" + + "\u05b8\u0001\u0000\u0000\u0000\u05b8\u00ff\u0001\u0000\u0000\u0000\u05b9" + + "\u05b7\u0001\u0000\u0000\u0000\u05ba\u05bb\u0006\u0080\uffff\uffff\u0000" + + "\u05bb\u05bc\u0003\u0102\u0081\u0000\u05bc\u05c2\u0001\u0000\u0000\u0000" + + "\u05bd\u05be\n\u0002\u0000\u0000\u05be\u05bf\u0005C\u0000\u0000\u05bf" + + "\u05c1\u0003\u0102\u0081\u0000\u05c0\u05bd\u0001\u0000\u0000\u0000\u05c1" + + "\u05c4\u0001\u0000\u0000\u0000\u05c2\u05c0\u0001\u0000\u0000\u0000\u05c2" + + "\u05c3\u0001\u0000\u0000\u0000\u05c3\u0101\u0001\u0000\u0000\u0000\u05c4" + + "\u05c2\u0001\u0000\u0000\u0000\u05c5\u05c6\u0006\u0081\uffff\uffff\u0000" + + "\u05c6\u05c7\u0003\u0104\u0082\u0000\u05c7\u05cd\u0001\u0000\u0000\u0000" + + "\u05c8\u05c9\n\u0002\u0000\u0000\u05c9\u05ca\u00059\u0000\u0000\u05ca" + + "\u05cc\u0003\u0104\u0082\u0000\u05cb\u05c8\u0001\u0000\u0000\u0000\u05cc" + + "\u05cf\u0001\u0000\u0000\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000\u05cd" + + "\u05ce\u0001\u0000\u0000\u0000\u05ce\u0103\u0001\u0000\u0000\u0000\u05cf" + + "\u05cd\u0001\u0000\u0000\u0000\u05d0\u05d1\u0006\u0082\uffff\uffff\u0000" + + "\u05d1\u05d2\u0003\u0106\u0083\u0000\u05d2\u05d8\u0001\u0000\u0000\u0000" + + "\u05d3\u05d4\n\u0002\u0000\u0000\u05d4\u05d5\u0007\u0003\u0000\u0000\u05d5" + + "\u05d7\u0003\u0106\u0083\u0000\u05d6\u05d3\u0001\u0000\u0000\u0000\u05d7" + + "\u05da\u0001\u0000\u0000\u0000\u05d8\u05d6\u0001\u0000\u0000\u0000\u05d8" + + "\u05d9\u0001\u0000\u0000\u0000\u05d9\u0105\u0001\u0000\u0000\u0000\u05da" + + "\u05d8\u0001\u0000\u0000\u0000\u05db\u05dc\u0006\u0083\uffff\uffff\u0000" + + "\u05dc\u05dd\u0003\u0108\u0084\u0000\u05dd\u05e3\u0001\u0000\u0000\u0000" + + "\u05de\u05df\n\u0002\u0000\u0000\u05df\u05e0\u0007\u0002\u0000\u0000\u05e0" + + "\u05e2\u0003\u0108\u0084\u0000\u05e1\u05de\u0001\u0000\u0000\u0000\u05e2" + + "\u05e5\u0001\u0000\u0000\u0000\u05e3\u05e1\u0001\u0000\u0000\u0000\u05e3" + + "\u05e4\u0001\u0000\u0000\u0000\u05e4\u0107\u0001\u0000\u0000\u0000\u05e5" + + "\u05e3\u0001\u0000\u0000\u0000\u05e6\u05e7\u0006\u0084\uffff\uffff\u0000" + + "\u05e7\u05e8\u0003\u010a\u0085\u0000\u05e8\u05ee\u0001\u0000\u0000\u0000" + + "\u05e9\u05ea\n\u0002\u0000\u0000\u05ea\u05eb\u0007\u0004\u0000\u0000\u05eb" + + "\u05ed\u0003\u010a\u0085\u0000\u05ec\u05e9\u0001\u0000\u0000\u0000\u05ed" + + "\u05f0\u0001\u0000\u0000\u0000\u05ee\u05ec\u0001\u0000\u0000\u0000\u05ee" + + "\u05ef\u0001\u0000\u0000\u0000\u05ef\u0109\u0001\u0000\u0000\u0000\u05f0" + + "\u05ee\u0001\u0000\u0000\u0000\u05f1\u05f2\u00054\u0000\u0000\u05f2\u05f9" + + "\u0003\u010a\u0085\u0000\u05f3\u05f4\u00055\u0000\u0000\u05f4\u05f9\u0003" + + "\u010a\u0085\u0000\u05f5\u05f6\u0005B\u0000\u0000\u05f6\u05f9\u0003\u010a" + + "\u0085\u0000\u05f7\u05f9\u0003\u010c\u0086\u0000\u05f8\u05f1\u0001\u0000" + + "\u0000\u0000\u05f8\u05f3\u0001\u0000\u0000\u0000\u05f8\u05f5\u0001\u0000" + + "\u0000\u0000\u05f8\u05f7\u0001\u0000\u0000\u0000\u05f9\u010b\u0001\u0000" + + "\u0000\u0000\u05fa\u05fd\u0003\u010e\u0087\u0000\u05fb\u05fc\u0005F\u0000" + + "\u0000\u05fc\u05fe\u0003\u010a\u0085\u0000\u05fd\u05fb\u0001\u0000\u0000" + + "\u0000\u05fd\u05fe\u0001\u0000\u0000\u0000\u05fe\u010d\u0001\u0000\u0000" + + "\u0000\u05ff\u0600\u0005\b\u0000\u0000\u0600\u0603\u0003\u0110\u0088\u0000" + + "\u0601\u0603\u0003\u0110\u0088\u0000\u0602\u05ff\u0001\u0000\u0000\u0000" + + "\u0602\u0601\u0001\u0000\u0000\u0000\u0603\u010f\u0001\u0000\u0000\u0000" + + "\u0604\u0605\u0006\u0088\uffff\uffff\u0000\u0605\u0606\u0003\u0116\u008b" + + "\u0000\u0606\u0618\u0001\u0000\u0000\u0000\u0607\u0614\n\u0002\u0000\u0000" + + "\u0608\u0609\u00050\u0000\u0000\u0609\u0615\u0005Z\u0000\u0000\u060a\u0615" + + "\u0003\u0156\u00ab\u0000\u060b\u060d\u0005*\u0000\u0000\u060c\u060e\u0003" + + "\u015a\u00ad\u0000\u060d\u060c\u0001\u0000\u0000\u0000\u060d\u060e\u0001" + + "\u0000\u0000\u0000\u060e\u060f\u0001\u0000\u0000\u0000\u060f\u0615\u0005" + + "-\u0000\u0000\u0610\u0611\u0005+\u0000\u0000\u0611\u0612\u0003\u0112\u0089" + + "\u0000\u0612\u0613\u0005.\u0000\u0000\u0613\u0615\u0001\u0000\u0000\u0000" + + "\u0614\u0608\u0001\u0000\u0000\u0000\u0614\u060a\u0001\u0000\u0000\u0000" + + "\u0614\u060b\u0001\u0000\u0000\u0000\u0614\u0610\u0001\u0000\u0000\u0000" + + "\u0615\u0617\u0001\u0000\u0000\u0000\u0616\u0607\u0001\u0000\u0000\u0000" + + "\u0617\u061a\u0001\u0000\u0000\u0000\u0618\u0616\u0001\u0000\u0000\u0000" + + "\u0618\u0619\u0001\u0000\u0000\u0000\u0619\u0111\u0001\u0000\u0000\u0000" + + "\u061a\u0618\u0001\u0000\u0000\u0000\u061b\u062e\u0003\u0114\u008a\u0000" + + "\u061c\u061f\u0003\u0114\u008a\u0000\u061d\u061f\u0003\u0160\u00b0\u0000" + + "\u061e\u061c\u0001\u0000\u0000\u0000\u061e\u061d\u0001\u0000\u0000\u0000" + + "\u061f\u0627\u0001\u0000\u0000\u0000\u0620\u0623\u00052\u0000\u0000\u0621" + + "\u0624\u0003\u0114\u008a\u0000\u0622\u0624\u0003\u0160\u00b0\u0000\u0623" + + "\u0621\u0001\u0000\u0000\u0000\u0623\u0622\u0001\u0000\u0000\u0000\u0624" + + "\u0626\u0001\u0000\u0000\u0000\u0625\u0620\u0001\u0000\u0000\u0000\u0626" + + "\u0629\u0001\u0000\u0000\u0000\u0627\u0625\u0001\u0000\u0000\u0000\u0627" + + "\u0628\u0001\u0000\u0000\u0000\u0628\u062b\u0001\u0000\u0000\u0000\u0629" + + "\u0627\u0001\u0000\u0000\u0000\u062a\u062c\u00052\u0000\u0000\u062b\u062a" + + "\u0001\u0000\u0000\u0000\u062b\u062c\u0001\u0000\u0000\u0000\u062c\u062e" + + "\u0001\u0000\u0000\u0000\u062d\u061b\u0001\u0000\u0000\u0000\u062d\u061e" + + "\u0001\u0000\u0000\u0000\u062e\u0113\u0001\u0000\u0000\u0000\u062f\u0631" + + "\u0003\u00d0h\u0000\u0630\u062f\u0001\u0000\u0000\u0000\u0630\u0631\u0001" + + "\u0000\u0000\u0000\u0631\u0632\u0001\u0000\u0000\u0000\u0632\u0634\u0005" + + "1\u0000\u0000\u0633\u0635\u0003\u00d0h\u0000\u0634\u0633\u0001\u0000\u0000" + + "\u0000\u0634\u0635\u0001\u0000\u0000\u0000\u0635\u063a\u0001\u0000\u0000" + + "\u0000\u0636\u0638\u00051\u0000\u0000\u0637\u0639\u0003\u00d0h\u0000\u0638" + + "\u0637\u0001\u0000\u0000\u0000\u0638\u0639\u0001\u0000\u0000\u0000\u0639" + + "\u063b\u0001\u0000\u0000\u0000\u063a\u0636\u0001\u0000\u0000\u0000\u063a" + + "\u063b\u0001\u0000\u0000\u0000\u063b\u063e\u0001\u0000\u0000\u0000\u063c" + + "\u063e\u0003\u00deo\u0000\u063d\u0630\u0001\u0000\u0000\u0000\u063d\u063c" + + "\u0001\u0000\u0000\u0000\u063e\u0115\u0001\u0000\u0000\u0000\u063f\u0656" + + "\u0005Z\u0000\u0000\u0640\u0656\u0005\u0011\u0000\u0000\u0641\u0656\u0005" + + "\u0007\u0000\u0000\u0642\u0656\u0005\f\u0000\u0000\u0643\u0656\u0003\u013e" + + "\u009f\u0000\u0644\u0656\u0005[\u0000\u0000\u0645\u0649\u0003\u0142\u00a1" + + "\u0000\u0646\u0649\u0003\u0118\u008c\u0000\u0647\u0649\u0003\u0156\u00ab" + + "\u0000\u0648\u0645\u0001\u0000\u0000\u0000\u0648\u0646\u0001\u0000\u0000" + + "\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u0656\u0001\u0000\u0000" + + "\u0000\u064a\u064d\u0003\u0140\u00a0\u0000\u064b\u064d\u0003\u0152\u00a9" + + "\u0000\u064c\u064a\u0001\u0000\u0000\u0000\u064c\u064b\u0001\u0000\u0000" + + "\u0000\u064d\u0656\u0001\u0000\u0000\u0000\u064e\u0653\u0003\u0146\u00a3" + + "\u0000\u064f\u0653\u0003\u0144\u00a2\u0000\u0650\u0653\u0003\u0158\u00ac" + + "\u0000\u0651\u0653\u0003\u0154\u00aa\u0000\u0652\u064e\u0001\u0000\u0000" + + "\u0000\u0652\u064f\u0001\u0000\u0000\u0000\u0652\u0650\u0001\u0000\u0000" + + "\u0000\u0652\u0651\u0001\u0000\u0000\u0000\u0653\u0656\u0001\u0000\u0000" + + "\u0000\u0654\u0656\u0005W\u0000\u0000\u0655\u063f\u0001\u0000\u0000\u0000" + + "\u0655\u0640\u0001\u0000\u0000\u0000\u0655\u0641\u0001\u0000\u0000\u0000" + + "\u0655\u0642\u0001\u0000\u0000\u0000\u0655\u0643\u0001\u0000\u0000\u0000" + + "\u0655\u0644\u0001\u0000\u0000\u0000\u0655\u0648\u0001\u0000\u0000\u0000" + + "\u0655\u064c\u0001\u0000\u0000\u0000\u0655\u0652\u0001\u0000\u0000\u0000" + + "\u0655\u0654\u0001\u0000\u0000\u0000\u0656\u0117\u0001\u0000\u0000\u0000" + + "\u0657\u065a\u0005*\u0000\u0000\u0658\u065b\u0003\u00d2i\u0000\u0659\u065b" + + "\u0003\u00deo\u0000\u065a\u0658\u0001\u0000\u0000\u0000\u065a\u0659\u0001" + + "\u0000\u0000\u0000\u065b\u065c\u0001\u0000\u0000\u0000\u065c\u065d\u0005" + + "-\u0000\u0000\u065d\u0119\u0001\u0000\u0000\u0000\u065e\u0660\u0005\u0019" + + "\u0000\u0000\u065f\u0661\u0003\u011c\u008e\u0000\u0660\u065f\u0001\u0000" + + "\u0000\u0000\u0660\u0661\u0001\u0000\u0000\u0000\u0661\u0662\u0001\u0000" + + "\u0000\u0000\u0662\u0663\u00051\u0000\u0000\u0663\u0664\u0003\u00d0h\u0000" + + "\u0664\u011b\u0001\u0000\u0000\u0000\u0665\u0666\u0003\u011e\u008f\u0000" + + "\u0666\u011d\u0001\u0000\u0000\u0000\u0667\u066b\u0003\u0120\u0090\u0000" + + "\u0668\u066a\u0003\u0128\u0094\u0000\u0669\u0668\u0001\u0000\u0000\u0000" + + "\u066a\u066d\u0001\u0000\u0000\u0000\u066b\u0669\u0001\u0000\u0000\u0000" + + "\u066b\u066c\u0001\u0000\u0000\u0000\u066c\u0671\u0001\u0000\u0000\u0000" + + "\u066d\u066b\u0001\u0000\u0000\u0000\u066e\u0670\u0003\u012a\u0095\u0000" + + "\u066f\u066e\u0001\u0000\u0000\u0000\u0670\u0673\u0001\u0000\u0000\u0000" + + "\u0671\u066f\u0001\u0000\u0000\u0000\u0671\u0672\u0001\u0000\u0000\u0000" + + "\u0672\u0675\u0001\u0000\u0000\u0000\u0673\u0671\u0001\u0000\u0000\u0000" + + "\u0674\u0676\u0003\u0124\u0092\u0000\u0675\u0674\u0001\u0000\u0000\u0000" + + "\u0675\u0676\u0001\u0000\u0000\u0000\u0676\u0699\u0001\u0000\u0000\u0000" + + "\u0677\u067b\u0003\u0122\u0091\u0000\u0678\u067a\u0003\u012a\u0095\u0000" + + "\u0679\u0678\u0001\u0000\u0000\u0000\u067a\u067d\u0001\u0000\u0000\u0000" + + "\u067b\u0679\u0001\u0000\u0000\u0000\u067b\u067c\u0001\u0000\u0000\u0000" + + "\u067c\u067f\u0001\u0000\u0000\u0000\u067d\u067b\u0001\u0000\u0000\u0000" + + "\u067e\u0680\u0003\u0124\u0092\u0000\u067f\u067e\u0001\u0000\u0000\u0000" + + "\u067f\u0680\u0001\u0000\u0000\u0000\u0680\u0699\u0001\u0000\u0000\u0000" + + "\u0681\u0683\u0003\u0128\u0094\u0000\u0682\u0681\u0001\u0000\u0000\u0000" + + "\u0683\u0684\u0001\u0000\u0000\u0000\u0684\u0682\u0001\u0000\u0000\u0000" + + "\u0684\u0685\u0001\u0000\u0000\u0000\u0685\u0689\u0001\u0000\u0000\u0000" + + "\u0686\u0688\u0003\u012a\u0095\u0000\u0687\u0686\u0001\u0000\u0000\u0000" + + "\u0688\u068b\u0001\u0000\u0000\u0000\u0689\u0687\u0001\u0000\u0000\u0000" + + "\u0689\u068a\u0001\u0000\u0000\u0000\u068a\u068d\u0001\u0000\u0000\u0000" + + "\u068b\u0689\u0001\u0000\u0000\u0000\u068c\u068e\u0003\u0124\u0092\u0000" + + "\u068d\u068c\u0001\u0000\u0000\u0000\u068d\u068e\u0001\u0000\u0000\u0000" + + "\u068e\u0699\u0001\u0000\u0000\u0000\u068f\u0691\u0003\u012a\u0095\u0000" + + "\u0690\u068f\u0001\u0000\u0000\u0000\u0691\u0692\u0001\u0000\u0000\u0000" + + "\u0692\u0690\u0001\u0000\u0000\u0000\u0692\u0693\u0001\u0000\u0000\u0000" + + "\u0693\u0695\u0001\u0000\u0000\u0000\u0694\u0696\u0003\u0124\u0092\u0000" + + "\u0695\u0694\u0001\u0000\u0000\u0000\u0695\u0696\u0001\u0000\u0000\u0000" + + "\u0696\u0699\u0001\u0000\u0000\u0000\u0697\u0699\u0003\u0124\u0092\u0000" + + "\u0698\u0667\u0001\u0000\u0000\u0000\u0698\u0677\u0001\u0000\u0000\u0000" + + "\u0698\u0682\u0001\u0000\u0000\u0000\u0698\u0690\u0001\u0000\u0000\u0000" + + "\u0698\u0697\u0001\u0000\u0000\u0000\u0699\u011f\u0001\u0000\u0000\u0000" + + "\u069a\u069c\u0003\u0128\u0094\u0000\u069b\u069a\u0001\u0000\u0000\u0000" + + "\u069c\u069d\u0001\u0000\u0000\u0000\u069d\u069b\u0001\u0000\u0000\u0000" + + "\u069d\u069e\u0001\u0000\u0000\u0000\u069e\u069f\u0001\u0000\u0000\u0000" + + "\u069f\u06a1\u00057\u0000\u0000\u06a0\u06a2\u00052\u0000\u0000\u06a1\u06a0" + + "\u0001\u0000\u0000\u0000\u06a1\u06a2\u0001\u0000\u0000\u0000\u06a2\u0121" + + "\u0001\u0000\u0000\u0000\u06a3\u06a5\u0003\u0128\u0094\u0000\u06a4\u06a3" + + "\u0001\u0000\u0000\u0000\u06a5\u06a8\u0001\u0000\u0000\u0000\u06a6\u06a4" + + "\u0001\u0000\u0000\u0000\u06a6\u06a7\u0001\u0000\u0000\u0000\u06a7\u06aa" + + "\u0001\u0000\u0000\u0000\u06a8\u06a6\u0001\u0000\u0000\u0000\u06a9\u06ab" + + "\u0003\u012a\u0095\u0000\u06aa\u06a9\u0001\u0000\u0000\u0000\u06ab\u06ac" + + "\u0001\u0000\u0000\u0000\u06ac\u06aa\u0001\u0000\u0000\u0000\u06ac\u06ad" + + "\u0001\u0000\u0000\u0000\u06ad\u06ae\u0001\u0000\u0000\u0000\u06ae\u06b0" + + "\u00057\u0000\u0000\u06af\u06b1\u00052\u0000\u0000\u06b0\u06af\u0001\u0000" + + "\u0000\u0000\u06b0\u06b1\u0001\u0000\u0000\u0000\u06b1\u0123\u0001\u0000" + + "\u0000\u0000\u06b2\u06b3\u00056\u0000\u0000\u06b3\u06b7\u0003\u0128\u0094" + + "\u0000\u06b4\u06b6\u0003\u012c\u0096\u0000\u06b5\u06b4\u0001\u0000\u0000" + + "\u0000\u06b6\u06b9\u0001\u0000\u0000\u0000\u06b7\u06b5\u0001\u0000\u0000" + + "\u0000\u06b7\u06b8\u0001\u0000\u0000\u0000\u06b8\u06bb\u0001\u0000\u0000" + + "\u0000\u06b9\u06b7\u0001\u0000\u0000\u0000\u06ba\u06bc\u0003\u0126\u0093" + + "\u0000\u06bb\u06ba\u0001\u0000\u0000\u0000\u06bb\u06bc\u0001\u0000\u0000" + + "\u0000\u06bc\u06c9\u0001\u0000\u0000\u0000\u06bd\u06be\u00056\u0000\u0000" + + "\u06be\u06c0\u00052\u0000\u0000\u06bf\u06c1\u0003\u012c\u0096\u0000\u06c0" + + "\u06bf\u0001\u0000\u0000\u0000\u06c1\u06c2\u0001\u0000\u0000\u0000\u06c2" + + "\u06c0\u0001\u0000\u0000\u0000\u06c2\u06c3\u0001\u0000\u0000\u0000\u06c3" + + "\u06c5\u0001\u0000\u0000\u0000\u06c4\u06c6\u0003\u0126\u0093\u0000\u06c5" + + "\u06c4\u0001\u0000\u0000\u0000\u06c5\u06c6\u0001\u0000\u0000\u0000\u06c6" + + "\u06c9\u0001\u0000\u0000\u0000\u06c7\u06c9\u0003\u0126\u0093\u0000\u06c8" + + "\u06b2\u0001\u0000\u0000\u0000\u06c8\u06bd\u0001\u0000\u0000\u0000\u06c8" + + "\u06c7\u0001\u0000\u0000\u0000\u06c9\u0125\u0001\u0000\u0000\u0000\u06ca" + + "\u06cb\u0005F\u0000\u0000\u06cb\u06cc\u0003\u0128\u0094\u0000\u06cc\u0127" + + "\u0001\u0000\u0000\u0000\u06cd\u06cf\u0003\u012e\u0097\u0000\u06ce\u06d0" + + "\u00052\u0000\u0000\u06cf\u06ce\u0001\u0000\u0000\u0000\u06cf\u06d0\u0001" + + "\u0000\u0000\u0000\u06d0\u0129\u0001\u0000\u0000\u0000\u06d1\u06d2\u0003" + + "\u012e\u0097\u0000\u06d2\u06d4\u0003d2\u0000\u06d3\u06d5\u00052\u0000" + + "\u0000\u06d4\u06d3\u0001\u0000\u0000\u0000\u06d4\u06d5\u0001\u0000\u0000" + + "\u0000\u06d5\u012b\u0001\u0000\u0000\u0000\u06d6\u06d8\u0003\u012e\u0097" + + "\u0000\u06d7\u06d9\u0003d2\u0000\u06d8\u06d7\u0001\u0000\u0000\u0000\u06d8" + + "\u06d9\u0001\u0000\u0000\u0000\u06d9\u06db\u0001\u0000\u0000\u0000\u06da" + + "\u06dc\u00052\u0000\u0000\u06db\u06da\u0001\u0000\u0000\u0000\u06db\u06dc" + + "\u0001\u0000\u0000\u0000\u06dc\u012d\u0001\u0000\u0000\u0000\u06dd\u06de" + + "\u0005Z\u0000\u0000\u06de\u012f\u0001\u0000\u0000\u0000\u06df\u06e2\u0003" + + "\u0132\u0099\u0000\u06e0\u06e2\u0005\u0005\u0000\u0000\u06e1\u06df\u0001" + + "\u0000\u0000\u0000\u06e1\u06e0\u0001\u0000\u0000\u0000\u06e2\u0131\u0001" + + "\u0000\u0000\u0000\u06e3\u06e6\u0005,\u0000\u0000\u06e4\u06e7\u0003\u00d2" + + "i\u0000\u06e5\u06e7\u0003\u00d4j\u0000\u06e6\u06e4\u0001\u0000\u0000\u0000" + + "\u06e6\u06e5\u0001\u0000\u0000\u0000\u06e7\u06e9\u0001\u0000\u0000\u0000" + + "\u06e8\u06ea\u0005<\u0000\u0000\u06e9\u06e8\u0001\u0000\u0000\u0000\u06e9" + + "\u06ea\u0001\u0000\u0000\u0000\u06ea\u06ec\u0001\u0000\u0000\u0000\u06eb" + + "\u06ed\u0003\u0134\u009a\u0000\u06ec\u06eb\u0001\u0000\u0000\u0000\u06ec" + + "\u06ed\u0001\u0000\u0000\u0000\u06ed\u06ef\u0001\u0000\u0000\u0000\u06ee" + + "\u06f0\u0003\u0136\u009b\u0000\u06ef\u06ee\u0001\u0000\u0000\u0000\u06ef" + + "\u06f0\u0001\u0000\u0000\u0000\u06f0\u06f1\u0001\u0000\u0000\u0000\u06f1" + + "\u06f2\u0005/\u0000\u0000\u06f2\u0133\u0001\u0000\u0000\u0000\u06f3\u06f4" + + "\u0005Y\u0000\u0000\u06f4\u06f5\u0005Z\u0000\u0000\u06f5\u0135\u0001\u0000" + + "\u0000\u0000\u06f6\u06fa\u00051\u0000\u0000\u06f7\u06f9\u0003\u0138\u009c" + + "\u0000\u06f8\u06f7\u0001\u0000\u0000\u0000\u06f9\u06fc\u0001\u0000\u0000" + + "\u0000\u06fa\u06f8\u0001\u0000\u0000\u0000\u06fa\u06fb\u0001\u0000\u0000" + + "\u0000\u06fb\u0137\u0001\u0000\u0000\u0000\u06fc\u06fa\u0001\u0000\u0000" + + "\u0000\u06fd\u0700\u0005\u0005\u0000\u0000\u06fe\u0700\u0003\u0132\u0099" + + "\u0000\u06ff\u06fd\u0001\u0000\u0000\u0000\u06ff\u06fe\u0001\u0000\u0000" + + "\u0000\u0700\u0139\u0001\u0000\u0000\u0000\u0701\u0705\u0005\u0004\u0000" + + "\u0000\u0702\u0704\u0003\u0130\u0098\u0000\u0703\u0702\u0001\u0000\u0000" + + "\u0000\u0704\u0707\u0001\u0000\u0000\u0000\u0705\u0703\u0001\u0000\u0000" + + "\u0000\u0705\u0706\u0001\u0000\u0000\u0000\u0706\u0708\u0001\u0000\u0000" + + "\u0000\u0707\u0705\u0001\u0000\u0000\u0000\u0708\u0709\u0005\u0006\u0000" + + "\u0000\u0709\u013b\u0001\u0000\u0000\u0000\u070a\u070b\u0005\\\u0000\u0000" + + "\u070b\u013d\u0001\u0000\u0000\u0000\u070c\u070f\u0003\u013a\u009d\u0000" + + "\u070d\u070f\u0003\u013c\u009e\u0000\u070e\u070c\u0001\u0000\u0000\u0000" + + "\u070e\u070d\u0001\u0000\u0000\u0000\u070f\u0710\u0001\u0000\u0000\u0000" + + "\u0710\u070e\u0001\u0000\u0000\u0000\u0710\u0711\u0001\u0000\u0000\u0000" + + "\u0711\u013f\u0001\u0000\u0000\u0000\u0712\u0714\u0005+\u0000\u0000\u0713" + + "\u0715\u0003\u00d8l\u0000\u0714\u0713\u0001\u0000\u0000\u0000\u0714\u0715" + + "\u0001\u0000\u0000\u0000\u0715\u0716\u0001\u0000\u0000\u0000\u0716\u0717" + + "\u0005.\u0000\u0000\u0717\u0141\u0001\u0000\u0000\u0000\u0718\u071e\u0005" + + "*\u0000\u0000\u0719\u071a\u0003\u00dam\u0000\u071a\u071c\u00052\u0000" + + "\u0000\u071b\u071d\u0003\u00d8l\u0000\u071c\u071b\u0001\u0000\u0000\u0000" + + "\u071c\u071d\u0001\u0000\u0000\u0000\u071d\u071f\u0001\u0000\u0000\u0000" + + "\u071e\u0719\u0001\u0000\u0000\u0000\u071e\u071f\u0001\u0000\u0000\u0000" + + "\u071f\u0720\u0001\u0000\u0000\u0000\u0720\u0721\u0005-\u0000\u0000\u0721" + + "\u0143\u0001\u0000\u0000\u0000\u0722\u0723\u0005,\u0000\u0000\u0723\u0724" + + "\u0003\u00d8l\u0000\u0724\u0725\u0005/\u0000\u0000\u0725\u0145\u0001\u0000" + + "\u0000\u0000\u0726\u0728\u0005,\u0000\u0000\u0727\u0729\u0003\u0148\u00a4" + + "\u0000\u0728\u0727\u0001\u0000\u0000\u0000\u0728\u0729\u0001\u0000\u0000" + + "\u0000\u0729\u072a\u0001\u0000\u0000\u0000\u072a\u072b\u0005/\u0000\u0000" + + "\u072b\u0147\u0001\u0000\u0000\u0000\u072c\u0731\u0003\u014a\u00a5\u0000" + + "\u072d\u072e\u00052\u0000\u0000\u072e\u0730\u0003\u014a\u00a5\u0000\u072f" + + "\u072d\u0001\u0000\u0000\u0000\u0730\u0733\u0001\u0000\u0000\u0000\u0731" + + "\u072f\u0001\u0000\u0000\u0000\u0731\u0732\u0001\u0000\u0000\u0000\u0732" + + "\u0735\u0001\u0000\u0000\u0000\u0733\u0731\u0001\u0000\u0000\u0000\u0734" + + "\u0736\u00052\u0000\u0000\u0735\u0734\u0001\u0000\u0000\u0000\u0735\u0736" + + "\u0001\u0000\u0000\u0000\u0736\u0149\u0001\u0000\u0000\u0000\u0737\u0738" + + "\u0005F\u0000\u0000\u0738\u073b\u0003\u00fe\u007f\u0000\u0739\u073b\u0003" + + "\u014c\u00a6\u0000\u073a\u0737\u0001\u0000\u0000\u0000\u073a\u0739\u0001" + + "\u0000\u0000\u0000\u073b\u014b\u0001\u0000\u0000\u0000\u073c\u073d\u0003" + + "\u00d0h\u0000\u073d\u073e\u00051\u0000\u0000\u073e\u073f\u0003\u00d0h" + + "\u0000\u073f\u014d\u0001\u0000\u0000\u0000\u0740\u0742\u0003\u0150\u00a8" + + "\u0000\u0741\u0740\u0001\u0000\u0000\u0000\u0742\u0743\u0001\u0000\u0000" + + "\u0000\u0743\u0741\u0001\u0000\u0000\u0000\u0743\u0744\u0001\u0000\u0000" + + "\u0000\u0744\u014f\u0001\u0000\u0000\u0000\u0745\u0747\u0005%\u0000\u0000" + + "\u0746\u0745\u0001\u0000\u0000\u0000\u0746\u0747\u0001\u0000\u0000\u0000" + + "\u0747\u0748\u0001\u0000\u0000\u0000\u0748\u0749\u0005\u0018\u0000\u0000" + + "\u0749\u074a\u0003\u0166\u00b3\u0000\u074a\u074b\u0005\u000f\u0000\u0000" + + "\u074b\u0750\u0003\u00e0p\u0000\u074c\u074d\u0005\'\u0000\u0000\u074d" + + "\u074f\u0003\u00e0p\u0000\u074e\u074c\u0001\u0000\u0000\u0000\u074f\u0752" + + "\u0001\u0000\u0000\u0000\u0750\u074e\u0001\u0000\u0000\u0000\u0750\u0751" + + "\u0001\u0000\u0000\u0000\u0751\u0151\u0001\u0000\u0000\u0000\u0752\u0750" + + "\u0001\u0000\u0000\u0000\u0753\u0754\u0005+\u0000\u0000\u0754\u0755\u0003" + + "\u00deo\u0000\u0755\u0756\u0003\u014e\u00a7\u0000\u0756\u0757\u0005.\u0000" + + "\u0000\u0757\u0153\u0001\u0000\u0000\u0000\u0758\u0759\u0005,\u0000\u0000" + + "\u0759\u075a\u0003\u00deo\u0000\u075a\u075b\u0003\u014e\u00a7\u0000\u075b" + + "\u075c\u0005/\u0000\u0000\u075c\u0155\u0001\u0000\u0000\u0000\u075d\u0760" + + "\u0005*\u0000\u0000\u075e\u0761\u0003\u00dcn\u0000\u075f\u0761\u0003\u00d0" + + "h\u0000\u0760\u075e\u0001\u0000\u0000\u0000\u0760\u075f\u0001\u0000\u0000" + + "\u0000\u0761\u0762\u0001\u0000\u0000\u0000\u0762\u0763\u0003\u014e\u00a7" + + "\u0000\u0763\u0764\u0005-\u0000\u0000\u0764\u0157\u0001\u0000\u0000\u0000" + + "\u0765\u0766\u0005,\u0000\u0000\u0766\u0767\u0003\u014c\u00a6\u0000\u0767" + + "\u0768\u0003\u014e\u00a7\u0000\u0768\u0769\u0005/\u0000\u0000\u0769\u0159" + + "\u0001\u0000\u0000\u0000\u076a\u076c\u0003\u015c\u00ae\u0000\u076b\u076d" + + "\u00052\u0000\u0000\u076c\u076b\u0001\u0000\u0000\u0000\u076c\u076d\u0001" + + "\u0000\u0000\u0000\u076d\u015b\u0001\u0000\u0000\u0000\u076e\u0774\u0003" + + "\u0160\u00b0\u0000\u076f\u0772\u0003\u00dcn\u0000\u0770\u0772\u0003\u00d0" + + "h\u0000\u0771\u076f\u0001\u0000\u0000\u0000\u0771\u0770\u0001\u0000\u0000" + + "\u0000\u0772\u0774\u0001\u0000\u0000\u0000\u0773\u076e\u0001\u0000\u0000" + + "\u0000\u0773\u0771\u0001\u0000\u0000\u0000\u0774\u077f\u0001\u0000\u0000" + + "\u0000\u0775\u077b\u00052\u0000\u0000\u0776\u077c\u0003\u0160\u00b0\u0000" + + "\u0777\u077a\u0003\u00dcn\u0000\u0778\u077a\u0003\u00d0h\u0000\u0779\u0777" + + "\u0001\u0000\u0000\u0000\u0779\u0778\u0001\u0000\u0000\u0000\u077a\u077c" + + "\u0001\u0000\u0000\u0000\u077b\u0776\u0001\u0000\u0000\u0000\u077b\u0779" + + "\u0001\u0000\u0000\u0000\u077c\u077e\u0001\u0000\u0000\u0000\u077d\u0775" + + "\u0001\u0000\u0000\u0000\u077e\u0781\u0001\u0000\u0000\u0000\u077f\u077d" + + "\u0001\u0000\u0000\u0000\u077f\u0780\u0001\u0000\u0000\u0000\u0780\u0784" + + "\u0001\u0000\u0000\u0000\u0781\u077f\u0001\u0000\u0000\u0000\u0782\u0783" + + "\u00052\u0000\u0000\u0783\u0785\u0003\u015e\u00af\u0000\u0784\u0782\u0001" + + "\u0000\u0000\u0000\u0784\u0785\u0001\u0000\u0000\u0000\u0785\u0788\u0001" + + "\u0000\u0000\u0000\u0786\u0788\u0003\u015e\u00af\u0000\u0787\u0773\u0001" + + "\u0000\u0000\u0000\u0787\u0786\u0001\u0000\u0000\u0000\u0788\u015d\u0001" + + "\u0000\u0000\u0000\u0789\u078e\u0003\u0162\u00b1\u0000\u078a\u078b\u0005" + + "2\u0000\u0000\u078b\u078d\u0003\u0162\u00b1\u0000\u078c\u078a\u0001\u0000" + + "\u0000\u0000\u078d\u0790\u0001\u0000\u0000\u0000\u078e\u078c\u0001\u0000" + + "\u0000\u0000\u078e\u078f\u0001\u0000\u0000\u0000\u078f\u079a\u0001\u0000" + + "\u0000\u0000\u0790\u078e\u0001\u0000\u0000\u0000\u0791\u0792\u00052\u0000" + + "\u0000\u0792\u0797\u0003\u0164\u00b2\u0000\u0793\u0794\u00052\u0000\u0000" + + "\u0794\u0796\u0003\u0164\u00b2\u0000\u0795\u0793\u0001\u0000\u0000\u0000" + + "\u0796\u0799\u0001\u0000\u0000\u0000\u0797\u0795\u0001\u0000\u0000\u0000" + + "\u0797\u0798\u0001\u0000\u0000\u0000\u0798\u079b\u0001\u0000\u0000\u0000" + + "\u0799\u0797\u0001\u0000\u0000\u0000\u079a\u0791\u0001\u0000\u0000\u0000" + + "\u079a\u079b\u0001\u0000\u0000\u0000\u079b\u07a5\u0001\u0000\u0000\u0000" + + "\u079c\u07a1\u0003\u0164\u00b2\u0000\u079d\u079e\u00052\u0000\u0000\u079e" + + "\u07a0\u0003\u0164\u00b2\u0000\u079f\u079d\u0001\u0000\u0000\u0000\u07a0" + + "\u07a3\u0001\u0000\u0000\u0000\u07a1\u079f\u0001\u0000\u0000\u0000\u07a1" + + "\u07a2\u0001\u0000\u0000\u0000\u07a2\u07a5\u0001\u0000\u0000\u0000\u07a3" + + "\u07a1\u0001\u0000\u0000\u0000\u07a4\u0789\u0001\u0000\u0000\u0000\u07a4" + + "\u079c\u0001\u0000\u0000\u0000\u07a5\u015f\u0001\u0000\u0000\u0000\u07a6" + + "\u07a7\u00056\u0000\u0000\u07a7\u07a8\u0003\u00d0h\u0000\u07a8\u0161\u0001" + + "\u0000\u0000\u0000\u07a9\u07aa\u0005Z\u0000\u0000\u07aa\u07ab\u0005<\u0000" + + "\u0000\u07ab\u07ae\u0003\u00d0h\u0000\u07ac\u07ae\u0003\u0160\u00b0\u0000" + + "\u07ad\u07a9\u0001\u0000\u0000\u0000\u07ad\u07ac\u0001\u0000\u0000\u0000" + + "\u07ae\u0163\u0001\u0000\u0000\u0000\u07af\u07b0\u0005Z\u0000\u0000\u07b0" + + "\u07b1\u0005<\u0000\u0000\u07b1\u07b5\u0003\u00d0h\u0000\u07b2\u07b3\u0005" + + "F\u0000\u0000\u07b3\u07b5\u0003\u00d0h\u0000\u07b4\u07af\u0001\u0000\u0000" + + "\u0000\u07b4\u07b2\u0001\u0000\u0000\u0000\u07b5\u0165\u0001\u0000\u0000" + + "\u0000\u07b6\u07bb\u0003\u016c\u00b6\u0000\u07b7\u07b8\u00052\u0000\u0000" + + "\u07b8\u07ba\u0003\u016c\u00b6\u0000\u07b9\u07b7\u0001\u0000\u0000\u0000" + + "\u07ba\u07bd\u0001\u0000\u0000\u0000\u07bb\u07b9\u0001\u0000\u0000\u0000" + + "\u07bb\u07bc\u0001\u0000\u0000\u0000\u07bc\u07bf\u0001\u0000\u0000\u0000" + + "\u07bd\u07bb\u0001\u0000\u0000\u0000\u07be\u07c0\u00052\u0000\u0000\u07bf" + + "\u07be\u0001\u0000\u0000\u0000\u07bf\u07c0\u0001\u0000\u0000\u0000\u07c0" + + "\u0167\u0001\u0000\u0000\u0000\u07c1\u07c4\u0003\u016c\u00b6\u0000\u07c2" + + "\u07c3\u00052\u0000\u0000\u07c3\u07c5\u0003\u016c\u00b6\u0000\u07c4\u07c2" + + "\u0001\u0000\u0000\u0000\u07c5\u07c6\u0001\u0000\u0000\u0000\u07c6\u07c4" + + "\u0001\u0000\u0000\u0000\u07c6\u07c7\u0001\u0000\u0000\u0000\u07c7\u07c9" + + "\u0001\u0000\u0000\u0000\u07c8\u07ca\u00052\u0000\u0000\u07c9\u07c8\u0001" + + "\u0000\u0000\u0000\u07c9\u07ca\u0001\u0000\u0000\u0000\u07ca\u0169\u0001" + + "\u0000\u0000\u0000\u07cb\u07d6\u0003\u016c\u00b6\u0000\u07cc\u07d7\u0005" + + "2\u0000\u0000\u07cd\u07ce\u00052\u0000\u0000\u07ce\u07d0\u0003\u016c\u00b6" + + "\u0000\u07cf\u07cd\u0001\u0000\u0000\u0000\u07d0\u07d1\u0001\u0000\u0000" + + "\u0000\u07d1\u07cf\u0001\u0000\u0000\u0000\u07d1\u07d2\u0001\u0000\u0000" + + "\u0000\u07d2\u07d4\u0001\u0000\u0000\u0000\u07d3\u07d5\u00052\u0000\u0000" + + "\u07d4\u07d3\u0001\u0000\u0000\u0000\u07d4\u07d5\u0001\u0000\u0000\u0000" + + "\u07d5\u07d7\u0001\u0000\u0000\u0000\u07d6\u07cc\u0001\u0000\u0000\u0000" + + "\u07d6\u07cf\u0001\u0000\u0000\u0000\u07d7\u016b\u0001\u0000\u0000\u0000" + + "\u07d8\u07d9\u00056\u0000\u0000\u07d9\u07dc\u0003\u016c\u00b6\u0000\u07da" + + "\u07dc\u0003\u016e\u00b7\u0000\u07db\u07d8\u0001\u0000\u0000\u0000\u07db" + + "\u07da\u0001\u0000\u0000\u0000\u07dc\u016d\u0001\u0000\u0000\u0000\u07dd" + + "\u07e4\u0003\u0176\u00bb\u0000\u07de\u07df\u00050\u0000\u0000\u07df\u07e5" + + "\u0005Z\u0000\u0000\u07e0\u07e1\u0005+\u0000\u0000\u07e1\u07e2\u0003\u0112" + + "\u0089\u0000\u07e2\u07e3\u0005.\u0000\u0000\u07e3\u07e5\u0001\u0000\u0000" + + "\u0000\u07e4\u07de\u0001\u0000\u0000\u0000\u07e4\u07e0\u0001\u0000\u0000" + + "\u0000\u07e5\u07e8\u0001\u0000\u0000\u0000\u07e6\u07e8\u0003\u0170\u00b8" + + "\u0000\u07e7\u07dd\u0001\u0000\u0000\u0000\u07e7\u07e6\u0001\u0000\u0000" + + "\u0000\u07e8\u016f\u0001\u0000\u0000\u0000\u07e9\u07f9\u0005Z\u0000\u0000" + + "\u07ea\u07eb\u0005*\u0000\u0000\u07eb\u07ec\u0003\u016e\u00b7\u0000\u07ec" + + "\u07ed\u0005-\u0000\u0000\u07ed\u07f9\u0001\u0000\u0000\u0000\u07ee\u07f0" + + "\u0005*\u0000\u0000\u07ef\u07f1\u0003\u016a\u00b5\u0000\u07f0\u07ef\u0001" + + "\u0000\u0000\u0000\u07f0\u07f1\u0001\u0000\u0000\u0000\u07f1\u07f2\u0001" + + "\u0000\u0000\u0000\u07f2\u07f9\u0005-\u0000\u0000\u07f3\u07f5\u0005+\u0000" + + "\u0000\u07f4\u07f6\u0003\u0168\u00b4\u0000\u07f5\u07f4\u0001\u0000\u0000" + + "\u0000\u07f5\u07f6\u0001\u0000\u0000\u0000\u07f6\u07f7\u0001\u0000\u0000" + + "\u0000\u07f7\u07f9\u0005.\u0000\u0000\u07f8\u07e9\u0001\u0000\u0000\u0000" + + "\u07f8\u07ea\u0001\u0000\u0000\u0000\u07f8\u07ee\u0001\u0000\u0000\u0000" + + "\u07f8\u07f3\u0001\u0000\u0000\u0000\u07f9\u0171\u0001\u0000\u0000\u0000" + + "\u07fa\u0801\u0003\u0174\u00ba\u0000\u07fb\u0801\u0005Z\u0000\u0000\u07fc" + + "\u07fd\u0005*\u0000\u0000\u07fd\u07fe\u0003\u0172\u00b9\u0000\u07fe\u07ff" + + "\u0005-\u0000\u0000\u07ff\u0801\u0001\u0000\u0000\u0000\u0800\u07fa\u0001" + + "\u0000\u0000\u0000\u0800\u07fb\u0001\u0000\u0000\u0000\u0800\u07fc\u0001" + + "\u0000\u0000\u0000\u0801\u0173\u0001\u0000\u0000\u0000\u0802\u0809\u0003" + + "\u0176\u00bb\u0000\u0803\u0804\u00050\u0000\u0000\u0804\u080a\u0005Z\u0000" + + "\u0000\u0805\u0806\u0005+\u0000\u0000\u0806\u0807\u0003\u0112\u0089\u0000" + + "\u0807\u0808\u0005.\u0000\u0000\u0808\u080a\u0001\u0000\u0000\u0000\u0809" + + "\u0803\u0001\u0000\u0000\u0000\u0809\u0805\u0001\u0000\u0000\u0000\u080a" + + "\u0175\u0001\u0000\u0000\u0000\u080b\u080c\u0006\u00bb\uffff\uffff\u0000" + + "\u080c\u080d\u0003\u0116\u008b\u0000\u080d\u081f\u0001\u0000\u0000\u0000" + + "\u080e\u081b\n\u0002\u0000\u0000\u080f\u0810\u00050\u0000\u0000\u0810" + + "\u081c\u0005Z\u0000\u0000\u0811\u0812\u0005+\u0000\u0000\u0812\u0813\u0003" + + "\u0112\u0089\u0000\u0813\u0814\u0005.\u0000\u0000\u0814\u081c\u0001\u0000" + + "\u0000\u0000\u0815\u081c\u0003\u0156\u00ab\u0000\u0816\u0818\u0005*\u0000" + + "\u0000\u0817\u0819\u0003\u015a\u00ad\u0000\u0818\u0817\u0001\u0000\u0000" + + "\u0000\u0818\u0819\u0001\u0000\u0000\u0000\u0819\u081a\u0001\u0000\u0000" + + "\u0000\u081a\u081c\u0005-\u0000\u0000\u081b\u080f\u0001\u0000\u0000\u0000" + + "\u081b\u0811\u0001\u0000\u0000\u0000\u081b\u0815\u0001\u0000\u0000\u0000" + + "\u081b\u0816\u0001\u0000\u0000\u0000\u081c\u081e\u0001\u0000\u0000\u0000" + + "\u081d\u080e\u0001\u0000\u0000\u0000\u081e\u0821\u0001\u0000\u0000\u0000" + + "\u081f\u081d\u0001\u0000\u0000\u0000\u081f\u0820\u0001\u0000\u0000\u0000" + + "\u0820\u0177\u0001\u0000\u0000\u0000\u0821\u081f\u0001\u0000\u0000\u0000" + + "\u0822\u0827\u0003\u017a\u00bd\u0000\u0823\u0824\u00052\u0000\u0000\u0824" + + "\u0826\u0003\u017a\u00bd\u0000\u0825\u0823\u0001\u0000\u0000\u0000\u0826" + + "\u0829\u0001\u0000\u0000\u0000\u0827\u0825\u0001\u0000\u0000\u0000\u0827" + + "\u0828\u0001\u0000\u0000\u0000\u0828\u082b\u0001\u0000\u0000\u0000\u0829" + + "\u0827\u0001\u0000\u0000\u0000\u082a\u082c\u00052\u0000\u0000\u082b\u082a" + + "\u0001\u0000\u0000\u0000\u082b\u082c\u0001\u0000\u0000\u0000\u082c\u0179" + + "\u0001\u0000\u0000\u0000\u082d\u0834\u0003\u0176\u00bb\u0000\u082e\u082f" + + "\u00050\u0000\u0000\u082f\u0835\u0005Z\u0000\u0000\u0830\u0831\u0005+" + + "\u0000\u0000\u0831\u0832\u0003\u0112\u0089\u0000\u0832\u0833\u0005.\u0000" + + "\u0000\u0833\u0835\u0001\u0000\u0000\u0000\u0834\u082e\u0001\u0000\u0000" + + "\u0000\u0834\u0830\u0001\u0000\u0000\u0000\u0835\u0838\u0001\u0000\u0000" + + "\u0000\u0836\u0838\u0003\u017c\u00be\u0000\u0837\u082d\u0001\u0000\u0000" + + "\u0000\u0837\u0836\u0001\u0000\u0000\u0000\u0838\u017b\u0001\u0000\u0000" + + "\u0000\u0839\u0849\u0005Z\u0000\u0000\u083a\u083b\u0005*\u0000\u0000\u083b" + + "\u083c\u0003\u017a\u00bd\u0000\u083c\u083d\u0005-\u0000\u0000\u083d\u0849" + + "\u0001\u0000\u0000\u0000\u083e\u0840\u0005*\u0000\u0000\u083f\u0841\u0003" + + "\u0178\u00bc\u0000\u0840\u083f\u0001\u0000\u0000\u0000\u0840\u0841\u0001" + + "\u0000\u0000\u0000\u0841\u0842\u0001\u0000\u0000\u0000\u0842\u0849\u0005" + + "-\u0000\u0000\u0843\u0845\u0005+\u0000\u0000\u0844\u0846\u0003\u0178\u00bc" + + "\u0000\u0845\u0844\u0001\u0000\u0000\u0000\u0845\u0846\u0001\u0000\u0000" + + "\u0000\u0846\u0847\u0001\u0000\u0000\u0000\u0847\u0849\u0005.\u0000\u0000" + + "\u0848\u0839\u0001\u0000\u0000\u0000\u0848\u083a\u0001\u0000\u0000\u0000" + + "\u0848\u083e\u0001\u0000\u0000\u0000\u0848\u0843\u0001\u0000\u0000\u0000" + + "\u0849\u017d\u0001\u0000\u0000\u0000\u084a\u084f\u0003\u00d0h\u0000\u084b" + + "\u084c\u00052\u0000\u0000\u084c\u084e\u0003\u00d0h\u0000\u084d\u084b\u0001" + + "\u0000\u0000\u0000\u084e\u0851\u0001\u0000\u0000\u0000\u084f\u084d\u0001" + + "\u0000\u0000\u0000\u084f\u0850\u0001\u0000\u0000\u0000\u0850\u085e\u0001" + + "\u0000\u0000\u0000\u0851\u084f\u0001\u0000\u0000\u0000\u0852\u085c\u0005" + + "2\u0000\u0000\u0853\u0854\u00056\u0000\u0000\u0854\u0858\u0003\u00d0h" + + "\u0000\u0855\u0856\u00052\u0000\u0000\u0856\u0857\u0005F\u0000\u0000\u0857" + + "\u0859\u0003\u00d0h\u0000\u0858\u0855\u0001\u0000\u0000\u0000\u0858\u0859" + + "\u0001\u0000\u0000\u0000\u0859\u085d\u0001\u0000\u0000\u0000\u085a\u085b" + + "\u0005F\u0000\u0000\u085b\u085d\u0003\u00d0h\u0000\u085c\u0853\u0001\u0000" + + "\u0000\u0000\u085c\u085a\u0001\u0000\u0000\u0000\u085d\u085f\u0001\u0000" + + "\u0000\u0000\u085e\u0852\u0001\u0000\u0000\u0000\u085e\u085f\u0001\u0000" + + "\u0000\u0000\u085f\u086a\u0001\u0000\u0000\u0000\u0860\u0861\u00056\u0000" + + "\u0000\u0861\u0865\u0003\u00d0h\u0000\u0862\u0863\u00052\u0000\u0000\u0863" + + "\u0864\u0005F\u0000\u0000\u0864\u0866\u0003\u00d0h\u0000\u0865\u0862\u0001" + + "\u0000\u0000\u0000\u0865\u0866\u0001\u0000\u0000\u0000\u0866\u086a\u0001" + + "\u0000\u0000\u0000\u0867\u0868\u0005F\u0000\u0000\u0868\u086a\u0003\u00d0" + + "h\u0000\u0869\u084a\u0001\u0000\u0000\u0000\u0869\u0860\u0001\u0000\u0000" + + "\u0000\u0869\u0867\u0001\u0000\u0000\u0000\u086a\u017f\u0001\u0000\u0000" + + "\u0000\u086b\u086c\u0005]\u0000\u0000\u086c\u086f\u0005\u0003\u0000\u0000" + + "\u086d\u086f\u0005\u0003\u0000\u0000\u086e\u086b\u0001\u0000\u0000\u0000" + + "\u086e\u086d\u0001\u0000\u0000\u0000\u086f\u0181\u0001\u0000\u0000\u0000" + + "\u0870\u0871\u0004\u00c1\t\u0000\u0871\u0872\u0005Z\u0000\u0000\u0872" + + "\u0183\u0001\u0000\u0000\u0000\u0873\u0874\u0004\u00c2\n\u0000\u0874\u0875" + + "\u0005Z\u0000\u0000\u0875\u0185\u0001\u0000\u0000\u0000\u0876\u0877\u0004" + + "\u00c3\u000b\u0000\u0877\u0878\u0005Z\u0000\u0000\u0878\u0187\u0001\u0000" + + "\u0000\u0000\u0879\u087a\u0004\u00c4\f\u0000\u087a\u087b\u0005Z\u0000" + + "\u0000\u087b\u0189\u0001\u0000\u0000\u0000\u087c\u087d\u0004\u00c5\r\u0000" + + "\u087d\u087e\u0005Z\u0000\u0000\u087e\u018b\u0001\u0000\u0000\u0000\u0120" + + "\u018d\u0197\u019e\u01a6\u01b0\u01b4\u01bc\u01c3\u01c7\u01d9\u01e3\u01ea" + + "\u01f1\u01f7\u01fe\u0202\u0205\u020b\u020d\u0211\u0217\u021d\u021f\u0227" + + "\u0230\u023c\u0240\u0249\u0254\u0258\u025d\u0263\u026a\u0270\u0277\u027d" + + "\u0287\u0290\u0298\u029e\u02a3\u02a7\u02aa\u02b3\u02b8\u02bc\u02c1\u02c5" + + "\u02cc\u02d0\u02d5\u02d9\u02dc\u02e4\u02ea\u02ee\u02f4\u02f8\u02fd\u0302" + + "\u0306\u030b\u030e\u0311\u0316\u031a\u031f\u0325\u0329\u0330\u0334\u033b" + + "\u033f\u0346\u0349\u034c\u0353\u0356\u035a\u035d\u0362\u0365\u0369\u036c" + + "\u036f\u0373\u0387\u0389\u0391\u0393\u039e\u03a1\u03a9\u03ad\u03b0\u03b9" + + "\u03bd\u03c7\u03cc\u03ce\u03d5\u03e2\u03e5\u03e8\u03f0\u03f3\u03f6\u03f8" + + "\u03fe\u0400\u040a\u041b\u0422\u0425\u042a\u0434\u0438\u0443\u044e\u0456" + + "\u045e\u0465\u046a\u047f\u0486\u048f\u0494\u0497\u049c\u04a3\u04a7\u04ab" + + "\u04b5\u04bd\u04c0\u04c4\u04cb\u04d0\u04dd\u04e0\u04e3\u04e5\u04ee\u04f6" + + "\u0500\u050e\u0512\u0516\u051c\u0526\u052a\u0532\u0535\u053b\u053d\u0544" + + "\u0548\u054d\u0554\u0558\u055d\u0565\u056c\u0574\u057a\u0580\u058d\u05b7" + + "\u05c2\u05cd\u05d8\u05e3\u05ee\u05f8\u05fd\u0602\u060d\u0614\u0618\u061e" + + "\u0623\u0627\u062b\u062d\u0630\u0634\u0638\u063a\u063d\u0648\u064c\u0652" + + "\u0655\u065a\u0660\u066b\u0671\u0675\u067b\u067f\u0684\u0689\u068d\u0692" + + "\u0695\u0698\u069d\u06a1\u06a6\u06ac\u06b0\u06b7\u06bb\u06c2\u06c5\u06c8" + + "\u06cf\u06d4\u06d8\u06db\u06e1\u06e6\u06e9\u06ec\u06ef\u06fa\u06ff\u0705" + + "\u070e\u0710\u0714\u071c\u071e\u0728\u0731\u0735\u073a\u0743\u0746\u0750" + + "\u0760\u076c\u0771\u0773\u0779\u077b\u077f\u0784\u0787\u078e\u0797\u079a" + + "\u07a1\u07a4\u07ad\u07b4\u07bb\u07bf\u07c6\u07c9\u07d1\u07d4\u07d6\u07db" + + "\u07e4\u07e7\u07f0\u07f5\u07f8\u0800\u0809\u0818\u081b\u081f\u0827\u082b" + + "\u0834\u0837\u0840\u0845\u0848\u084f\u0858\u085c\u085e\u0865\u0869\u086e"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/PythonParser.tokens b/src/main/java/PythonParser.tokens new file mode 100644 index 0000000..37493cd --- /dev/null +++ b/src/main/java/PythonParser.tokens @@ -0,0 +1,178 @@ +INDENT=1 +DEDENT=2 +TYPE_COMMENT=3 +FSTRING_START=4 +FSTRING_MIDDLE=5 +FSTRING_END=6 +FALSE=7 +AWAIT=8 +ELSE=9 +IMPORT=10 +PASS=11 +NONE=12 +BREAK=13 +EXCEPT=14 +IN=15 +RAISE=16 +TRUE=17 +CLASS=18 +FINALLY=19 +IS=20 +RETURN=21 +AND=22 +CONTINUE=23 +FOR=24 +LAMBDA=25 +TRY=26 +AS=27 +DEF=28 +FROM=29 +NONLOCAL=30 +WHILE=31 +ASSERT=32 +DEL=33 +GLOBAL=34 +NOT=35 +WITH=36 +ASYNC=37 +ELIF=38 +IF=39 +OR=40 +YIELD=41 +LPAR=42 +LSQB=43 +LBRACE=44 +RPAR=45 +RSQB=46 +RBRACE=47 +DOT=48 +COLON=49 +COMMA=50 +SEMI=51 +PLUS=52 +MINUS=53 +STAR=54 +SLASH=55 +VBAR=56 +AMPER=57 +LESS=58 +GREATER=59 +EQUAL=60 +PERCENT=61 +EQEQUAL=62 +NOTEQUAL=63 +LESSEQUAL=64 +GREATEREQUAL=65 +TILDE=66 +CIRCUMFLEX=67 +LEFTSHIFT=68 +RIGHTSHIFT=69 +DOUBLESTAR=70 +PLUSEQUAL=71 +MINEQUAL=72 +STAREQUAL=73 +SLASHEQUAL=74 +PERCENTEQUAL=75 +AMPEREQUAL=76 +VBAREQUAL=77 +CIRCUMFLEXEQUAL=78 +LEFTSHIFTEQUAL=79 +RIGHTSHIFTEQUAL=80 +DOUBLESTAREQUAL=81 +DOUBLESLASH=82 +DOUBLESLASHEQUAL=83 +AT=84 +ATEQUAL=85 +RARROW=86 +ELLIPSIS=87 +COLONEQUAL=88 +EXCLAMATION=89 +NAME=90 +NUMBER=91 +STRING=92 +NEWLINE=93 +COMMENT=94 +WS=95 +EXPLICIT_LINE_JOINING=96 +ERRORTOKEN=97 +'False'=7 +'await'=8 +'else'=9 +'import'=10 +'pass'=11 +'None'=12 +'break'=13 +'except'=14 +'in'=15 +'raise'=16 +'True'=17 +'class'=18 +'finally'=19 +'is'=20 +'return'=21 +'and'=22 +'continue'=23 +'for'=24 +'lambda'=25 +'try'=26 +'as'=27 +'def'=28 +'from'=29 +'nonlocal'=30 +'while'=31 +'assert'=32 +'del'=33 +'global'=34 +'not'=35 +'with'=36 +'async'=37 +'elif'=38 +'if'=39 +'or'=40 +'yield'=41 +'('=42 +'['=43 +')'=45 +']'=46 +'.'=48 +':'=49 +','=50 +';'=51 +'+'=52 +'-'=53 +'*'=54 +'/'=55 +'|'=56 +'&'=57 +'<'=58 +'>'=59 +'='=60 +'%'=61 +'=='=62 +'!='=63 +'<='=64 +'>='=65 +'~'=66 +'^'=67 +'<<'=68 +'>>'=69 +'**'=70 +'+='=71 +'-='=72 +'*='=73 +'/='=74 +'%='=75 +'&='=76 +'|='=77 +'^='=78 +'<<='=79 +'>>='=80 +'**='=81 +'//'=82 +'//='=83 +'@'=84 +'@='=85 +'->'=86 +'...'=87 +':='=88 +'!'=89 diff --git a/src/main/java/PythonParserBase.java b/src/main/java/PythonParserBase.java new file mode 100644 index 0000000..d3a7ebf --- /dev/null +++ b/src/main/java/PythonParserBase.java @@ -0,0 +1,17 @@ +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.TokenStream; + +public abstract class PythonParserBase extends Parser { + protected PythonParserBase(TokenStream input) { + super(input); + } + + // https://docs.python.org/3/reference/lexical_analysis.html#soft-keywords + public boolean isEqualToCurrentTokenText(String tokenText) { + return this.getCurrentToken().getText().equals(tokenText); + } + + public boolean isnotEqualToCurrentTokenText(String tokenText) { + return !this.isEqualToCurrentTokenText(tokenText); // for compatibility with the Python 'not' logical operator + } +} diff --git a/src/main/java/PythonParserBaseListener.java b/src/main/java/PythonParserBaseListener.java new file mode 100644 index 0000000..d8e03a9 --- /dev/null +++ b/src/main/java/PythonParserBaseListener.java @@ -0,0 +1,3613 @@ +// Generated from PythonParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link PythonParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class PythonParserBaseListener implements PythonParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFile_input(PythonParser.File_inputContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFile_input(PythonParser.File_inputContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterInteractive(PythonParser.InteractiveContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitInteractive(PythonParser.InteractiveContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEval(PythonParser.EvalContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEval(PythonParser.EvalContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunc_type(PythonParser.Func_typeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunc_type(PythonParser.Func_typeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_input(PythonParser.Fstring_inputContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_input(PythonParser.Fstring_inputContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStatements(PythonParser.StatementsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStatements(PythonParser.StatementsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStatement(PythonParser.StatementContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStatement(PythonParser.StatementContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStatement_newline(PythonParser.Statement_newlineContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStatement_newline(PythonParser.Statement_newlineContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSimple_stmts(PythonParser.Simple_stmtsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSimple_stmts(PythonParser.Simple_stmtsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSimple_stmt(PythonParser.Simple_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSimple_stmt(PythonParser.Simple_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCompound_stmt(PythonParser.Compound_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCompound_stmt(PythonParser.Compound_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAssignment(PythonParser.AssignmentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAssignment(PythonParser.AssignmentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotated_rhs(PythonParser.Annotated_rhsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotated_rhs(PythonParser.Annotated_rhsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAugassign(PythonParser.AugassignContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAugassign(PythonParser.AugassignContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterReturn_stmt(PythonParser.Return_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitReturn_stmt(PythonParser.Return_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterRaise_stmt(PythonParser.Raise_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitRaise_stmt(PythonParser.Raise_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGlobal_stmt(PythonParser.Global_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGlobal_stmt(PythonParser.Global_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNonlocal_stmt(PythonParser.Nonlocal_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNonlocal_stmt(PythonParser.Nonlocal_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDel_stmt(PythonParser.Del_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDel_stmt(PythonParser.Del_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterYield_stmt(PythonParser.Yield_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitYield_stmt(PythonParser.Yield_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAssert_stmt(PythonParser.Assert_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAssert_stmt(PythonParser.Assert_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_stmt(PythonParser.Import_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_stmt(PythonParser.Import_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_name(PythonParser.Import_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_name(PythonParser.Import_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_from(PythonParser.Import_fromContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_from(PythonParser.Import_fromContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_from_targets(PythonParser.Import_from_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_from_targets(PythonParser.Import_from_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_from_as_names(PythonParser.Import_from_as_namesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_from_as_names(PythonParser.Import_from_as_namesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImport_from_as_name(PythonParser.Import_from_as_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImport_from_as_name(PythonParser.Import_from_as_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDotted_as_names(PythonParser.Dotted_as_namesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDotted_as_names(PythonParser.Dotted_as_namesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDotted_as_name(PythonParser.Dotted_as_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDotted_as_name(PythonParser.Dotted_as_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDotted_name(PythonParser.Dotted_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDotted_name(PythonParser.Dotted_nameContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBlock(PythonParser.BlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBlock(PythonParser.BlockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDecorators(PythonParser.DecoratorsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDecorators(PythonParser.DecoratorsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClass_def(PythonParser.Class_defContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClass_def(PythonParser.Class_defContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClass_def_raw(PythonParser.Class_def_rawContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClass_def_raw(PythonParser.Class_def_rawContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunction_def(PythonParser.Function_defContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunction_def(PythonParser.Function_defContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunction_def_raw(PythonParser.Function_def_rawContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunction_def_raw(PythonParser.Function_def_rawContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParams(PythonParser.ParamsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParams(PythonParser.ParamsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParameters(PythonParser.ParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParameters(PythonParser.ParametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSlash_no_default(PythonParser.Slash_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSlash_no_default(PythonParser.Slash_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSlash_with_default(PythonParser.Slash_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSlash_with_default(PythonParser.Slash_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_etc(PythonParser.Star_etcContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_etc(PythonParser.Star_etcContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKwds(PythonParser.KwdsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKwds(PythonParser.KwdsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam_no_default(PythonParser.Param_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam_no_default(PythonParser.Param_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam_no_default_star_annotation(PythonParser.Param_no_default_star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam_no_default_star_annotation(PythonParser.Param_no_default_star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam_with_default(PythonParser.Param_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam_with_default(PythonParser.Param_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam_maybe_default(PythonParser.Param_maybe_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam_maybe_default(PythonParser.Param_maybe_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam(PythonParser.ParamContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam(PythonParser.ParamContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterParam_star_annotation(PythonParser.Param_star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitParam_star_annotation(PythonParser.Param_star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAnnotation(PythonParser.AnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAnnotation(PythonParser.AnnotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_annotation(PythonParser.Star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_annotation(PythonParser.Star_annotationContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDefault_assignment(PythonParser.Default_assignmentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDefault_assignment(PythonParser.Default_assignmentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIf_stmt(PythonParser.If_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIf_stmt(PythonParser.If_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterElif_stmt(PythonParser.Elif_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitElif_stmt(PythonParser.Elif_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterElse_block(PythonParser.Else_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitElse_block(PythonParser.Else_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWhile_stmt(PythonParser.While_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWhile_stmt(PythonParser.While_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFor_stmt(PythonParser.For_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFor_stmt(PythonParser.For_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWith_stmt(PythonParser.With_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWith_stmt(PythonParser.With_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWith_item(PythonParser.With_itemContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWith_item(PythonParser.With_itemContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTry_stmt(PythonParser.Try_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTry_stmt(PythonParser.Try_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExcept_block(PythonParser.Except_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExcept_block(PythonParser.Except_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExcept_star_block(PythonParser.Except_star_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExcept_star_block(PythonParser.Except_star_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFinally_block(PythonParser.Finally_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFinally_block(PythonParser.Finally_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMatch_stmt(PythonParser.Match_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMatch_stmt(PythonParser.Match_stmtContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSubject_expr(PythonParser.Subject_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSubject_expr(PythonParser.Subject_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCase_block(PythonParser.Case_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCase_block(PythonParser.Case_blockContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGuard(PythonParser.GuardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGuard(PythonParser.GuardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPatterns(PythonParser.PatternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPatterns(PythonParser.PatternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPattern(PythonParser.PatternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPattern(PythonParser.PatternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAs_pattern(PythonParser.As_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAs_pattern(PythonParser.As_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterOr_pattern(PythonParser.Or_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitOr_pattern(PythonParser.Or_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClosed_pattern(PythonParser.Closed_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClosed_pattern(PythonParser.Closed_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLiteral_pattern(PythonParser.Literal_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLiteral_pattern(PythonParser.Literal_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLiteral_expr(PythonParser.Literal_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLiteral_expr(PythonParser.Literal_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterComplex_number(PythonParser.Complex_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitComplex_number(PythonParser.Complex_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSigned_number(PythonParser.Signed_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSigned_number(PythonParser.Signed_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSigned_real_number(PythonParser.Signed_real_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSigned_real_number(PythonParser.Signed_real_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterReal_number(PythonParser.Real_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitReal_number(PythonParser.Real_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterImaginary_number(PythonParser.Imaginary_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitImaginary_number(PythonParser.Imaginary_numberContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCapture_pattern(PythonParser.Capture_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCapture_pattern(PythonParser.Capture_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPattern_capture_target(PythonParser.Pattern_capture_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPattern_capture_target(PythonParser.Pattern_capture_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterWildcard_pattern(PythonParser.Wildcard_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitWildcard_pattern(PythonParser.Wildcard_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterValue_pattern(PythonParser.Value_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitValue_pattern(PythonParser.Value_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAttr(PythonParser.AttrContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAttr(PythonParser.AttrContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterName_or_attr(PythonParser.Name_or_attrContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitName_or_attr(PythonParser.Name_or_attrContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGroup_pattern(PythonParser.Group_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGroup_pattern(PythonParser.Group_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSequence_pattern(PythonParser.Sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSequence_pattern(PythonParser.Sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterOpen_sequence_pattern(PythonParser.Open_sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitOpen_sequence_pattern(PythonParser.Open_sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMaybe_sequence_pattern(PythonParser.Maybe_sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMaybe_sequence_pattern(PythonParser.Maybe_sequence_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMaybe_star_pattern(PythonParser.Maybe_star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMaybe_star_pattern(PythonParser.Maybe_star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_pattern(PythonParser.Star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_pattern(PythonParser.Star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterMapping_pattern(PythonParser.Mapping_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitMapping_pattern(PythonParser.Mapping_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterItems_pattern(PythonParser.Items_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitItems_pattern(PythonParser.Items_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKey_value_pattern(PythonParser.Key_value_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKey_value_pattern(PythonParser.Key_value_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDouble_star_pattern(PythonParser.Double_star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDouble_star_pattern(PythonParser.Double_star_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterClass_pattern(PythonParser.Class_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitClass_pattern(PythonParser.Class_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPositional_patterns(PythonParser.Positional_patternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPositional_patterns(PythonParser.Positional_patternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKeyword_patterns(PythonParser.Keyword_patternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKeyword_patterns(PythonParser.Keyword_patternsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKeyword_pattern(PythonParser.Keyword_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKeyword_pattern(PythonParser.Keyword_patternContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_alias(PythonParser.Type_aliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_alias(PythonParser.Type_aliasContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_params(PythonParser.Type_paramsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_params(PythonParser.Type_paramsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_param_seq(PythonParser.Type_param_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_param_seq(PythonParser.Type_param_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_param(PythonParser.Type_paramContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_param(PythonParser.Type_paramContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_param_bound(PythonParser.Type_param_boundContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_param_bound(PythonParser.Type_param_boundContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExpressions(PythonParser.ExpressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExpressions(PythonParser.ExpressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterExpression(PythonParser.ExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitExpression(PythonParser.ExpressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterYield_expr(PythonParser.Yield_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitYield_expr(PythonParser.Yield_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_expressions(PythonParser.Star_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_expressions(PythonParser.Star_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_expression(PythonParser.Star_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_expression(PythonParser.Star_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_named_expressions(PythonParser.Star_named_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_named_expressions(PythonParser.Star_named_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_named_expression(PythonParser.Star_named_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_named_expression(PythonParser.Star_named_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAssignment_expression(PythonParser.Assignment_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAssignment_expression(PythonParser.Assignment_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNamed_expression(PythonParser.Named_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNamed_expression(PythonParser.Named_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDisjunction(PythonParser.DisjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDisjunction(PythonParser.DisjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterConjunction(PythonParser.ConjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitConjunction(PythonParser.ConjunctionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterInversion(PythonParser.InversionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitInversion(PythonParser.InversionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterComparison(PythonParser.ComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitComparison(PythonParser.ComparisonContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterCompare_op_bitwise_or_pair(PythonParser.Compare_op_bitwise_or_pairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitCompare_op_bitwise_or_pair(PythonParser.Compare_op_bitwise_or_pairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEq_bitwise_or(PythonParser.Eq_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEq_bitwise_or(PythonParser.Eq_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNoteq_bitwise_or(PythonParser.Noteq_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNoteq_bitwise_or(PythonParser.Noteq_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLte_bitwise_or(PythonParser.Lte_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLte_bitwise_or(PythonParser.Lte_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLt_bitwise_or(PythonParser.Lt_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLt_bitwise_or(PythonParser.Lt_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGte_bitwise_or(PythonParser.Gte_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGte_bitwise_or(PythonParser.Gte_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGt_bitwise_or(PythonParser.Gt_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGt_bitwise_or(PythonParser.Gt_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterNotin_bitwise_or(PythonParser.Notin_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitNotin_bitwise_or(PythonParser.Notin_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIn_bitwise_or(PythonParser.In_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIn_bitwise_or(PythonParser.In_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIsnot_bitwise_or(PythonParser.Isnot_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIsnot_bitwise_or(PythonParser.Isnot_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterIs_bitwise_or(PythonParser.Is_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitIs_bitwise_or(PythonParser.Is_bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBitwise_or(PythonParser.Bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBitwise_or(PythonParser.Bitwise_orContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBitwise_xor(PythonParser.Bitwise_xorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBitwise_xor(PythonParser.Bitwise_xorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterBitwise_and(PythonParser.Bitwise_andContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitBitwise_and(PythonParser.Bitwise_andContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterShift_expr(PythonParser.Shift_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitShift_expr(PythonParser.Shift_exprContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSum(PythonParser.SumContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSum(PythonParser.SumContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTerm(PythonParser.TermContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTerm(PythonParser.TermContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFactor(PythonParser.FactorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFactor(PythonParser.FactorContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPower(PythonParser.PowerContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPower(PythonParser.PowerContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAwait_primary(PythonParser.Await_primaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAwait_primary(PythonParser.Await_primaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterPrimary(PythonParser.PrimaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitPrimary(PythonParser.PrimaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSlices(PythonParser.SlicesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSlices(PythonParser.SlicesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSlice(PythonParser.SliceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSlice(PythonParser.SliceContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterAtom(PythonParser.AtomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitAtom(PythonParser.AtomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGroup(PythonParser.GroupContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGroup(PythonParser.GroupContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambdef(PythonParser.LambdefContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambdef(PythonParser.LambdefContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_params(PythonParser.Lambda_paramsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_params(PythonParser.Lambda_paramsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_parameters(PythonParser.Lambda_parametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_parameters(PythonParser.Lambda_parametersContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_slash_no_default(PythonParser.Lambda_slash_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_slash_no_default(PythonParser.Lambda_slash_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_slash_with_default(PythonParser.Lambda_slash_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_slash_with_default(PythonParser.Lambda_slash_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_star_etc(PythonParser.Lambda_star_etcContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_star_etc(PythonParser.Lambda_star_etcContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_kwds(PythonParser.Lambda_kwdsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_kwds(PythonParser.Lambda_kwdsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_param_no_default(PythonParser.Lambda_param_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_param_no_default(PythonParser.Lambda_param_no_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_param_with_default(PythonParser.Lambda_param_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_param_with_default(PythonParser.Lambda_param_with_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_param_maybe_default(PythonParser.Lambda_param_maybe_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_param_maybe_default(PythonParser.Lambda_param_maybe_defaultContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterLambda_param(PythonParser.Lambda_paramContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitLambda_param(PythonParser.Lambda_paramContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_middle(PythonParser.Fstring_middleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_middle(PythonParser.Fstring_middleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_replacement_field(PythonParser.Fstring_replacement_fieldContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_replacement_field(PythonParser.Fstring_replacement_fieldContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_conversion(PythonParser.Fstring_conversionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_conversion(PythonParser.Fstring_conversionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_full_format_spec(PythonParser.Fstring_full_format_specContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_full_format_spec(PythonParser.Fstring_full_format_specContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring_format_spec(PythonParser.Fstring_format_specContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring_format_spec(PythonParser.Fstring_format_specContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFstring(PythonParser.FstringContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFstring(PythonParser.FstringContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterString(PythonParser.StringContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitString(PythonParser.StringContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStrings(PythonParser.StringsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStrings(PythonParser.StringsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterList(PythonParser.ListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitList(PythonParser.ListContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTuple(PythonParser.TupleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTuple(PythonParser.TupleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSet(PythonParser.SetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSet(PythonParser.SetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDict(PythonParser.DictContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDict(PythonParser.DictContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDouble_starred_kvpairs(PythonParser.Double_starred_kvpairsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDouble_starred_kvpairs(PythonParser.Double_starred_kvpairsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDouble_starred_kvpair(PythonParser.Double_starred_kvpairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDouble_starred_kvpair(PythonParser.Double_starred_kvpairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKvpair(PythonParser.KvpairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKvpair(PythonParser.KvpairContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFor_if_clauses(PythonParser.For_if_clausesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFor_if_clauses(PythonParser.For_if_clausesContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFor_if_clause(PythonParser.For_if_clauseContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFor_if_clause(PythonParser.For_if_clauseContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterListcomp(PythonParser.ListcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitListcomp(PythonParser.ListcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSetcomp(PythonParser.SetcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSetcomp(PythonParser.SetcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterGenexp(PythonParser.GenexpContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitGenexp(PythonParser.GenexpContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDictcomp(PythonParser.DictcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDictcomp(PythonParser.DictcompContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterArguments(PythonParser.ArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitArguments(PythonParser.ArgumentsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterArgs(PythonParser.ArgsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitArgs(PythonParser.ArgsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKwargs(PythonParser.KwargsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKwargs(PythonParser.KwargsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStarred_expression(PythonParser.Starred_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStarred_expression(PythonParser.Starred_expressionContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKwarg_or_starred(PythonParser.Kwarg_or_starredContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKwarg_or_starred(PythonParser.Kwarg_or_starredContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterKwarg_or_double_starred(PythonParser.Kwarg_or_double_starredContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitKwarg_or_double_starred(PythonParser.Kwarg_or_double_starredContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_targets(PythonParser.Star_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_targets(PythonParser.Star_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_targets_list_seq(PythonParser.Star_targets_list_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_targets_list_seq(PythonParser.Star_targets_list_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_targets_tuple_seq(PythonParser.Star_targets_tuple_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_targets_tuple_seq(PythonParser.Star_targets_tuple_seqContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_target(PythonParser.Star_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_target(PythonParser.Star_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterTarget_with_star_atom(PythonParser.Target_with_star_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitTarget_with_star_atom(PythonParser.Target_with_star_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterStar_atom(PythonParser.Star_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitStar_atom(PythonParser.Star_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSingle_target(PythonParser.Single_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSingle_target(PythonParser.Single_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSingle_subscript_attribute_target(PythonParser.Single_subscript_attribute_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSingle_subscript_attribute_target(PythonParser.Single_subscript_attribute_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterT_primary(PythonParser.T_primaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitT_primary(PythonParser.T_primaryContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDel_targets(PythonParser.Del_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDel_targets(PythonParser.Del_targetsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDel_target(PythonParser.Del_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDel_target(PythonParser.Del_targetContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterDel_t_atom(PythonParser.Del_t_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitDel_t_atom(PythonParser.Del_t_atomContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterType_expressions(PythonParser.Type_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitType_expressions(PythonParser.Type_expressionsContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterFunc_type_comment(PythonParser.Func_type_commentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitFunc_type_comment(PythonParser.Func_type_commentContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSoft_kw_type(PythonParser.Soft_kw_typeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSoft_kw_type(PythonParser.Soft_kw_typeContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSoft_kw_match(PythonParser.Soft_kw_matchContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSoft_kw_match(PythonParser.Soft_kw_matchContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSoft_kw_case(PythonParser.Soft_kw_caseContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSoft_kw_case(PythonParser.Soft_kw_caseContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSoft_kw_wildcard(PythonParser.Soft_kw_wildcardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSoft_kw_wildcard(PythonParser.Soft_kw_wildcardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterSoft_kw__not__wildcard(PythonParser.Soft_kw__not__wildcardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitSoft_kw__not__wildcard(PythonParser.Soft_kw__not__wildcardContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void enterEveryRule(ParserRuleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void exitEveryRule(ParserRuleContext ctx) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void visitTerminal(TerminalNode node) { + } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override + public void visitErrorNode(ErrorNode node) { + } +} \ No newline at end of file diff --git a/src/main/java/PythonParserListener.java b/src/main/java/PythonParserListener.java new file mode 100644 index 0000000..79096f7 --- /dev/null +++ b/src/main/java/PythonParserListener.java @@ -0,0 +1,2781 @@ +// Generated from PythonParser.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link PythonParser}. + */ +public interface PythonParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link PythonParser#file_input}. + * + * @param ctx the parse tree + */ + void enterFile_input(PythonParser.File_inputContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#file_input}. + * + * @param ctx the parse tree + */ + void exitFile_input(PythonParser.File_inputContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#interactive}. + * + * @param ctx the parse tree + */ + void enterInteractive(PythonParser.InteractiveContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#interactive}. + * + * @param ctx the parse tree + */ + void exitInteractive(PythonParser.InteractiveContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#eval}. + * + * @param ctx the parse tree + */ + void enterEval(PythonParser.EvalContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#eval}. + * + * @param ctx the parse tree + */ + void exitEval(PythonParser.EvalContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#func_type}. + * + * @param ctx the parse tree + */ + void enterFunc_type(PythonParser.Func_typeContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#func_type}. + * + * @param ctx the parse tree + */ + void exitFunc_type(PythonParser.Func_typeContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_input}. + * + * @param ctx the parse tree + */ + void enterFstring_input(PythonParser.Fstring_inputContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_input}. + * + * @param ctx the parse tree + */ + void exitFstring_input(PythonParser.Fstring_inputContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#statements}. + * + * @param ctx the parse tree + */ + void enterStatements(PythonParser.StatementsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#statements}. + * + * @param ctx the parse tree + */ + void exitStatements(PythonParser.StatementsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#statement}. + * + * @param ctx the parse tree + */ + void enterStatement(PythonParser.StatementContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#statement}. + * + * @param ctx the parse tree + */ + void exitStatement(PythonParser.StatementContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#statement_newline}. + * + * @param ctx the parse tree + */ + void enterStatement_newline(PythonParser.Statement_newlineContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#statement_newline}. + * + * @param ctx the parse tree + */ + void exitStatement_newline(PythonParser.Statement_newlineContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#simple_stmts}. + * + * @param ctx the parse tree + */ + void enterSimple_stmts(PythonParser.Simple_stmtsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#simple_stmts}. + * + * @param ctx the parse tree + */ + void exitSimple_stmts(PythonParser.Simple_stmtsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#simple_stmt}. + * + * @param ctx the parse tree + */ + void enterSimple_stmt(PythonParser.Simple_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#simple_stmt}. + * + * @param ctx the parse tree + */ + void exitSimple_stmt(PythonParser.Simple_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#compound_stmt}. + * + * @param ctx the parse tree + */ + void enterCompound_stmt(PythonParser.Compound_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#compound_stmt}. + * + * @param ctx the parse tree + */ + void exitCompound_stmt(PythonParser.Compound_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#assignment}. + * + * @param ctx the parse tree + */ + void enterAssignment(PythonParser.AssignmentContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#assignment}. + * + * @param ctx the parse tree + */ + void exitAssignment(PythonParser.AssignmentContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#annotated_rhs}. + * + * @param ctx the parse tree + */ + void enterAnnotated_rhs(PythonParser.Annotated_rhsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#annotated_rhs}. + * + * @param ctx the parse tree + */ + void exitAnnotated_rhs(PythonParser.Annotated_rhsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#augassign}. + * + * @param ctx the parse tree + */ + void enterAugassign(PythonParser.AugassignContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#augassign}. + * + * @param ctx the parse tree + */ + void exitAugassign(PythonParser.AugassignContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#return_stmt}. + * + * @param ctx the parse tree + */ + void enterReturn_stmt(PythonParser.Return_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#return_stmt}. + * + * @param ctx the parse tree + */ + void exitReturn_stmt(PythonParser.Return_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#raise_stmt}. + * + * @param ctx the parse tree + */ + void enterRaise_stmt(PythonParser.Raise_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#raise_stmt}. + * + * @param ctx the parse tree + */ + void exitRaise_stmt(PythonParser.Raise_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#global_stmt}. + * + * @param ctx the parse tree + */ + void enterGlobal_stmt(PythonParser.Global_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#global_stmt}. + * + * @param ctx the parse tree + */ + void exitGlobal_stmt(PythonParser.Global_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#nonlocal_stmt}. + * + * @param ctx the parse tree + */ + void enterNonlocal_stmt(PythonParser.Nonlocal_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#nonlocal_stmt}. + * + * @param ctx the parse tree + */ + void exitNonlocal_stmt(PythonParser.Nonlocal_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#del_stmt}. + * + * @param ctx the parse tree + */ + void enterDel_stmt(PythonParser.Del_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#del_stmt}. + * + * @param ctx the parse tree + */ + void exitDel_stmt(PythonParser.Del_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#yield_stmt}. + * + * @param ctx the parse tree + */ + void enterYield_stmt(PythonParser.Yield_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#yield_stmt}. + * + * @param ctx the parse tree + */ + void exitYield_stmt(PythonParser.Yield_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#assert_stmt}. + * + * @param ctx the parse tree + */ + void enterAssert_stmt(PythonParser.Assert_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#assert_stmt}. + * + * @param ctx the parse tree + */ + void exitAssert_stmt(PythonParser.Assert_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_stmt}. + * + * @param ctx the parse tree + */ + void enterImport_stmt(PythonParser.Import_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_stmt}. + * + * @param ctx the parse tree + */ + void exitImport_stmt(PythonParser.Import_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_name}. + * + * @param ctx the parse tree + */ + void enterImport_name(PythonParser.Import_nameContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_name}. + * + * @param ctx the parse tree + */ + void exitImport_name(PythonParser.Import_nameContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_from}. + * + * @param ctx the parse tree + */ + void enterImport_from(PythonParser.Import_fromContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_from}. + * + * @param ctx the parse tree + */ + void exitImport_from(PythonParser.Import_fromContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_from_targets}. + * + * @param ctx the parse tree + */ + void enterImport_from_targets(PythonParser.Import_from_targetsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_from_targets}. + * + * @param ctx the parse tree + */ + void exitImport_from_targets(PythonParser.Import_from_targetsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_from_as_names}. + * + * @param ctx the parse tree + */ + void enterImport_from_as_names(PythonParser.Import_from_as_namesContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_from_as_names}. + * + * @param ctx the parse tree + */ + void exitImport_from_as_names(PythonParser.Import_from_as_namesContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#import_from_as_name}. + * + * @param ctx the parse tree + */ + void enterImport_from_as_name(PythonParser.Import_from_as_nameContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#import_from_as_name}. + * + * @param ctx the parse tree + */ + void exitImport_from_as_name(PythonParser.Import_from_as_nameContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#dotted_as_names}. + * + * @param ctx the parse tree + */ + void enterDotted_as_names(PythonParser.Dotted_as_namesContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#dotted_as_names}. + * + * @param ctx the parse tree + */ + void exitDotted_as_names(PythonParser.Dotted_as_namesContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#dotted_as_name}. + * + * @param ctx the parse tree + */ + void enterDotted_as_name(PythonParser.Dotted_as_nameContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#dotted_as_name}. + * + * @param ctx the parse tree + */ + void exitDotted_as_name(PythonParser.Dotted_as_nameContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#dotted_name}. + * + * @param ctx the parse tree + */ + void enterDotted_name(PythonParser.Dotted_nameContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#dotted_name}. + * + * @param ctx the parse tree + */ + void exitDotted_name(PythonParser.Dotted_nameContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#block}. + * + * @param ctx the parse tree + */ + void enterBlock(PythonParser.BlockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#block}. + * + * @param ctx the parse tree + */ + void exitBlock(PythonParser.BlockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#decorators}. + * + * @param ctx the parse tree + */ + void enterDecorators(PythonParser.DecoratorsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#decorators}. + * + * @param ctx the parse tree + */ + void exitDecorators(PythonParser.DecoratorsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#class_def}. + * + * @param ctx the parse tree + */ + void enterClass_def(PythonParser.Class_defContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#class_def}. + * + * @param ctx the parse tree + */ + void exitClass_def(PythonParser.Class_defContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#class_def_raw}. + * + * @param ctx the parse tree + */ + void enterClass_def_raw(PythonParser.Class_def_rawContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#class_def_raw}. + * + * @param ctx the parse tree + */ + void exitClass_def_raw(PythonParser.Class_def_rawContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#function_def}. + * + * @param ctx the parse tree + */ + void enterFunction_def(PythonParser.Function_defContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#function_def}. + * + * @param ctx the parse tree + */ + void exitFunction_def(PythonParser.Function_defContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#function_def_raw}. + * + * @param ctx the parse tree + */ + void enterFunction_def_raw(PythonParser.Function_def_rawContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#function_def_raw}. + * + * @param ctx the parse tree + */ + void exitFunction_def_raw(PythonParser.Function_def_rawContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#params}. + * + * @param ctx the parse tree + */ + void enterParams(PythonParser.ParamsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#params}. + * + * @param ctx the parse tree + */ + void exitParams(PythonParser.ParamsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#parameters}. + * + * @param ctx the parse tree + */ + void enterParameters(PythonParser.ParametersContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#parameters}. + * + * @param ctx the parse tree + */ + void exitParameters(PythonParser.ParametersContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#slash_no_default}. + * + * @param ctx the parse tree + */ + void enterSlash_no_default(PythonParser.Slash_no_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#slash_no_default}. + * + * @param ctx the parse tree + */ + void exitSlash_no_default(PythonParser.Slash_no_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#slash_with_default}. + * + * @param ctx the parse tree + */ + void enterSlash_with_default(PythonParser.Slash_with_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#slash_with_default}. + * + * @param ctx the parse tree + */ + void exitSlash_with_default(PythonParser.Slash_with_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_etc}. + * + * @param ctx the parse tree + */ + void enterStar_etc(PythonParser.Star_etcContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_etc}. + * + * @param ctx the parse tree + */ + void exitStar_etc(PythonParser.Star_etcContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#kwds}. + * + * @param ctx the parse tree + */ + void enterKwds(PythonParser.KwdsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#kwds}. + * + * @param ctx the parse tree + */ + void exitKwds(PythonParser.KwdsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param_no_default}. + * + * @param ctx the parse tree + */ + void enterParam_no_default(PythonParser.Param_no_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param_no_default}. + * + * @param ctx the parse tree + */ + void exitParam_no_default(PythonParser.Param_no_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param_no_default_star_annotation}. + * + * @param ctx the parse tree + */ + void enterParam_no_default_star_annotation(PythonParser.Param_no_default_star_annotationContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param_no_default_star_annotation}. + * + * @param ctx the parse tree + */ + void exitParam_no_default_star_annotation(PythonParser.Param_no_default_star_annotationContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param_with_default}. + * + * @param ctx the parse tree + */ + void enterParam_with_default(PythonParser.Param_with_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param_with_default}. + * + * @param ctx the parse tree + */ + void exitParam_with_default(PythonParser.Param_with_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param_maybe_default}. + * + * @param ctx the parse tree + */ + void enterParam_maybe_default(PythonParser.Param_maybe_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param_maybe_default}. + * + * @param ctx the parse tree + */ + void exitParam_maybe_default(PythonParser.Param_maybe_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param}. + * + * @param ctx the parse tree + */ + void enterParam(PythonParser.ParamContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param}. + * + * @param ctx the parse tree + */ + void exitParam(PythonParser.ParamContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#param_star_annotation}. + * + * @param ctx the parse tree + */ + void enterParam_star_annotation(PythonParser.Param_star_annotationContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#param_star_annotation}. + * + * @param ctx the parse tree + */ + void exitParam_star_annotation(PythonParser.Param_star_annotationContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#annotation}. + * + * @param ctx the parse tree + */ + void enterAnnotation(PythonParser.AnnotationContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#annotation}. + * + * @param ctx the parse tree + */ + void exitAnnotation(PythonParser.AnnotationContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_annotation}. + * + * @param ctx the parse tree + */ + void enterStar_annotation(PythonParser.Star_annotationContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_annotation}. + * + * @param ctx the parse tree + */ + void exitStar_annotation(PythonParser.Star_annotationContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#default_assignment}. + * + * @param ctx the parse tree + */ + void enterDefault_assignment(PythonParser.Default_assignmentContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#default_assignment}. + * + * @param ctx the parse tree + */ + void exitDefault_assignment(PythonParser.Default_assignmentContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#if_stmt}. + * + * @param ctx the parse tree + */ + void enterIf_stmt(PythonParser.If_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#if_stmt}. + * + * @param ctx the parse tree + */ + void exitIf_stmt(PythonParser.If_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#elif_stmt}. + * + * @param ctx the parse tree + */ + void enterElif_stmt(PythonParser.Elif_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#elif_stmt}. + * + * @param ctx the parse tree + */ + void exitElif_stmt(PythonParser.Elif_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#else_block}. + * + * @param ctx the parse tree + */ + void enterElse_block(PythonParser.Else_blockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#else_block}. + * + * @param ctx the parse tree + */ + void exitElse_block(PythonParser.Else_blockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#while_stmt}. + * + * @param ctx the parse tree + */ + void enterWhile_stmt(PythonParser.While_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#while_stmt}. + * + * @param ctx the parse tree + */ + void exitWhile_stmt(PythonParser.While_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#for_stmt}. + * + * @param ctx the parse tree + */ + void enterFor_stmt(PythonParser.For_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#for_stmt}. + * + * @param ctx the parse tree + */ + void exitFor_stmt(PythonParser.For_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#with_stmt}. + * + * @param ctx the parse tree + */ + void enterWith_stmt(PythonParser.With_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#with_stmt}. + * + * @param ctx the parse tree + */ + void exitWith_stmt(PythonParser.With_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#with_item}. + * + * @param ctx the parse tree + */ + void enterWith_item(PythonParser.With_itemContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#with_item}. + * + * @param ctx the parse tree + */ + void exitWith_item(PythonParser.With_itemContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#try_stmt}. + * + * @param ctx the parse tree + */ + void enterTry_stmt(PythonParser.Try_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#try_stmt}. + * + * @param ctx the parse tree + */ + void exitTry_stmt(PythonParser.Try_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#except_block}. + * + * @param ctx the parse tree + */ + void enterExcept_block(PythonParser.Except_blockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#except_block}. + * + * @param ctx the parse tree + */ + void exitExcept_block(PythonParser.Except_blockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#except_star_block}. + * + * @param ctx the parse tree + */ + void enterExcept_star_block(PythonParser.Except_star_blockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#except_star_block}. + * + * @param ctx the parse tree + */ + void exitExcept_star_block(PythonParser.Except_star_blockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#finally_block}. + * + * @param ctx the parse tree + */ + void enterFinally_block(PythonParser.Finally_blockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#finally_block}. + * + * @param ctx the parse tree + */ + void exitFinally_block(PythonParser.Finally_blockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#match_stmt}. + * + * @param ctx the parse tree + */ + void enterMatch_stmt(PythonParser.Match_stmtContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#match_stmt}. + * + * @param ctx the parse tree + */ + void exitMatch_stmt(PythonParser.Match_stmtContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#subject_expr}. + * + * @param ctx the parse tree + */ + void enterSubject_expr(PythonParser.Subject_exprContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#subject_expr}. + * + * @param ctx the parse tree + */ + void exitSubject_expr(PythonParser.Subject_exprContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#case_block}. + * + * @param ctx the parse tree + */ + void enterCase_block(PythonParser.Case_blockContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#case_block}. + * + * @param ctx the parse tree + */ + void exitCase_block(PythonParser.Case_blockContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#guard}. + * + * @param ctx the parse tree + */ + void enterGuard(PythonParser.GuardContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#guard}. + * + * @param ctx the parse tree + */ + void exitGuard(PythonParser.GuardContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#patterns}. + * + * @param ctx the parse tree + */ + void enterPatterns(PythonParser.PatternsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#patterns}. + * + * @param ctx the parse tree + */ + void exitPatterns(PythonParser.PatternsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#pattern}. + * + * @param ctx the parse tree + */ + void enterPattern(PythonParser.PatternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#pattern}. + * + * @param ctx the parse tree + */ + void exitPattern(PythonParser.PatternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#as_pattern}. + * + * @param ctx the parse tree + */ + void enterAs_pattern(PythonParser.As_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#as_pattern}. + * + * @param ctx the parse tree + */ + void exitAs_pattern(PythonParser.As_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#or_pattern}. + * + * @param ctx the parse tree + */ + void enterOr_pattern(PythonParser.Or_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#or_pattern}. + * + * @param ctx the parse tree + */ + void exitOr_pattern(PythonParser.Or_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#closed_pattern}. + * + * @param ctx the parse tree + */ + void enterClosed_pattern(PythonParser.Closed_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#closed_pattern}. + * + * @param ctx the parse tree + */ + void exitClosed_pattern(PythonParser.Closed_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#literal_pattern}. + * + * @param ctx the parse tree + */ + void enterLiteral_pattern(PythonParser.Literal_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#literal_pattern}. + * + * @param ctx the parse tree + */ + void exitLiteral_pattern(PythonParser.Literal_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#literal_expr}. + * + * @param ctx the parse tree + */ + void enterLiteral_expr(PythonParser.Literal_exprContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#literal_expr}. + * + * @param ctx the parse tree + */ + void exitLiteral_expr(PythonParser.Literal_exprContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#complex_number}. + * + * @param ctx the parse tree + */ + void enterComplex_number(PythonParser.Complex_numberContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#complex_number}. + * + * @param ctx the parse tree + */ + void exitComplex_number(PythonParser.Complex_numberContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#signed_number}. + * + * @param ctx the parse tree + */ + void enterSigned_number(PythonParser.Signed_numberContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#signed_number}. + * + * @param ctx the parse tree + */ + void exitSigned_number(PythonParser.Signed_numberContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#signed_real_number}. + * + * @param ctx the parse tree + */ + void enterSigned_real_number(PythonParser.Signed_real_numberContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#signed_real_number}. + * + * @param ctx the parse tree + */ + void exitSigned_real_number(PythonParser.Signed_real_numberContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#real_number}. + * + * @param ctx the parse tree + */ + void enterReal_number(PythonParser.Real_numberContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#real_number}. + * + * @param ctx the parse tree + */ + void exitReal_number(PythonParser.Real_numberContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#imaginary_number}. + * + * @param ctx the parse tree + */ + void enterImaginary_number(PythonParser.Imaginary_numberContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#imaginary_number}. + * + * @param ctx the parse tree + */ + void exitImaginary_number(PythonParser.Imaginary_numberContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#capture_pattern}. + * + * @param ctx the parse tree + */ + void enterCapture_pattern(PythonParser.Capture_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#capture_pattern}. + * + * @param ctx the parse tree + */ + void exitCapture_pattern(PythonParser.Capture_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#pattern_capture_target}. + * + * @param ctx the parse tree + */ + void enterPattern_capture_target(PythonParser.Pattern_capture_targetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#pattern_capture_target}. + * + * @param ctx the parse tree + */ + void exitPattern_capture_target(PythonParser.Pattern_capture_targetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#wildcard_pattern}. + * + * @param ctx the parse tree + */ + void enterWildcard_pattern(PythonParser.Wildcard_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#wildcard_pattern}. + * + * @param ctx the parse tree + */ + void exitWildcard_pattern(PythonParser.Wildcard_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#value_pattern}. + * + * @param ctx the parse tree + */ + void enterValue_pattern(PythonParser.Value_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#value_pattern}. + * + * @param ctx the parse tree + */ + void exitValue_pattern(PythonParser.Value_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#attr}. + * + * @param ctx the parse tree + */ + void enterAttr(PythonParser.AttrContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#attr}. + * + * @param ctx the parse tree + */ + void exitAttr(PythonParser.AttrContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#name_or_attr}. + * + * @param ctx the parse tree + */ + void enterName_or_attr(PythonParser.Name_or_attrContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#name_or_attr}. + * + * @param ctx the parse tree + */ + void exitName_or_attr(PythonParser.Name_or_attrContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#group_pattern}. + * + * @param ctx the parse tree + */ + void enterGroup_pattern(PythonParser.Group_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#group_pattern}. + * + * @param ctx the parse tree + */ + void exitGroup_pattern(PythonParser.Group_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#sequence_pattern}. + * + * @param ctx the parse tree + */ + void enterSequence_pattern(PythonParser.Sequence_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#sequence_pattern}. + * + * @param ctx the parse tree + */ + void exitSequence_pattern(PythonParser.Sequence_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#open_sequence_pattern}. + * + * @param ctx the parse tree + */ + void enterOpen_sequence_pattern(PythonParser.Open_sequence_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#open_sequence_pattern}. + * + * @param ctx the parse tree + */ + void exitOpen_sequence_pattern(PythonParser.Open_sequence_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#maybe_sequence_pattern}. + * + * @param ctx the parse tree + */ + void enterMaybe_sequence_pattern(PythonParser.Maybe_sequence_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#maybe_sequence_pattern}. + * + * @param ctx the parse tree + */ + void exitMaybe_sequence_pattern(PythonParser.Maybe_sequence_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#maybe_star_pattern}. + * + * @param ctx the parse tree + */ + void enterMaybe_star_pattern(PythonParser.Maybe_star_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#maybe_star_pattern}. + * + * @param ctx the parse tree + */ + void exitMaybe_star_pattern(PythonParser.Maybe_star_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_pattern}. + * + * @param ctx the parse tree + */ + void enterStar_pattern(PythonParser.Star_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_pattern}. + * + * @param ctx the parse tree + */ + void exitStar_pattern(PythonParser.Star_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#mapping_pattern}. + * + * @param ctx the parse tree + */ + void enterMapping_pattern(PythonParser.Mapping_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#mapping_pattern}. + * + * @param ctx the parse tree + */ + void exitMapping_pattern(PythonParser.Mapping_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#items_pattern}. + * + * @param ctx the parse tree + */ + void enterItems_pattern(PythonParser.Items_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#items_pattern}. + * + * @param ctx the parse tree + */ + void exitItems_pattern(PythonParser.Items_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#key_value_pattern}. + * + * @param ctx the parse tree + */ + void enterKey_value_pattern(PythonParser.Key_value_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#key_value_pattern}. + * + * @param ctx the parse tree + */ + void exitKey_value_pattern(PythonParser.Key_value_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#double_star_pattern}. + * + * @param ctx the parse tree + */ + void enterDouble_star_pattern(PythonParser.Double_star_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#double_star_pattern}. + * + * @param ctx the parse tree + */ + void exitDouble_star_pattern(PythonParser.Double_star_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#class_pattern}. + * + * @param ctx the parse tree + */ + void enterClass_pattern(PythonParser.Class_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#class_pattern}. + * + * @param ctx the parse tree + */ + void exitClass_pattern(PythonParser.Class_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#positional_patterns}. + * + * @param ctx the parse tree + */ + void enterPositional_patterns(PythonParser.Positional_patternsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#positional_patterns}. + * + * @param ctx the parse tree + */ + void exitPositional_patterns(PythonParser.Positional_patternsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#keyword_patterns}. + * + * @param ctx the parse tree + */ + void enterKeyword_patterns(PythonParser.Keyword_patternsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#keyword_patterns}. + * + * @param ctx the parse tree + */ + void exitKeyword_patterns(PythonParser.Keyword_patternsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#keyword_pattern}. + * + * @param ctx the parse tree + */ + void enterKeyword_pattern(PythonParser.Keyword_patternContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#keyword_pattern}. + * + * @param ctx the parse tree + */ + void exitKeyword_pattern(PythonParser.Keyword_patternContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_alias}. + * + * @param ctx the parse tree + */ + void enterType_alias(PythonParser.Type_aliasContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_alias}. + * + * @param ctx the parse tree + */ + void exitType_alias(PythonParser.Type_aliasContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_params}. + * + * @param ctx the parse tree + */ + void enterType_params(PythonParser.Type_paramsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_params}. + * + * @param ctx the parse tree + */ + void exitType_params(PythonParser.Type_paramsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_param_seq}. + * + * @param ctx the parse tree + */ + void enterType_param_seq(PythonParser.Type_param_seqContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_param_seq}. + * + * @param ctx the parse tree + */ + void exitType_param_seq(PythonParser.Type_param_seqContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_param}. + * + * @param ctx the parse tree + */ + void enterType_param(PythonParser.Type_paramContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_param}. + * + * @param ctx the parse tree + */ + void exitType_param(PythonParser.Type_paramContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_param_bound}. + * + * @param ctx the parse tree + */ + void enterType_param_bound(PythonParser.Type_param_boundContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_param_bound}. + * + * @param ctx the parse tree + */ + void exitType_param_bound(PythonParser.Type_param_boundContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#expressions}. + * + * @param ctx the parse tree + */ + void enterExpressions(PythonParser.ExpressionsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#expressions}. + * + * @param ctx the parse tree + */ + void exitExpressions(PythonParser.ExpressionsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#expression}. + * + * @param ctx the parse tree + */ + void enterExpression(PythonParser.ExpressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#expression}. + * + * @param ctx the parse tree + */ + void exitExpression(PythonParser.ExpressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#yield_expr}. + * + * @param ctx the parse tree + */ + void enterYield_expr(PythonParser.Yield_exprContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#yield_expr}. + * + * @param ctx the parse tree + */ + void exitYield_expr(PythonParser.Yield_exprContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_expressions}. + * + * @param ctx the parse tree + */ + void enterStar_expressions(PythonParser.Star_expressionsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_expressions}. + * + * @param ctx the parse tree + */ + void exitStar_expressions(PythonParser.Star_expressionsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_expression}. + * + * @param ctx the parse tree + */ + void enterStar_expression(PythonParser.Star_expressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_expression}. + * + * @param ctx the parse tree + */ + void exitStar_expression(PythonParser.Star_expressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_named_expressions}. + * + * @param ctx the parse tree + */ + void enterStar_named_expressions(PythonParser.Star_named_expressionsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_named_expressions}. + * + * @param ctx the parse tree + */ + void exitStar_named_expressions(PythonParser.Star_named_expressionsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_named_expression}. + * + * @param ctx the parse tree + */ + void enterStar_named_expression(PythonParser.Star_named_expressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_named_expression}. + * + * @param ctx the parse tree + */ + void exitStar_named_expression(PythonParser.Star_named_expressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#assignment_expression}. + * + * @param ctx the parse tree + */ + void enterAssignment_expression(PythonParser.Assignment_expressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#assignment_expression}. + * + * @param ctx the parse tree + */ + void exitAssignment_expression(PythonParser.Assignment_expressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#named_expression}. + * + * @param ctx the parse tree + */ + void enterNamed_expression(PythonParser.Named_expressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#named_expression}. + * + * @param ctx the parse tree + */ + void exitNamed_expression(PythonParser.Named_expressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#disjunction}. + * + * @param ctx the parse tree + */ + void enterDisjunction(PythonParser.DisjunctionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#disjunction}. + * + * @param ctx the parse tree + */ + void exitDisjunction(PythonParser.DisjunctionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#conjunction}. + * + * @param ctx the parse tree + */ + void enterConjunction(PythonParser.ConjunctionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#conjunction}. + * + * @param ctx the parse tree + */ + void exitConjunction(PythonParser.ConjunctionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#inversion}. + * + * @param ctx the parse tree + */ + void enterInversion(PythonParser.InversionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#inversion}. + * + * @param ctx the parse tree + */ + void exitInversion(PythonParser.InversionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#comparison}. + * + * @param ctx the parse tree + */ + void enterComparison(PythonParser.ComparisonContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#comparison}. + * + * @param ctx the parse tree + */ + void exitComparison(PythonParser.ComparisonContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#compare_op_bitwise_or_pair}. + * + * @param ctx the parse tree + */ + void enterCompare_op_bitwise_or_pair(PythonParser.Compare_op_bitwise_or_pairContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#compare_op_bitwise_or_pair}. + * + * @param ctx the parse tree + */ + void exitCompare_op_bitwise_or_pair(PythonParser.Compare_op_bitwise_or_pairContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#eq_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterEq_bitwise_or(PythonParser.Eq_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#eq_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitEq_bitwise_or(PythonParser.Eq_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#noteq_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterNoteq_bitwise_or(PythonParser.Noteq_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#noteq_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitNoteq_bitwise_or(PythonParser.Noteq_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lte_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterLte_bitwise_or(PythonParser.Lte_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lte_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitLte_bitwise_or(PythonParser.Lte_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lt_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterLt_bitwise_or(PythonParser.Lt_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lt_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitLt_bitwise_or(PythonParser.Lt_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#gte_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterGte_bitwise_or(PythonParser.Gte_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#gte_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitGte_bitwise_or(PythonParser.Gte_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#gt_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterGt_bitwise_or(PythonParser.Gt_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#gt_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitGt_bitwise_or(PythonParser.Gt_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#notin_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterNotin_bitwise_or(PythonParser.Notin_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#notin_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitNotin_bitwise_or(PythonParser.Notin_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#in_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterIn_bitwise_or(PythonParser.In_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#in_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitIn_bitwise_or(PythonParser.In_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#isnot_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterIsnot_bitwise_or(PythonParser.Isnot_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#isnot_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitIsnot_bitwise_or(PythonParser.Isnot_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#is_bitwise_or}. + * + * @param ctx the parse tree + */ + void enterIs_bitwise_or(PythonParser.Is_bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#is_bitwise_or}. + * + * @param ctx the parse tree + */ + void exitIs_bitwise_or(PythonParser.Is_bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#bitwise_or}. + * + * @param ctx the parse tree + */ + void enterBitwise_or(PythonParser.Bitwise_orContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#bitwise_or}. + * + * @param ctx the parse tree + */ + void exitBitwise_or(PythonParser.Bitwise_orContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#bitwise_xor}. + * + * @param ctx the parse tree + */ + void enterBitwise_xor(PythonParser.Bitwise_xorContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#bitwise_xor}. + * + * @param ctx the parse tree + */ + void exitBitwise_xor(PythonParser.Bitwise_xorContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#bitwise_and}. + * + * @param ctx the parse tree + */ + void enterBitwise_and(PythonParser.Bitwise_andContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#bitwise_and}. + * + * @param ctx the parse tree + */ + void exitBitwise_and(PythonParser.Bitwise_andContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#shift_expr}. + * + * @param ctx the parse tree + */ + void enterShift_expr(PythonParser.Shift_exprContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#shift_expr}. + * + * @param ctx the parse tree + */ + void exitShift_expr(PythonParser.Shift_exprContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#sum}. + * + * @param ctx the parse tree + */ + void enterSum(PythonParser.SumContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#sum}. + * + * @param ctx the parse tree + */ + void exitSum(PythonParser.SumContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#term}. + * + * @param ctx the parse tree + */ + void enterTerm(PythonParser.TermContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#term}. + * + * @param ctx the parse tree + */ + void exitTerm(PythonParser.TermContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#factor}. + * + * @param ctx the parse tree + */ + void enterFactor(PythonParser.FactorContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#factor}. + * + * @param ctx the parse tree + */ + void exitFactor(PythonParser.FactorContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#power}. + * + * @param ctx the parse tree + */ + void enterPower(PythonParser.PowerContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#power}. + * + * @param ctx the parse tree + */ + void exitPower(PythonParser.PowerContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#await_primary}. + * + * @param ctx the parse tree + */ + void enterAwait_primary(PythonParser.Await_primaryContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#await_primary}. + * + * @param ctx the parse tree + */ + void exitAwait_primary(PythonParser.Await_primaryContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#primary}. + * + * @param ctx the parse tree + */ + void enterPrimary(PythonParser.PrimaryContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#primary}. + * + * @param ctx the parse tree + */ + void exitPrimary(PythonParser.PrimaryContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#slices}. + * + * @param ctx the parse tree + */ + void enterSlices(PythonParser.SlicesContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#slices}. + * + * @param ctx the parse tree + */ + void exitSlices(PythonParser.SlicesContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#slice}. + * + * @param ctx the parse tree + */ + void enterSlice(PythonParser.SliceContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#slice}. + * + * @param ctx the parse tree + */ + void exitSlice(PythonParser.SliceContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#atom}. + * + * @param ctx the parse tree + */ + void enterAtom(PythonParser.AtomContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#atom}. + * + * @param ctx the parse tree + */ + void exitAtom(PythonParser.AtomContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#group}. + * + * @param ctx the parse tree + */ + void enterGroup(PythonParser.GroupContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#group}. + * + * @param ctx the parse tree + */ + void exitGroup(PythonParser.GroupContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambdef}. + * + * @param ctx the parse tree + */ + void enterLambdef(PythonParser.LambdefContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambdef}. + * + * @param ctx the parse tree + */ + void exitLambdef(PythonParser.LambdefContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_params}. + * + * @param ctx the parse tree + */ + void enterLambda_params(PythonParser.Lambda_paramsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_params}. + * + * @param ctx the parse tree + */ + void exitLambda_params(PythonParser.Lambda_paramsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_parameters}. + * + * @param ctx the parse tree + */ + void enterLambda_parameters(PythonParser.Lambda_parametersContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_parameters}. + * + * @param ctx the parse tree + */ + void exitLambda_parameters(PythonParser.Lambda_parametersContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_slash_no_default}. + * + * @param ctx the parse tree + */ + void enterLambda_slash_no_default(PythonParser.Lambda_slash_no_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_slash_no_default}. + * + * @param ctx the parse tree + */ + void exitLambda_slash_no_default(PythonParser.Lambda_slash_no_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_slash_with_default}. + * + * @param ctx the parse tree + */ + void enterLambda_slash_with_default(PythonParser.Lambda_slash_with_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_slash_with_default}. + * + * @param ctx the parse tree + */ + void exitLambda_slash_with_default(PythonParser.Lambda_slash_with_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_star_etc}. + * + * @param ctx the parse tree + */ + void enterLambda_star_etc(PythonParser.Lambda_star_etcContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_star_etc}. + * + * @param ctx the parse tree + */ + void exitLambda_star_etc(PythonParser.Lambda_star_etcContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_kwds}. + * + * @param ctx the parse tree + */ + void enterLambda_kwds(PythonParser.Lambda_kwdsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_kwds}. + * + * @param ctx the parse tree + */ + void exitLambda_kwds(PythonParser.Lambda_kwdsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_param_no_default}. + * + * @param ctx the parse tree + */ + void enterLambda_param_no_default(PythonParser.Lambda_param_no_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_param_no_default}. + * + * @param ctx the parse tree + */ + void exitLambda_param_no_default(PythonParser.Lambda_param_no_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_param_with_default}. + * + * @param ctx the parse tree + */ + void enterLambda_param_with_default(PythonParser.Lambda_param_with_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_param_with_default}. + * + * @param ctx the parse tree + */ + void exitLambda_param_with_default(PythonParser.Lambda_param_with_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_param_maybe_default}. + * + * @param ctx the parse tree + */ + void enterLambda_param_maybe_default(PythonParser.Lambda_param_maybe_defaultContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_param_maybe_default}. + * + * @param ctx the parse tree + */ + void exitLambda_param_maybe_default(PythonParser.Lambda_param_maybe_defaultContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#lambda_param}. + * + * @param ctx the parse tree + */ + void enterLambda_param(PythonParser.Lambda_paramContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#lambda_param}. + * + * @param ctx the parse tree + */ + void exitLambda_param(PythonParser.Lambda_paramContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_middle}. + * + * @param ctx the parse tree + */ + void enterFstring_middle(PythonParser.Fstring_middleContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_middle}. + * + * @param ctx the parse tree + */ + void exitFstring_middle(PythonParser.Fstring_middleContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_replacement_field}. + * + * @param ctx the parse tree + */ + void enterFstring_replacement_field(PythonParser.Fstring_replacement_fieldContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_replacement_field}. + * + * @param ctx the parse tree + */ + void exitFstring_replacement_field(PythonParser.Fstring_replacement_fieldContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_conversion}. + * + * @param ctx the parse tree + */ + void enterFstring_conversion(PythonParser.Fstring_conversionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_conversion}. + * + * @param ctx the parse tree + */ + void exitFstring_conversion(PythonParser.Fstring_conversionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_full_format_spec}. + * + * @param ctx the parse tree + */ + void enterFstring_full_format_spec(PythonParser.Fstring_full_format_specContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_full_format_spec}. + * + * @param ctx the parse tree + */ + void exitFstring_full_format_spec(PythonParser.Fstring_full_format_specContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring_format_spec}. + * + * @param ctx the parse tree + */ + void enterFstring_format_spec(PythonParser.Fstring_format_specContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring_format_spec}. + * + * @param ctx the parse tree + */ + void exitFstring_format_spec(PythonParser.Fstring_format_specContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#fstring}. + * + * @param ctx the parse tree + */ + void enterFstring(PythonParser.FstringContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#fstring}. + * + * @param ctx the parse tree + */ + void exitFstring(PythonParser.FstringContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#string}. + * + * @param ctx the parse tree + */ + void enterString(PythonParser.StringContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#string}. + * + * @param ctx the parse tree + */ + void exitString(PythonParser.StringContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#strings}. + * + * @param ctx the parse tree + */ + void enterStrings(PythonParser.StringsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#strings}. + * + * @param ctx the parse tree + */ + void exitStrings(PythonParser.StringsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#list}. + * + * @param ctx the parse tree + */ + void enterList(PythonParser.ListContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#list}. + * + * @param ctx the parse tree + */ + void exitList(PythonParser.ListContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#tuple}. + * + * @param ctx the parse tree + */ + void enterTuple(PythonParser.TupleContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#tuple}. + * + * @param ctx the parse tree + */ + void exitTuple(PythonParser.TupleContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#set}. + * + * @param ctx the parse tree + */ + void enterSet(PythonParser.SetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#set}. + * + * @param ctx the parse tree + */ + void exitSet(PythonParser.SetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#dict}. + * + * @param ctx the parse tree + */ + void enterDict(PythonParser.DictContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#dict}. + * + * @param ctx the parse tree + */ + void exitDict(PythonParser.DictContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#double_starred_kvpairs}. + * + * @param ctx the parse tree + */ + void enterDouble_starred_kvpairs(PythonParser.Double_starred_kvpairsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#double_starred_kvpairs}. + * + * @param ctx the parse tree + */ + void exitDouble_starred_kvpairs(PythonParser.Double_starred_kvpairsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#double_starred_kvpair}. + * + * @param ctx the parse tree + */ + void enterDouble_starred_kvpair(PythonParser.Double_starred_kvpairContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#double_starred_kvpair}. + * + * @param ctx the parse tree + */ + void exitDouble_starred_kvpair(PythonParser.Double_starred_kvpairContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#kvpair}. + * + * @param ctx the parse tree + */ + void enterKvpair(PythonParser.KvpairContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#kvpair}. + * + * @param ctx the parse tree + */ + void exitKvpair(PythonParser.KvpairContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#for_if_clauses}. + * + * @param ctx the parse tree + */ + void enterFor_if_clauses(PythonParser.For_if_clausesContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#for_if_clauses}. + * + * @param ctx the parse tree + */ + void exitFor_if_clauses(PythonParser.For_if_clausesContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#for_if_clause}. + * + * @param ctx the parse tree + */ + void enterFor_if_clause(PythonParser.For_if_clauseContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#for_if_clause}. + * + * @param ctx the parse tree + */ + void exitFor_if_clause(PythonParser.For_if_clauseContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#listcomp}. + * + * @param ctx the parse tree + */ + void enterListcomp(PythonParser.ListcompContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#listcomp}. + * + * @param ctx the parse tree + */ + void exitListcomp(PythonParser.ListcompContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#setcomp}. + * + * @param ctx the parse tree + */ + void enterSetcomp(PythonParser.SetcompContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#setcomp}. + * + * @param ctx the parse tree + */ + void exitSetcomp(PythonParser.SetcompContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#genexp}. + * + * @param ctx the parse tree + */ + void enterGenexp(PythonParser.GenexpContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#genexp}. + * + * @param ctx the parse tree + */ + void exitGenexp(PythonParser.GenexpContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#dictcomp}. + * + * @param ctx the parse tree + */ + void enterDictcomp(PythonParser.DictcompContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#dictcomp}. + * + * @param ctx the parse tree + */ + void exitDictcomp(PythonParser.DictcompContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#arguments}. + * + * @param ctx the parse tree + */ + void enterArguments(PythonParser.ArgumentsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#arguments}. + * + * @param ctx the parse tree + */ + void exitArguments(PythonParser.ArgumentsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#args}. + * + * @param ctx the parse tree + */ + void enterArgs(PythonParser.ArgsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#args}. + * + * @param ctx the parse tree + */ + void exitArgs(PythonParser.ArgsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#kwargs}. + * + * @param ctx the parse tree + */ + void enterKwargs(PythonParser.KwargsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#kwargs}. + * + * @param ctx the parse tree + */ + void exitKwargs(PythonParser.KwargsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#starred_expression}. + * + * @param ctx the parse tree + */ + void enterStarred_expression(PythonParser.Starred_expressionContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#starred_expression}. + * + * @param ctx the parse tree + */ + void exitStarred_expression(PythonParser.Starred_expressionContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#kwarg_or_starred}. + * + * @param ctx the parse tree + */ + void enterKwarg_or_starred(PythonParser.Kwarg_or_starredContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#kwarg_or_starred}. + * + * @param ctx the parse tree + */ + void exitKwarg_or_starred(PythonParser.Kwarg_or_starredContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#kwarg_or_double_starred}. + * + * @param ctx the parse tree + */ + void enterKwarg_or_double_starred(PythonParser.Kwarg_or_double_starredContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#kwarg_or_double_starred}. + * + * @param ctx the parse tree + */ + void exitKwarg_or_double_starred(PythonParser.Kwarg_or_double_starredContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_targets}. + * + * @param ctx the parse tree + */ + void enterStar_targets(PythonParser.Star_targetsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_targets}. + * + * @param ctx the parse tree + */ + void exitStar_targets(PythonParser.Star_targetsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_targets_list_seq}. + * + * @param ctx the parse tree + */ + void enterStar_targets_list_seq(PythonParser.Star_targets_list_seqContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_targets_list_seq}. + * + * @param ctx the parse tree + */ + void exitStar_targets_list_seq(PythonParser.Star_targets_list_seqContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_targets_tuple_seq}. + * + * @param ctx the parse tree + */ + void enterStar_targets_tuple_seq(PythonParser.Star_targets_tuple_seqContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_targets_tuple_seq}. + * + * @param ctx the parse tree + */ + void exitStar_targets_tuple_seq(PythonParser.Star_targets_tuple_seqContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_target}. + * + * @param ctx the parse tree + */ + void enterStar_target(PythonParser.Star_targetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_target}. + * + * @param ctx the parse tree + */ + void exitStar_target(PythonParser.Star_targetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#target_with_star_atom}. + * + * @param ctx the parse tree + */ + void enterTarget_with_star_atom(PythonParser.Target_with_star_atomContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#target_with_star_atom}. + * + * @param ctx the parse tree + */ + void exitTarget_with_star_atom(PythonParser.Target_with_star_atomContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#star_atom}. + * + * @param ctx the parse tree + */ + void enterStar_atom(PythonParser.Star_atomContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#star_atom}. + * + * @param ctx the parse tree + */ + void exitStar_atom(PythonParser.Star_atomContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#single_target}. + * + * @param ctx the parse tree + */ + void enterSingle_target(PythonParser.Single_targetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#single_target}. + * + * @param ctx the parse tree + */ + void exitSingle_target(PythonParser.Single_targetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#single_subscript_attribute_target}. + * + * @param ctx the parse tree + */ + void enterSingle_subscript_attribute_target(PythonParser.Single_subscript_attribute_targetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#single_subscript_attribute_target}. + * + * @param ctx the parse tree + */ + void exitSingle_subscript_attribute_target(PythonParser.Single_subscript_attribute_targetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#t_primary}. + * + * @param ctx the parse tree + */ + void enterT_primary(PythonParser.T_primaryContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#t_primary}. + * + * @param ctx the parse tree + */ + void exitT_primary(PythonParser.T_primaryContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#del_targets}. + * + * @param ctx the parse tree + */ + void enterDel_targets(PythonParser.Del_targetsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#del_targets}. + * + * @param ctx the parse tree + */ + void exitDel_targets(PythonParser.Del_targetsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#del_target}. + * + * @param ctx the parse tree + */ + void enterDel_target(PythonParser.Del_targetContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#del_target}. + * + * @param ctx the parse tree + */ + void exitDel_target(PythonParser.Del_targetContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#del_t_atom}. + * + * @param ctx the parse tree + */ + void enterDel_t_atom(PythonParser.Del_t_atomContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#del_t_atom}. + * + * @param ctx the parse tree + */ + void exitDel_t_atom(PythonParser.Del_t_atomContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#type_expressions}. + * + * @param ctx the parse tree + */ + void enterType_expressions(PythonParser.Type_expressionsContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#type_expressions}. + * + * @param ctx the parse tree + */ + void exitType_expressions(PythonParser.Type_expressionsContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#func_type_comment}. + * + * @param ctx the parse tree + */ + void enterFunc_type_comment(PythonParser.Func_type_commentContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#func_type_comment}. + * + * @param ctx the parse tree + */ + void exitFunc_type_comment(PythonParser.Func_type_commentContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#soft_kw_type}. + * + * @param ctx the parse tree + */ + void enterSoft_kw_type(PythonParser.Soft_kw_typeContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#soft_kw_type}. + * + * @param ctx the parse tree + */ + void exitSoft_kw_type(PythonParser.Soft_kw_typeContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#soft_kw_match}. + * + * @param ctx the parse tree + */ + void enterSoft_kw_match(PythonParser.Soft_kw_matchContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#soft_kw_match}. + * + * @param ctx the parse tree + */ + void exitSoft_kw_match(PythonParser.Soft_kw_matchContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#soft_kw_case}. + * + * @param ctx the parse tree + */ + void enterSoft_kw_case(PythonParser.Soft_kw_caseContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#soft_kw_case}. + * + * @param ctx the parse tree + */ + void exitSoft_kw_case(PythonParser.Soft_kw_caseContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#soft_kw_wildcard}. + * + * @param ctx the parse tree + */ + void enterSoft_kw_wildcard(PythonParser.Soft_kw_wildcardContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#soft_kw_wildcard}. + * + * @param ctx the parse tree + */ + void exitSoft_kw_wildcard(PythonParser.Soft_kw_wildcardContext ctx); + + /** + * Enter a parse tree produced by {@link PythonParser#soft_kw__not__wildcard}. + * + * @param ctx the parse tree + */ + void enterSoft_kw__not__wildcard(PythonParser.Soft_kw__not__wildcardContext ctx); + + /** + * Exit a parse tree produced by {@link PythonParser#soft_kw__not__wildcard}. + * + * @param ctx the parse tree + */ + void exitSoft_kw__not__wildcard(PythonParser.Soft_kw__not__wildcardContext ctx); +} \ No newline at end of file diff --git a/src/main/java/UnicodeClasses.interp b/src/main/java/UnicodeClasses.interp new file mode 100644 index 0000000..b87e04e --- /dev/null +++ b/src/main/java/UnicodeClasses.interp @@ -0,0 +1,38 @@ +token literal names: +null +null +null +null +null +null +null +null + +token symbolic names: +null +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL + +rule names: +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 7, 29, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 0, 0, 7, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 1, 0, 7, 582, 0, 97, 122, 181, 181, 223, 246, 248, 255, 257, 257, 259, 259, 261, 261, 263, 263, 265, 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279, 281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, 295, 297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, 311, 312, 314, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, 326, 328, 329, 331, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, 343, 343, 345, 345, 347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, 357, 359, 359, 361, 361, 363, 363, 365, 365, 367, 367, 369, 369, 371, 371, 373, 373, 375, 375, 378, 378, 380, 380, 382, 384, 387, 387, 389, 389, 392, 392, 396, 397, 402, 402, 405, 405, 409, 411, 414, 414, 417, 417, 419, 419, 421, 421, 424, 424, 426, 427, 429, 429, 432, 432, 436, 436, 438, 438, 441, 442, 445, 447, 454, 454, 457, 457, 460, 460, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 477, 479, 479, 481, 481, 483, 483, 485, 485, 487, 487, 489, 489, 491, 491, 493, 493, 495, 496, 499, 499, 501, 501, 505, 505, 507, 507, 509, 509, 511, 511, 513, 513, 515, 515, 517, 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527, 529, 529, 531, 531, 533, 533, 535, 535, 537, 537, 539, 539, 541, 541, 543, 543, 545, 545, 547, 547, 549, 549, 551, 551, 553, 553, 555, 555, 557, 557, 559, 559, 561, 561, 563, 569, 572, 572, 575, 576, 578, 578, 583, 583, 585, 585, 587, 587, 589, 589, 591, 659, 661, 687, 881, 881, 883, 883, 887, 887, 891, 893, 912, 912, 940, 974, 976, 977, 981, 983, 985, 985, 987, 987, 989, 989, 991, 991, 993, 993, 995, 995, 997, 997, 999, 999, 1001, 1001, 1003, 1003, 1005, 1005, 1007, 1011, 1013, 1013, 1016, 1016, 1019, 1020, 1072, 1119, 1121, 1121, 1123, 1123, 1125, 1125, 1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, 1135, 1135, 1137, 1137, 1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, 1147, 1147, 1149, 1149, 1151, 1151, 1153, 1153, 1163, 1163, 1165, 1165, 1167, 1167, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175, 1177, 1177, 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187, 1189, 1189, 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199, 1201, 1201, 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211, 1213, 1213, 1215, 1215, 1218, 1218, 1220, 1220, 1222, 1222, 1224, 1224, 1226, 1226, 1228, 1228, 1230, 1231, 1233, 1233, 1235, 1235, 1237, 1237, 1239, 1239, 1241, 1241, 1243, 1243, 1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, 1253, 1253, 1255, 1255, 1257, 1257, 1259, 1259, 1261, 1261, 1263, 1263, 1265, 1265, 1267, 1267, 1269, 1269, 1271, 1271, 1273, 1273, 1275, 1275, 1277, 1277, 1279, 1279, 1281, 1281, 1283, 1283, 1285, 1285, 1287, 1287, 1289, 1289, 1291, 1291, 1293, 1293, 1295, 1295, 1297, 1297, 1299, 1299, 1301, 1301, 1303, 1303, 1305, 1305, 1307, 1307, 1309, 1309, 1311, 1311, 1313, 1313, 1315, 1315, 1317, 1317, 1319, 1319, 1377, 1415, 7424, 7467, 7531, 7543, 7545, 7578, 7681, 7681, 7683, 7683, 7685, 7685, 7687, 7687, 7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699, 7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711, 7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723, 7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735, 7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747, 7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759, 7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771, 7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783, 7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795, 7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807, 7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819, 7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7837, 7839, 7839, 7841, 7841, 7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, 7853, 7853, 7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, 7865, 7865, 7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, 7877, 7877, 7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, 7889, 7889, 7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, 7901, 7901, 7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, 7913, 7913, 7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, 7925, 7925, 7927, 7927, 7929, 7929, 7931, 7931, 7933, 7933, 7935, 7943, 7952, 7957, 7968, 7975, 7984, 7991, 8000, 8005, 8016, 8023, 8032, 8039, 8048, 8061, 8064, 8071, 8080, 8087, 8096, 8103, 8112, 8116, 8118, 8119, 8126, 8126, 8130, 8132, 8134, 8135, 8144, 8147, 8150, 8151, 8160, 8167, 8178, 8180, 8182, 8183, 8458, 8458, 8462, 8463, 8467, 8467, 8495, 8495, 8500, 8500, 8505, 8505, 8508, 8509, 8518, 8521, 8526, 8526, 8580, 8580, 11312, 11358, 11361, 11361, 11365, 11366, 11368, 11368, 11370, 11370, 11372, 11372, 11377, 11377, 11379, 11380, 11382, 11387, 11393, 11393, 11395, 11395, 11397, 11397, 11399, 11399, 11401, 11401, 11403, 11403, 11405, 11405, 11407, 11407, 11409, 11409, 11411, 11411, 11413, 11413, 11415, 11415, 11417, 11417, 11419, 11419, 11421, 11421, 11423, 11423, 11425, 11425, 11427, 11427, 11429, 11429, 11431, 11431, 11433, 11433, 11435, 11435, 11437, 11437, 11439, 11439, 11441, 11441, 11443, 11443, 11445, 11445, 11447, 11447, 11449, 11449, 11451, 11451, 11453, 11453, 11455, 11455, 11457, 11457, 11459, 11459, 11461, 11461, 11463, 11463, 11465, 11465, 11467, 11467, 11469, 11469, 11471, 11471, 11473, 11473, 11475, 11475, 11477, 11477, 11479, 11479, 11481, 11481, 11483, 11483, 11485, 11485, 11487, 11487, 11489, 11489, 11491, 11492, 11500, 11500, 11502, 11502, 11507, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 42561, 42561, 42563, 42563, 42565, 42565, 42567, 42567, 42569, 42569, 42571, 42571, 42573, 42573, 42575, 42575, 42577, 42577, 42579, 42579, 42581, 42581, 42583, 42583, 42585, 42585, 42587, 42587, 42589, 42589, 42591, 42591, 42593, 42593, 42595, 42595, 42597, 42597, 42599, 42599, 42601, 42601, 42603, 42603, 42605, 42605, 42625, 42625, 42627, 42627, 42629, 42629, 42631, 42631, 42633, 42633, 42635, 42635, 42637, 42637, 42639, 42639, 42641, 42641, 42643, 42643, 42645, 42645, 42647, 42647, 42787, 42787, 42789, 42789, 42791, 42791, 42793, 42793, 42795, 42795, 42797, 42797, 42799, 42801, 42803, 42803, 42805, 42805, 42807, 42807, 42809, 42809, 42811, 42811, 42813, 42813, 42815, 42815, 42817, 42817, 42819, 42819, 42821, 42821, 42823, 42823, 42825, 42825, 42827, 42827, 42829, 42829, 42831, 42831, 42833, 42833, 42835, 42835, 42837, 42837, 42839, 42839, 42841, 42841, 42843, 42843, 42845, 42845, 42847, 42847, 42849, 42849, 42851, 42851, 42853, 42853, 42855, 42855, 42857, 42857, 42859, 42859, 42861, 42861, 42863, 42863, 42865, 42872, 42874, 42874, 42876, 42876, 42879, 42879, 42881, 42881, 42883, 42883, 42885, 42885, 42887, 42887, 42892, 42892, 42894, 42894, 42897, 42897, 42899, 42899, 42913, 42913, 42915, 42915, 42917, 42917, 42919, 42919, 42921, 42921, 43002, 43002, 64256, 64262, 64275, 64279, 65345, 65370, 51, 0, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 884, 884, 890, 890, 1369, 1369, 1600, 1600, 1765, 1766, 2036, 2037, 2042, 2042, 2074, 2074, 2084, 2084, 2088, 2088, 2417, 2417, 3654, 3654, 3782, 3782, 4348, 4348, 6103, 6103, 6211, 6211, 6823, 6823, 7288, 7293, 7468, 7530, 7544, 7544, 7579, 7615, 8305, 8305, 8319, 8319, 8336, 8348, 11388, 11389, 11631, 11631, 11823, 11823, 12293, 12293, 12337, 12341, 12347, 12347, 12445, 12446, 12540, 12542, 40981, 40981, 42232, 42237, 42508, 42508, 42623, 42623, 42775, 42783, 42864, 42864, 42888, 42888, 43000, 43001, 43471, 43471, 43632, 43632, 43741, 43741, 43763, 43764, 65392, 65392, 65438, 65439, 289, 0, 170, 170, 186, 186, 443, 443, 448, 451, 660, 660, 1488, 1514, 1520, 1522, 1568, 1599, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2048, 2069, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2418, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4304, 4346, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6108, 6108, 6176, 6210, 6212, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7401, 7404, 7406, 7409, 7413, 7414, 8501, 8504, 11568, 11623, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12294, 12294, 12348, 12348, 12353, 12438, 12447, 12447, 12449, 12538, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 13312, 19893, 19893, 19968, 19968, 40908, 40908, 40960, 40980, 40982, 42124, 42192, 42231, 42240, 42507, 42512, 42527, 42538, 42539, 42606, 42606, 42656, 42725, 43003, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43633, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43744, 43754, 43762, 43762, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 44032, 55203, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65382, 65391, 65393, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 10, 0, 453, 453, 456, 456, 459, 459, 498, 498, 8072, 8079, 8088, 8095, 8104, 8111, 8124, 8124, 8140, 8140, 8188, 8188, 576, 0, 65, 90, 192, 214, 216, 222, 256, 256, 258, 258, 260, 260, 262, 262, 264, 264, 266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, 278, 280, 280, 282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, 294, 294, 296, 296, 298, 298, 300, 300, 302, 302, 304, 304, 306, 306, 308, 308, 310, 310, 313, 313, 315, 315, 317, 317, 319, 319, 321, 321, 323, 323, 325, 325, 327, 327, 330, 330, 332, 332, 334, 334, 336, 336, 338, 338, 340, 340, 342, 342, 344, 344, 346, 346, 348, 348, 350, 350, 352, 352, 354, 354, 356, 356, 358, 358, 360, 360, 362, 362, 364, 364, 366, 366, 368, 368, 370, 370, 372, 372, 374, 374, 376, 377, 379, 379, 381, 381, 385, 386, 388, 388, 390, 391, 393, 395, 398, 401, 403, 404, 406, 408, 412, 413, 415, 416, 418, 418, 420, 420, 422, 423, 425, 425, 428, 428, 430, 431, 433, 435, 437, 437, 439, 440, 444, 444, 452, 452, 455, 455, 458, 458, 461, 461, 463, 463, 465, 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 478, 478, 480, 480, 482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 497, 497, 500, 500, 502, 504, 506, 506, 508, 508, 510, 510, 512, 512, 514, 514, 516, 516, 518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, 530, 532, 532, 534, 534, 536, 536, 538, 538, 540, 540, 542, 542, 544, 544, 546, 546, 548, 548, 550, 550, 552, 552, 554, 554, 556, 556, 558, 558, 560, 560, 562, 562, 570, 571, 573, 574, 577, 577, 579, 582, 584, 584, 586, 586, 588, 588, 590, 590, 880, 880, 882, 882, 886, 886, 902, 902, 904, 906, 908, 908, 910, 911, 913, 929, 931, 939, 975, 975, 978, 980, 984, 984, 986, 986, 988, 988, 990, 990, 992, 992, 994, 994, 996, 996, 998, 998, 1000, 1000, 1002, 1002, 1004, 1004, 1006, 1006, 1012, 1012, 1015, 1015, 1017, 1018, 1021, 1071, 1120, 1120, 1122, 1122, 1124, 1124, 1126, 1126, 1128, 1128, 1130, 1130, 1132, 1132, 1134, 1134, 1136, 1136, 1138, 1138, 1140, 1140, 1142, 1142, 1144, 1144, 1146, 1146, 1148, 1148, 1150, 1150, 1152, 1152, 1162, 1162, 1164, 1164, 1166, 1166, 1168, 1168, 1170, 1170, 1172, 1172, 1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184, 1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196, 1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208, 1210, 1210, 1212, 1212, 1214, 1214, 1216, 1217, 1219, 1219, 1221, 1221, 1223, 1223, 1225, 1225, 1227, 1227, 1229, 1229, 1232, 1232, 1234, 1234, 1236, 1236, 1238, 1238, 1240, 1240, 1242, 1242, 1244, 1244, 1246, 1246, 1248, 1248, 1250, 1250, 1252, 1252, 1254, 1254, 1256, 1256, 1258, 1258, 1260, 1260, 1262, 1262, 1264, 1264, 1266, 1266, 1268, 1268, 1270, 1270, 1272, 1272, 1274, 1274, 1276, 1276, 1278, 1278, 1280, 1280, 1282, 1282, 1284, 1284, 1286, 1286, 1288, 1288, 1290, 1290, 1292, 1292, 1294, 1294, 1296, 1296, 1298, 1298, 1300, 1300, 1302, 1302, 1304, 1304, 1306, 1306, 1308, 1308, 1310, 1310, 1312, 1312, 1314, 1314, 1316, 1316, 1318, 1318, 1329, 1366, 4256, 4293, 4295, 4295, 4301, 4301, 7680, 7680, 7682, 7682, 7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694, 7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706, 7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718, 7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730, 7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742, 7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754, 7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766, 7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778, 7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790, 7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802, 7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814, 7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826, 7828, 7828, 7838, 7838, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, 7848, 7848, 7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, 7860, 7860, 7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, 7872, 7872, 7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, 7884, 7884, 7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, 7896, 7896, 7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, 7908, 7908, 7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, 7920, 7920, 7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7930, 7930, 7932, 7932, 7934, 7934, 7944, 7951, 7960, 7965, 7976, 7983, 7992, 7999, 8008, 8013, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8040, 8047, 8120, 8123, 8136, 8139, 8152, 8155, 8168, 8172, 8184, 8187, 8450, 8450, 8455, 8455, 8459, 8461, 8464, 8466, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8496, 8499, 8510, 8511, 8517, 8517, 8579, 8579, 11264, 11310, 11360, 11360, 11362, 11364, 11367, 11367, 11369, 11369, 11371, 11371, 11373, 11376, 11378, 11378, 11381, 11381, 11390, 11392, 11394, 11394, 11396, 11396, 11398, 11398, 11400, 11400, 11402, 11402, 11404, 11404, 11406, 11406, 11408, 11408, 11410, 11410, 11412, 11412, 11414, 11414, 11416, 11416, 11418, 11418, 11420, 11420, 11422, 11422, 11424, 11424, 11426, 11426, 11428, 11428, 11430, 11430, 11432, 11432, 11434, 11434, 11436, 11436, 11438, 11438, 11440, 11440, 11442, 11442, 11444, 11444, 11446, 11446, 11448, 11448, 11450, 11450, 11452, 11452, 11454, 11454, 11456, 11456, 11458, 11458, 11460, 11460, 11462, 11462, 11464, 11464, 11466, 11466, 11468, 11468, 11470, 11470, 11472, 11472, 11474, 11474, 11476, 11476, 11478, 11478, 11480, 11480, 11482, 11482, 11484, 11484, 11486, 11486, 11488, 11488, 11490, 11490, 11499, 11499, 11501, 11501, 11506, 11506, 42560, 42560, 42562, 42562, 42564, 42564, 42566, 42566, 42568, 42568, 42570, 42570, 42572, 42572, 42574, 42574, 42576, 42576, 42578, 42578, 42580, 42580, 42582, 42582, 42584, 42584, 42586, 42586, 42588, 42588, 42590, 42590, 42592, 42592, 42594, 42594, 42596, 42596, 42598, 42598, 42600, 42600, 42602, 42602, 42604, 42604, 42624, 42624, 42626, 42626, 42628, 42628, 42630, 42630, 42632, 42632, 42634, 42634, 42636, 42636, 42638, 42638, 42640, 42640, 42642, 42642, 42644, 42644, 42646, 42646, 42786, 42786, 42788, 42788, 42790, 42790, 42792, 42792, 42794, 42794, 42796, 42796, 42798, 42798, 42802, 42802, 42804, 42804, 42806, 42806, 42808, 42808, 42810, 42810, 42812, 42812, 42814, 42814, 42816, 42816, 42818, 42818, 42820, 42820, 42822, 42822, 42824, 42824, 42826, 42826, 42828, 42828, 42830, 42830, 42832, 42832, 42834, 42834, 42836, 42836, 42838, 42838, 42840, 42840, 42842, 42842, 42844, 42844, 42846, 42846, 42848, 42848, 42850, 42850, 42852, 42852, 42854, 42854, 42856, 42856, 42858, 42858, 42860, 42860, 42862, 42862, 42873, 42873, 42875, 42875, 42877, 42878, 42880, 42880, 42882, 42882, 42884, 42884, 42886, 42886, 42891, 42891, 42893, 42893, 42896, 42896, 42898, 42898, 42912, 42912, 42914, 42914, 42916, 42916, 42918, 42918, 42920, 42920, 42922, 42922, 65313, 65338, 35, 0, 48, 57, 1632, 1641, 1776, 1785, 1984, 1993, 2406, 2415, 2534, 2543, 2662, 2671, 2790, 2799, 2918, 2927, 3046, 3055, 3174, 3183, 3302, 3311, 3430, 3439, 3664, 3673, 3792, 3801, 3872, 3881, 4160, 4169, 4240, 4249, 6112, 6121, 6160, 6169, 6470, 6479, 6608, 6617, 6784, 6793, 6800, 6809, 6992, 7001, 7088, 7097, 7232, 7241, 7248, 7257, 42528, 42537, 43216, 43225, 43264, 43273, 43472, 43481, 43600, 43609, 44016, 44025, 65296, 65305, 7, 0, 5870, 5872, 8544, 8578, 8581, 8584, 12295, 12295, 12321, 12329, 12344, 12346, 42726, 42735, 28, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 1, 15, 1, 0, 0, 0, 3, 17, 1, 0, 0, 0, 5, 19, 1, 0, 0, 0, 7, 21, 1, 0, 0, 0, 9, 23, 1, 0, 0, 0, 11, 25, 1, 0, 0, 0, 13, 27, 1, 0, 0, 0, 15, 16, 7, 0, 0, 0, 16, 2, 1, 0, 0, 0, 17, 18, 7, 1, 0, 0, 18, 4, 1, 0, 0, 0, 19, 20, 7, 2, 0, 0, 20, 6, 1, 0, 0, 0, 21, 22, 7, 3, 0, 0, 22, 8, 1, 0, 0, 0, 23, 24, 7, 4, 0, 0, 24, 10, 1, 0, 0, 0, 25, 26, 7, 5, 0, 0, 26, 12, 1, 0, 0, 0, 27, 28, 7, 6, 0, 0, 28, 14, 1, 0, 0, 0, 1, 0, 0] \ No newline at end of file diff --git a/src/main/java/UnicodeClasses.java b/src/main/java/UnicodeClasses.java new file mode 100644 index 0000000..73f5a79 --- /dev/null +++ b/src/main/java/UnicodeClasses.java @@ -0,0 +1,464 @@ +// Generated from UnicodeClasses.g4 by ANTLR 4.13.2 + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; +import org.antlr.v4.runtime.dfa.DFA; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class UnicodeClasses extends Lexer { + static { + RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); + } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + UNICODE_CLASS_LL = 1, UNICODE_CLASS_LM = 2, UNICODE_CLASS_LO = 3, UNICODE_CLASS_LT = 4, + UNICODE_CLASS_LU = 5, UNICODE_CLASS_ND = 6, UNICODE_CLASS_NL = 7; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[]{ + "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL" + }; + } + + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[]{ + }; + } + + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + + private static String[] makeSymbolicNames() { + return new String[]{ + null, "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL" + }; + } + + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public UnicodeClasses(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + @Override + public String getGrammarFileName() { + return "UnicodeClasses.g4"; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public static final String _serializedATN = + "\u0004\u0000\u0007\u001d\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002" + + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002" + + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0001" + + "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001" + + "\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001" + + "\u0006\u0001\u0006\u0000\u0000\u0007\u0001\u0001\u0003\u0002\u0005\u0003" + + "\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u0001\u0000\u0007\u0246\u0000" + + "az\u00b5\u00b5\u00df\u00f6\u00f8\u00ff\u0101\u0101\u0103\u0103\u0105\u0105" + + "\u0107\u0107\u0109\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111\u0111" + + "\u0113\u0113\u0115\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d\u011d" + + "\u011f\u011f\u0121\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129\u0129" + + "\u012b\u012b\u012d\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135\u0135" + + "\u0137\u0138\u013a\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142\u0142" + + "\u0144\u0144\u0146\u0146\u0148\u0149\u014b\u014b\u014d\u014d\u014f\u014f" + + "\u0151\u0151\u0153\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b\u015b" + + "\u015d\u015d\u015f\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167\u0167" + + "\u0169\u0169\u016b\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173\u0173" + + "\u0175\u0175\u0177\u0177\u017a\u017a\u017c\u017c\u017e\u0180\u0183\u0183" + + "\u0185\u0185\u0188\u0188\u018c\u018d\u0192\u0192\u0195\u0195\u0199\u019b" + + "\u019e\u019e\u01a1\u01a1\u01a3\u01a3\u01a5\u01a5\u01a8\u01a8\u01aa\u01ab" + + "\u01ad\u01ad\u01b0\u01b0\u01b4\u01b4\u01b6\u01b6\u01b9\u01ba\u01bd\u01bf" + + "\u01c6\u01c6\u01c9\u01c9\u01cc\u01cc\u01ce\u01ce\u01d0\u01d0\u01d2\u01d2" + + "\u01d4\u01d4\u01d6\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dd\u01df\u01df" + + "\u01e1\u01e1\u01e3\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb\u01eb" + + "\u01ed\u01ed\u01ef\u01f0\u01f3\u01f3\u01f5\u01f5\u01f9\u01f9\u01fb\u01fb" + + "\u01fd\u01fd\u01ff\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207\u0207" + + "\u0209\u0209\u020b\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213\u0213" + + "\u0215\u0215\u0217\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f\u021f" + + "\u0221\u0221\u0223\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b\u022b" + + "\u022d\u022d\u022f\u022f\u0231\u0231\u0233\u0239\u023c\u023c\u023f\u0240" + + "\u0242\u0242\u0247\u0247\u0249\u0249\u024b\u024b\u024d\u024d\u024f\u0293" + + "\u0295\u02af\u0371\u0371\u0373\u0373\u0377\u0377\u037b\u037d\u0390\u0390" + + "\u03ac\u03ce\u03d0\u03d1\u03d5\u03d7\u03d9\u03d9\u03db\u03db\u03dd\u03dd" + + "\u03df\u03df\u03e1\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9\u03e9" + + "\u03eb\u03eb\u03ed\u03ed\u03ef\u03f3\u03f5\u03f5\u03f8\u03f8\u03fb\u03fc" + + "\u0430\u045f\u0461\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469\u0469" + + "\u046b\u046b\u046d\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475\u0475" + + "\u0477\u0477\u0479\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481\u0481" + + "\u048b\u048b\u048d\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495\u0495" + + "\u0497\u0497\u0499\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1\u04a1" + + "\u04a3\u04a3\u04a5\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad\u04ad" + + "\u04af\u04af\u04b1\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9\u04b9" + + "\u04bb\u04bb\u04bd\u04bd\u04bf\u04bf\u04c2\u04c2\u04c4\u04c4\u04c6\u04c6" + + "\u04c8\u04c8\u04ca\u04ca\u04cc\u04cc\u04ce\u04cf\u04d1\u04d1\u04d3\u04d3" + + "\u04d5\u04d5\u04d7\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df\u04df" + + "\u04e1\u04e1\u04e3\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb\u04eb" + + "\u04ed\u04ed\u04ef\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7\u04f7" + + "\u04f9\u04f9\u04fb\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503\u0503" + + "\u0505\u0505\u0507\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f\u050f" + + "\u0511\u0511\u0513\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b\u051b" + + "\u051d\u051d\u051f\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527\u0527" + + "\u0561\u0587\u1d00\u1d2b\u1d6b\u1d77\u1d79\u1d9a\u1e01\u1e01\u1e03\u1e03" + + "\u1e05\u1e05\u1e07\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f\u1e0f" + + "\u1e11\u1e11\u1e13\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b\u1e1b" + + "\u1e1d\u1e1d\u1e1f\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27\u1e27" + + "\u1e29\u1e29\u1e2b\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33\u1e33" + + "\u1e35\u1e35\u1e37\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f\u1e3f" + + "\u1e41\u1e41\u1e43\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b\u1e4b" + + "\u1e4d\u1e4d\u1e4f\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57\u1e57" + + "\u1e59\u1e59\u1e5b\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63\u1e63" + + "\u1e65\u1e65\u1e67\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f\u1e6f" + + "\u1e71\u1e71\u1e73\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b\u1e7b" + + "\u1e7d\u1e7d\u1e7f\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87\u1e87" + + "\u1e89\u1e89\u1e8b\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93\u1e93" + + "\u1e95\u1e9d\u1e9f\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7\u1ea7" + + "\u1ea9\u1ea9\u1eab\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3\u1eb3" + + "\u1eb5\u1eb5\u1eb7\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf\u1ebf" + + "\u1ec1\u1ec1\u1ec3\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb\u1ecb" + + "\u1ecd\u1ecd\u1ecf\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7\u1ed7" + + "\u1ed9\u1ed9\u1edb\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3\u1ee3" + + "\u1ee5\u1ee5\u1ee7\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef\u1eef" + + "\u1ef1\u1ef1\u1ef3\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb\u1efb" + + "\u1efd\u1efd\u1eff\u1f07\u1f10\u1f15\u1f20\u1f27\u1f30\u1f37\u1f40\u1f45" + + "\u1f50\u1f57\u1f60\u1f67\u1f70\u1f7d\u1f80\u1f87\u1f90\u1f97\u1fa0\u1fa7" + + "\u1fb0\u1fb4\u1fb6\u1fb7\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fc7\u1fd0\u1fd3" + + "\u1fd6\u1fd7\u1fe0\u1fe7\u1ff2\u1ff4\u1ff6\u1ff7\u210a\u210a\u210e\u210f" + + "\u2113\u2113\u212f\u212f\u2134\u2134\u2139\u2139\u213c\u213d\u2146\u2149" + + "\u214e\u214e\u2184\u2184\u2c30\u2c5e\u2c61\u2c61\u2c65\u2c66\u2c68\u2c68" + + "\u2c6a\u2c6a\u2c6c\u2c6c\u2c71\u2c71\u2c73\u2c74\u2c76\u2c7b\u2c81\u2c81" + + "\u2c83\u2c83\u2c85\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d\u2c8d" + + "\u2c8f\u2c8f\u2c91\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99\u2c99" + + "\u2c9b\u2c9b\u2c9d\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5\u2ca5" + + "\u2ca7\u2ca7\u2ca9\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1\u2cb1" + + "\u2cb3\u2cb3\u2cb5\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd\u2cbd" + + "\u2cbf\u2cbf\u2cc1\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9\u2cc9" + + "\u2ccb\u2ccb\u2ccd\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5\u2cd5" + + "\u2cd7\u2cd7\u2cd9\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1\u2ce1" + + "\u2ce3\u2ce4\u2cec\u2cec\u2cee\u2cee\u2cf3\u2cf3\u2d00\u2d25\u2d27\u2d27" + + "\u2d2d\u2d2d\u8000\ua641\u8000\ua641\u8000\ua643\u8000\ua643\u8000\ua645" + + "\u8000\ua645\u8000\ua647\u8000\ua647\u8000\ua649\u8000\ua649\u8000\ua64b" + + "\u8000\ua64b\u8000\ua64d\u8000\ua64d\u8000\ua64f\u8000\ua64f\u8000\ua651" + + "\u8000\ua651\u8000\ua653\u8000\ua653\u8000\ua655\u8000\ua655\u8000\ua657" + + "\u8000\ua657\u8000\ua659\u8000\ua659\u8000\ua65b\u8000\ua65b\u8000\ua65d" + + "\u8000\ua65d\u8000\ua65f\u8000\ua65f\u8000\ua661\u8000\ua661\u8000\ua663" + + "\u8000\ua663\u8000\ua665\u8000\ua665\u8000\ua667\u8000\ua667\u8000\ua669" + + "\u8000\ua669\u8000\ua66b\u8000\ua66b\u8000\ua66d\u8000\ua66d\u8000\ua681" + + "\u8000\ua681\u8000\ua683\u8000\ua683\u8000\ua685\u8000\ua685\u8000\ua687" + + "\u8000\ua687\u8000\ua689\u8000\ua689\u8000\ua68b\u8000\ua68b\u8000\ua68d" + + "\u8000\ua68d\u8000\ua68f\u8000\ua68f\u8000\ua691\u8000\ua691\u8000\ua693" + + "\u8000\ua693\u8000\ua695\u8000\ua695\u8000\ua697\u8000\ua697\u8000\ua723" + + "\u8000\ua723\u8000\ua725\u8000\ua725\u8000\ua727\u8000\ua727\u8000\ua729" + + "\u8000\ua729\u8000\ua72b\u8000\ua72b\u8000\ua72d\u8000\ua72d\u8000\ua72f" + + "\u8000\ua731\u8000\ua733\u8000\ua733\u8000\ua735\u8000\ua735\u8000\ua737" + + "\u8000\ua737\u8000\ua739\u8000\ua739\u8000\ua73b\u8000\ua73b\u8000\ua73d" + + "\u8000\ua73d\u8000\ua73f\u8000\ua73f\u8000\ua741\u8000\ua741\u8000\ua743" + + "\u8000\ua743\u8000\ua745\u8000\ua745\u8000\ua747\u8000\ua747\u8000\ua749" + + "\u8000\ua749\u8000\ua74b\u8000\ua74b\u8000\ua74d\u8000\ua74d\u8000\ua74f" + + "\u8000\ua74f\u8000\ua751\u8000\ua751\u8000\ua753\u8000\ua753\u8000\ua755" + + "\u8000\ua755\u8000\ua757\u8000\ua757\u8000\ua759\u8000\ua759\u8000\ua75b" + + "\u8000\ua75b\u8000\ua75d\u8000\ua75d\u8000\ua75f\u8000\ua75f\u8000\ua761" + + "\u8000\ua761\u8000\ua763\u8000\ua763\u8000\ua765\u8000\ua765\u8000\ua767" + + "\u8000\ua767\u8000\ua769\u8000\ua769\u8000\ua76b\u8000\ua76b\u8000\ua76d" + + "\u8000\ua76d\u8000\ua76f\u8000\ua76f\u8000\ua771\u8000\ua778\u8000\ua77a" + + "\u8000\ua77a\u8000\ua77c\u8000\ua77c\u8000\ua77f\u8000\ua77f\u8000\ua781" + + "\u8000\ua781\u8000\ua783\u8000\ua783\u8000\ua785\u8000\ua785\u8000\ua787" + + "\u8000\ua787\u8000\ua78c\u8000\ua78c\u8000\ua78e\u8000\ua78e\u8000\ua791" + + "\u8000\ua791\u8000\ua793\u8000\ua793\u8000\ua7a1\u8000\ua7a1\u8000\ua7a3" + + "\u8000\ua7a3\u8000\ua7a5\u8000\ua7a5\u8000\ua7a7\u8000\ua7a7\u8000\ua7a9" + + "\u8000\ua7a9\u8000\ua7fa\u8000\ua7fa\u8000\ufb00\u8000\ufb06\u8000\ufb13" + + "\u8000\ufb17\u8000\uff41\u8000\uff5a3\u0000\u02b0\u02c1\u02c6\u02d1\u02e0" + + "\u02e4\u02ec\u02ec\u02ee\u02ee\u0374\u0374\u037a\u037a\u0559\u0559\u0640" + + "\u0640\u06e5\u06e6\u07f4\u07f5\u07fa\u07fa\u081a\u081a\u0824\u0824\u0828" + + "\u0828\u0971\u0971\u0e46\u0e46\u0ec6\u0ec6\u10fc\u10fc\u17d7\u17d7\u1843" + + "\u1843\u1aa7\u1aa7\u1c78\u1c7d\u1d2c\u1d6a\u1d78\u1d78\u1d9b\u1dbf\u2071" + + "\u2071\u207f\u207f\u2090\u209c\u2c7c\u2c7d\u2d6f\u2d6f\u2e2f\u2e2f\u3005" + + "\u3005\u3031\u3035\u303b\u303b\u309d\u309e\u30fc\u30fe\u8000\ua015\u8000" + + "\ua015\u8000\ua4f8\u8000\ua4fd\u8000\ua60c\u8000\ua60c\u8000\ua67f\u8000" + + "\ua67f\u8000\ua717\u8000\ua71f\u8000\ua770\u8000\ua770\u8000\ua788\u8000" + + "\ua788\u8000\ua7f8\u8000\ua7f9\u8000\ua9cf\u8000\ua9cf\u8000\uaa70\u8000" + + "\uaa70\u8000\uaadd\u8000\uaadd\u8000\uaaf3\u8000\uaaf4\u8000\uff70\u8000" + + "\uff70\u8000\uff9e\u8000\uff9f\u0121\u0000\u00aa\u00aa\u00ba\u00ba\u01bb" + + "\u01bb\u01c0\u01c3\u0294\u0294\u05d0\u05ea\u05f0\u05f2\u0620\u063f\u0641" + + "\u064a\u066e\u066f\u0671\u06d3\u06d5\u06d5\u06ee\u06ef\u06fa\u06fc\u06ff" + + "\u06ff\u0710\u0710\u0712\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u0800" + + "\u0815\u0840\u0858\u08a0\u08a0\u08a2\u08ac\u0904\u0939\u093d\u093d\u0950" + + "\u0950\u0958\u0961\u0972\u0977\u0979\u097f\u0985\u098c\u098f\u0990\u0993" + + "\u09a8\u09aa\u09b0\u09b2\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc" + + "\u09dd\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a" + + "\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72" + + "\u0a74\u0a85\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5" + + "\u0ab9\u0abd\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0b05\u0b0c\u0b0f\u0b10\u0b13" + + "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f" + + "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99" + + "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0" + + "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c33\u0c35\u0c39\u0c3d" + + "\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa" + + "\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cde\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05" + + "\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d60\u0d61\u0d7a" + + "\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd\u0dbd\u0dc0\u0dc6\u0e01" + + "\u0e30\u0e32\u0e33\u0e40\u0e45\u0e81\u0e82\u0e84\u0e84\u0e87\u0e88\u0e8a" + + "\u0e8a\u0e8d\u0e8d\u0e94\u0e97\u0e99\u0e9f\u0ea1\u0ea3\u0ea5\u0ea5\u0ea7" + + "\u0ea7\u0eaa\u0eab\u0ead\u0eb0\u0eb2\u0eb3\u0ebd\u0ebd\u0ec0\u0ec4\u0edc" + + "\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49\u0f6c\u0f88\u0f8c\u1000\u102a\u103f" + + "\u103f\u1050\u1055\u105a\u105d\u1061\u1061\u1065\u1066\u106e\u1070\u1075" + + "\u1081\u108e\u108e\u10d0\u10fa\u10fd\u1248\u124a\u124d\u1250\u1256\u1258" + + "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8" + + "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318" + + "\u135a\u1380\u138f\u13a0\u13f4\u1401\u166c\u166f\u167f\u1681\u169a\u16a0" + + "\u16ea\u1700\u170c\u170e\u1711\u1720\u1731\u1740\u1751\u1760\u176c\u176e" + + "\u1770\u1780\u17b3\u17dc\u17dc\u1820\u1842\u1844\u1877\u1880\u18a8\u18aa" + + "\u18aa\u18b0\u18f5\u1900\u191c\u1950\u196d\u1970\u1974\u1980\u19ab\u19c1" + + "\u19c7\u1a00\u1a16\u1a20\u1a54\u1b05\u1b33\u1b45\u1b4b\u1b83\u1ba0\u1bae" + + "\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d\u1c4f\u1c5a\u1c77\u1ce9\u1cec\u1cee" + + "\u1cf1\u1cf5\u1cf6\u2135\u2138\u2d30\u2d67\u2d80\u2d96\u2da0\u2da6\u2da8" + + "\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0\u2dd6\u2dd8" + + "\u2dde\u3006\u3006\u303c\u303c\u3041\u3096\u309f\u309f\u30a1\u30fa\u30ff" + + "\u30ff\u3105\u312d\u3131\u318e\u31a0\u31ba\u31f0\u31ff\u3400\u3400\u4db5" + + "\u4db5\u4e00\u4e00\u8000\u9fcc\u8000\u9fcc\u8000\ua000\u8000\ua014\u8000" + + "\ua016\u8000\ua48c\u8000\ua4d0\u8000\ua4f7\u8000\ua500\u8000\ua60b\u8000" + + "\ua610\u8000\ua61f\u8000\ua62a\u8000\ua62b\u8000\ua66e\u8000\ua66e\u8000" + + "\ua6a0\u8000\ua6e5\u8000\ua7fb\u8000\ua801\u8000\ua803\u8000\ua805\u8000" + + "\ua807\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000" + + "\ua882\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000" + + "\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960\u8000\ua97c\u8000" + + "\ua984\u8000\ua9b2\u8000\uaa00\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000" + + "\uaa44\u8000\uaa4b\u8000\uaa60\u8000\uaa6f\u8000\uaa71\u8000\uaa76\u8000" + + "\uaa7a\u8000\uaa7a\u8000\uaa80\u8000\uaaaf\u8000\uaab1\u8000\uaab1\u8000" + + "\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0\u8000\uaac0\u8000" + + "\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadc\u8000\uaae0\u8000\uaaea\u8000" + + "\uaaf2\u8000\uaaf2\u8000\uab01\u8000\uab06\u8000\uab09\u8000\uab0e\u8000" + + "\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28\u8000\uab2e\u8000" + + "\uabc0\u8000\uabe2\u8000\uac00\u8000\uac00\u8000\ud7a3\u8000\ud7a3\u8000" + + "\ud7b0\u8000\ud7c6\u8000\ud7cb\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000" + + "\ufa70\u8000\ufad9\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f\u8000\ufb28\u8000" + + "\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e\u8000\ufb3e\u8000" + + "\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46\u8000\ufbb1\u8000" + + "\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92\u8000\ufdc7\u8000" + + "\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76\u8000\ufefc\u8000" + + "\uff66\u8000\uff6f\u8000\uff71\u8000\uff9d\u8000\uffa0\u8000\uffbe\u8000" + + "\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2\u8000\uffd7\u8000" + + "\uffda\u8000\uffdc\n\u0000\u01c5\u01c5\u01c8\u01c8\u01cb\u01cb\u01f2\u01f2" + + "\u1f88\u1f8f\u1f98\u1f9f\u1fa8\u1faf\u1fbc\u1fbc\u1fcc\u1fcc\u1ffc\u1ffc" + + "\u0240\u0000AZ\u00c0\u00d6\u00d8\u00de\u0100\u0100\u0102\u0102\u0104\u0104" + + "\u0106\u0106\u0108\u0108\u010a\u010a\u010c\u010c\u010e\u010e\u0110\u0110" + + "\u0112\u0112\u0114\u0114\u0116\u0116\u0118\u0118\u011a\u011a\u011c\u011c" + + "\u011e\u011e\u0120\u0120\u0122\u0122\u0124\u0124\u0126\u0126\u0128\u0128" + + "\u012a\u012a\u012c\u012c\u012e\u012e\u0130\u0130\u0132\u0132\u0134\u0134" + + "\u0136\u0136\u0139\u0139\u013b\u013b\u013d\u013d\u013f\u013f\u0141\u0141" + + "\u0143\u0143\u0145\u0145\u0147\u0147\u014a\u014a\u014c\u014c\u014e\u014e" + + "\u0150\u0150\u0152\u0152\u0154\u0154\u0156\u0156\u0158\u0158\u015a\u015a" + + "\u015c\u015c\u015e\u015e\u0160\u0160\u0162\u0162\u0164\u0164\u0166\u0166" + + "\u0168\u0168\u016a\u016a\u016c\u016c\u016e\u016e\u0170\u0170\u0172\u0172" + + "\u0174\u0174\u0176\u0176\u0178\u0179\u017b\u017b\u017d\u017d\u0181\u0182" + + "\u0184\u0184\u0186\u0187\u0189\u018b\u018e\u0191\u0193\u0194\u0196\u0198" + + "\u019c\u019d\u019f\u01a0\u01a2\u01a2\u01a4\u01a4\u01a6\u01a7\u01a9\u01a9" + + "\u01ac\u01ac\u01ae\u01af\u01b1\u01b3\u01b5\u01b5\u01b7\u01b8\u01bc\u01bc" + + "\u01c4\u01c4\u01c7\u01c7\u01ca\u01ca\u01cd\u01cd\u01cf\u01cf\u01d1\u01d1" + + "\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7\u01d9\u01d9\u01db\u01db\u01de\u01de" + + "\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4\u01e6\u01e6\u01e8\u01e8\u01ea\u01ea" + + "\u01ec\u01ec\u01ee\u01ee\u01f1\u01f1\u01f4\u01f4\u01f6\u01f8\u01fa\u01fa" + + "\u01fc\u01fc\u01fe\u01fe\u0200\u0200\u0202\u0202\u0204\u0204\u0206\u0206" + + "\u0208\u0208\u020a\u020a\u020c\u020c\u020e\u020e\u0210\u0210\u0212\u0212" + + "\u0214\u0214\u0216\u0216\u0218\u0218\u021a\u021a\u021c\u021c\u021e\u021e" + + "\u0220\u0220\u0222\u0222\u0224\u0224\u0226\u0226\u0228\u0228\u022a\u022a" + + "\u022c\u022c\u022e\u022e\u0230\u0230\u0232\u0232\u023a\u023b\u023d\u023e" + + "\u0241\u0241\u0243\u0246\u0248\u0248\u024a\u024a\u024c\u024c\u024e\u024e" + + "\u0370\u0370\u0372\u0372\u0376\u0376\u0386\u0386\u0388\u038a\u038c\u038c" + + "\u038e\u038f\u0391\u03a1\u03a3\u03ab\u03cf\u03cf\u03d2\u03d4\u03d8\u03d8" + + "\u03da\u03da\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03e2\u03e4\u03e4" + + "\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea\u03ec\u03ec\u03ee\u03ee\u03f4\u03f4" + + "\u03f7\u03f7\u03f9\u03fa\u03fd\u042f\u0460\u0460\u0462\u0462\u0464\u0464" + + "\u0466\u0466\u0468\u0468\u046a\u046a\u046c\u046c\u046e\u046e\u0470\u0470" + + "\u0472\u0472\u0474\u0474\u0476\u0476\u0478\u0478\u047a\u047a\u047c\u047c" + + "\u047e\u047e\u0480\u0480\u048a\u048a\u048c\u048c\u048e\u048e\u0490\u0490" + + "\u0492\u0492\u0494\u0494\u0496\u0496\u0498\u0498\u049a\u049a\u049c\u049c" + + "\u049e\u049e\u04a0\u04a0\u04a2\u04a2\u04a4\u04a4\u04a6\u04a6\u04a8\u04a8" + + "\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae\u04b0\u04b0\u04b2\u04b2\u04b4\u04b4" + + "\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba\u04bc\u04bc\u04be\u04be\u04c0\u04c1" + + "\u04c3\u04c3\u04c5\u04c5\u04c7\u04c7\u04c9\u04c9\u04cb\u04cb\u04cd\u04cd" + + "\u04d0\u04d0\u04d2\u04d2\u04d4\u04d4\u04d6\u04d6\u04d8\u04d8\u04da\u04da" + + "\u04dc\u04dc\u04de\u04de\u04e0\u04e0\u04e2\u04e2\u04e4\u04e4\u04e6\u04e6" + + "\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec\u04ee\u04ee\u04f0\u04f0\u04f2\u04f2" + + "\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8\u04fa\u04fa\u04fc\u04fc\u04fe\u04fe" + + "\u0500\u0500\u0502\u0502\u0504\u0504\u0506\u0506\u0508\u0508\u050a\u050a" + + "\u050c\u050c\u050e\u050e\u0510\u0510\u0512\u0512\u0514\u0514\u0516\u0516" + + "\u0518\u0518\u051a\u051a\u051c\u051c\u051e\u051e\u0520\u0520\u0522\u0522" + + "\u0524\u0524\u0526\u0526\u0531\u0556\u10a0\u10c5\u10c7\u10c7\u10cd\u10cd" + + "\u1e00\u1e00\u1e02\u1e02\u1e04\u1e04\u1e06\u1e06\u1e08\u1e08\u1e0a\u1e0a" + + "\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10\u1e12\u1e12\u1e14\u1e14\u1e16\u1e16" + + "\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c\u1e1e\u1e1e\u1e20\u1e20\u1e22\u1e22" + + "\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28\u1e2a\u1e2a\u1e2c\u1e2c\u1e2e\u1e2e" + + "\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34\u1e36\u1e36\u1e38\u1e38\u1e3a\u1e3a" + + "\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40\u1e42\u1e42\u1e44\u1e44\u1e46\u1e46" + + "\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c\u1e4e\u1e4e\u1e50\u1e50\u1e52\u1e52" + + "\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58\u1e5a\u1e5a\u1e5c\u1e5c\u1e5e\u1e5e" + + "\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64\u1e66\u1e66\u1e68\u1e68\u1e6a\u1e6a" + + "\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70\u1e72\u1e72\u1e74\u1e74\u1e76\u1e76" + + "\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c\u1e7e\u1e7e\u1e80\u1e80\u1e82\u1e82" + + "\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88\u1e8a\u1e8a\u1e8c\u1e8c\u1e8e\u1e8e" + + "\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94\u1e9e\u1e9e\u1ea0\u1ea0\u1ea2\u1ea2" + + "\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8\u1eaa\u1eaa\u1eac\u1eac\u1eae\u1eae" + + "\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4\u1eb6\u1eb6\u1eb8\u1eb8\u1eba\u1eba" + + "\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0\u1ec2\u1ec2\u1ec4\u1ec4\u1ec6\u1ec6" + + "\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc\u1ece\u1ece\u1ed0\u1ed0\u1ed2\u1ed2" + + "\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8\u1eda\u1eda\u1edc\u1edc\u1ede\u1ede" + + "\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4\u1ee6\u1ee6\u1ee8\u1ee8\u1eea\u1eea" + + "\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0\u1ef2\u1ef2\u1ef4\u1ef4\u1ef6\u1ef6" + + "\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc\u1efe\u1efe\u1f08\u1f0f\u1f18\u1f1d" + + "\u1f28\u1f2f\u1f38\u1f3f\u1f48\u1f4d\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d" + + "\u1f5f\u1f5f\u1f68\u1f6f\u1fb8\u1fbb\u1fc8\u1fcb\u1fd8\u1fdb\u1fe8\u1fec" + + "\u1ff8\u1ffb\u2102\u2102\u2107\u2107\u210b\u210d\u2110\u2112\u2115\u2115" + + "\u2119\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u2130\u2133" + + "\u213e\u213f\u2145\u2145\u2183\u2183\u2c00\u2c2e\u2c60\u2c60\u2c62\u2c64" + + "\u2c67\u2c67\u2c69\u2c69\u2c6b\u2c6b\u2c6d\u2c70\u2c72\u2c72\u2c75\u2c75" + + "\u2c7e\u2c80\u2c82\u2c82\u2c84\u2c84\u2c86\u2c86\u2c88\u2c88\u2c8a\u2c8a" + + "\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90\u2c92\u2c92\u2c94\u2c94\u2c96\u2c96" + + "\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c\u2c9e\u2c9e\u2ca0\u2ca0\u2ca2\u2ca2" + + "\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8\u2caa\u2caa\u2cac\u2cac\u2cae\u2cae" + + "\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4\u2cb6\u2cb6\u2cb8\u2cb8\u2cba\u2cba" + + "\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0\u2cc2\u2cc2\u2cc4\u2cc4\u2cc6\u2cc6" + + "\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc\u2cce\u2cce\u2cd0\u2cd0\u2cd2\u2cd2" + + "\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8\u2cda\u2cda\u2cdc\u2cdc\u2cde\u2cde" + + "\u2ce0\u2ce0\u2ce2\u2ce2\u2ceb\u2ceb\u2ced\u2ced\u2cf2\u2cf2\u8000\ua640" + + "\u8000\ua640\u8000\ua642\u8000\ua642\u8000\ua644\u8000\ua644\u8000\ua646" + + "\u8000\ua646\u8000\ua648\u8000\ua648\u8000\ua64a\u8000\ua64a\u8000\ua64c" + + "\u8000\ua64c\u8000\ua64e\u8000\ua64e\u8000\ua650\u8000\ua650\u8000\ua652" + + "\u8000\ua652\u8000\ua654\u8000\ua654\u8000\ua656\u8000\ua656\u8000\ua658" + + "\u8000\ua658\u8000\ua65a\u8000\ua65a\u8000\ua65c\u8000\ua65c\u8000\ua65e" + + "\u8000\ua65e\u8000\ua660\u8000\ua660\u8000\ua662\u8000\ua662\u8000\ua664" + + "\u8000\ua664\u8000\ua666\u8000\ua666\u8000\ua668\u8000\ua668\u8000\ua66a" + + "\u8000\ua66a\u8000\ua66c\u8000\ua66c\u8000\ua680\u8000\ua680\u8000\ua682" + + "\u8000\ua682\u8000\ua684\u8000\ua684\u8000\ua686\u8000\ua686\u8000\ua688" + + "\u8000\ua688\u8000\ua68a\u8000\ua68a\u8000\ua68c\u8000\ua68c\u8000\ua68e" + + "\u8000\ua68e\u8000\ua690\u8000\ua690\u8000\ua692\u8000\ua692\u8000\ua694" + + "\u8000\ua694\u8000\ua696\u8000\ua696\u8000\ua722\u8000\ua722\u8000\ua724" + + "\u8000\ua724\u8000\ua726\u8000\ua726\u8000\ua728\u8000\ua728\u8000\ua72a" + + "\u8000\ua72a\u8000\ua72c\u8000\ua72c\u8000\ua72e\u8000\ua72e\u8000\ua732" + + "\u8000\ua732\u8000\ua734\u8000\ua734\u8000\ua736\u8000\ua736\u8000\ua738" + + "\u8000\ua738\u8000\ua73a\u8000\ua73a\u8000\ua73c\u8000\ua73c\u8000\ua73e" + + "\u8000\ua73e\u8000\ua740\u8000\ua740\u8000\ua742\u8000\ua742\u8000\ua744" + + "\u8000\ua744\u8000\ua746\u8000\ua746\u8000\ua748\u8000\ua748\u8000\ua74a" + + "\u8000\ua74a\u8000\ua74c\u8000\ua74c\u8000\ua74e\u8000\ua74e\u8000\ua750" + + "\u8000\ua750\u8000\ua752\u8000\ua752\u8000\ua754\u8000\ua754\u8000\ua756" + + "\u8000\ua756\u8000\ua758\u8000\ua758\u8000\ua75a\u8000\ua75a\u8000\ua75c" + + "\u8000\ua75c\u8000\ua75e\u8000\ua75e\u8000\ua760\u8000\ua760\u8000\ua762" + + "\u8000\ua762\u8000\ua764\u8000\ua764\u8000\ua766\u8000\ua766\u8000\ua768" + + "\u8000\ua768\u8000\ua76a\u8000\ua76a\u8000\ua76c\u8000\ua76c\u8000\ua76e" + + "\u8000\ua76e\u8000\ua779\u8000\ua779\u8000\ua77b\u8000\ua77b\u8000\ua77d" + + "\u8000\ua77e\u8000\ua780\u8000\ua780\u8000\ua782\u8000\ua782\u8000\ua784" + + "\u8000\ua784\u8000\ua786\u8000\ua786\u8000\ua78b\u8000\ua78b\u8000\ua78d" + + "\u8000\ua78d\u8000\ua790\u8000\ua790\u8000\ua792\u8000\ua792\u8000\ua7a0" + + "\u8000\ua7a0\u8000\ua7a2\u8000\ua7a2\u8000\ua7a4\u8000\ua7a4\u8000\ua7a6" + + "\u8000\ua7a6\u8000\ua7a8\u8000\ua7a8\u8000\ua7aa\u8000\ua7aa\u8000\uff21" + + "\u8000\uff3a#\u000009\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f" + + "\u09e6\u09ef\u0a66\u0a6f\u0ae6\u0aef\u0b66\u0b6f\u0be6\u0bef\u0c66\u0c6f" + + "\u0ce6\u0cef\u0d66\u0d6f\u0e50\u0e59\u0ed0\u0ed9\u0f20\u0f29\u1040\u1049" + + "\u1090\u1099\u17e0\u17e9\u1810\u1819\u1946\u194f\u19d0\u19d9\u1a80\u1a89" + + "\u1a90\u1a99\u1b50\u1b59\u1bb0\u1bb9\u1c40\u1c49\u1c50\u1c59\u8000\ua620" + + "\u8000\ua629\u8000\ua8d0\u8000\ua8d9\u8000\ua900\u8000\ua909\u8000\ua9d0" + + "\u8000\ua9d9\u8000\uaa50\u8000\uaa59\u8000\uabf0\u8000\uabf9\u8000\uff10" + + "\u8000\uff19\u0007\u0000\u16ee\u16f0\u2160\u2182\u2185\u2188\u3007\u3007" + + "\u3021\u3029\u3038\u303a\u8000\ua6e6\u8000\ua6ef\u001c\u0000\u0001\u0001" + + "\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001" + + "\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000" + + "\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000" + + "\u0000\u0001\u000f\u0001\u0000\u0000\u0000\u0003\u0011\u0001\u0000\u0000" + + "\u0000\u0005\u0013\u0001\u0000\u0000\u0000\u0007\u0015\u0001\u0000\u0000" + + "\u0000\t\u0017\u0001\u0000\u0000\u0000\u000b\u0019\u0001\u0000\u0000\u0000" + + "\r\u001b\u0001\u0000\u0000\u0000\u000f\u0010\u0007\u0000\u0000\u0000\u0010" + + "\u0002\u0001\u0000\u0000\u0000\u0011\u0012\u0007\u0001\u0000\u0000\u0012" + + "\u0004\u0001\u0000\u0000\u0000\u0013\u0014\u0007\u0002\u0000\u0000\u0014" + + "\u0006\u0001\u0000\u0000\u0000\u0015\u0016\u0007\u0003\u0000\u0000\u0016" + + "\b\u0001\u0000\u0000\u0000\u0017\u0018\u0007\u0004\u0000\u0000\u0018\n" + + "\u0001\u0000\u0000\u0000\u0019\u001a\u0007\u0005\u0000\u0000\u001a\f\u0001" + + "\u0000\u0000\u0000\u001b\u001c\u0007\u0006\u0000\u0000\u001c\u000e\u0001" + + "\u0000\u0000\u0000\u0001\u0000\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/main/java/UnicodeClasses.tokens b/src/main/java/UnicodeClasses.tokens new file mode 100644 index 0000000..bd91da7 --- /dev/null +++ b/src/main/java/UnicodeClasses.tokens @@ -0,0 +1,7 @@ +UNICODE_CLASS_LL=1 +UNICODE_CLASS_LM=2 +UNICODE_CLASS_LO=3 +UNICODE_CLASS_LT=4 +UNICODE_CLASS_LU=5 +UNICODE_CLASS_ND=6 +UNICODE_CLASS_NL=7 diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.interp deleted file mode 100644 index cfd8d38..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.interp +++ /dev/null @@ -1,478 +0,0 @@ -token literal names: -null -null -null -null -null -null -null -null -null -null -'alignas' -'alignof' -'asm' -'auto' -'bool' -'break' -'case' -'catch' -'char' -'char16_t' -'char32_t' -'class' -'const' -'constexpr' -'const_cast' -'continue' -'decltype' -'default' -'delete' -'do' -'double' -'dynamic_cast' -'else' -'enum' -'explicit' -'export' -'extern' -'false' -'final' -'float' -'for' -'friend' -'goto' -'if' -'inline' -'int' -'long' -'mutable' -'namespace' -'new' -'noexcept' -'nullptr' -'operator' -'override' -'private' -'protected' -'public' -'register' -'reinterpret_cast' -'return' -'short' -'signed' -'sizeof' -'static' -'static_assert' -'static_cast' -'struct' -'switch' -'template' -'this' -'thread_local' -'throw' -'true' -'try' -'typedef' -'typeid' -'typename' -'union' -'unsigned' -'using' -'virtual' -'void' -'volatile' -'wchar_t' -'while' -'(' -')' -'[' -']' -'{' -'}' -'+' -'-' -'*' -'/' -'%' -'^' -'&' -'|' -'~' -null -'=' -'<' -'>' -'+=' -'-=' -'*=' -'/=' -'%=' -'^=' -'&=' -'|=' -'<<=' -'>>=' -'==' -'!=' -'<=' -'>=' -null -null -'++' -'--' -',' -'->*' -'->' -'?' -':' -'::' -';' -'.' -'.*' -'...' -null -null -null -null -null -null -null -null -null -null -null -null -null -null - -token symbolic names: -null -IntegerLiteral -CharacterLiteral -FloatingLiteral -StringLiteral -BooleanLiteral -PointerLiteral -UserDefinedLiteral -MultiLineMacro -Directive -Alignas -Alignof -Asm -Auto -Bool -Break -Case -Catch -Char -Char16 -Char32 -Class -Const -Constexpr -Const_cast -Continue -Decltype -Default -Delete -Do -Double -Dynamic_cast -Else -Enum -Explicit -Export -Extern -False_ -Final -Float -For -Friend -Goto -If -Inline -Int -Long -Mutable -Namespace -New -Noexcept -Nullptr -Operator -Override -Private -Protected -Public -Register -Reinterpret_cast -Return -Short -Signed -Sizeof -Static -Static_assert -Static_cast -Struct -Switch -Template -This -Thread_local -Throw -True_ -Try -Typedef -Typeid_ -Typename_ -Union -Unsigned -Using -Virtual -Void -Volatile -Wchar -While -LeftParen -RightParen -LeftBracket -RightBracket -LeftBrace -RightBrace -Plus -Minus -Star -Div -Mod -Caret -And -Or -Tilde -Not -Assign -Less -Greater -PlusAssign -MinusAssign -StarAssign -DivAssign -ModAssign -XorAssign -AndAssign -OrAssign -LeftShiftAssign -RightShiftAssign -Equal -NotEqual -LessEqual -GreaterEqual -AndAnd -OrOr -PlusPlus -MinusMinus -Comma -ArrowStar -Arrow -Question -Colon -Doublecolon -Semi -Dot -DotStar -Ellipsis -Identifier -DecimalLiteral -OctalLiteral -HexadecimalLiteral -BinaryLiteral -Integersuffix -UserDefinedIntegerLiteral -UserDefinedFloatingLiteral -UserDefinedStringLiteral -UserDefinedCharacterLiteral -Whitespace -Newline -BlockComment -LineComment - -rule names: -IntegerLiteral -CharacterLiteral -FloatingLiteral -StringLiteral -BooleanLiteral -PointerLiteral -UserDefinedLiteral -MultiLineMacro -Directive -Alignas -Alignof -Asm -Auto -Bool -Break -Case -Catch -Char -Char16 -Char32 -Class -Const -Constexpr -Const_cast -Continue -Decltype -Default -Delete -Do -Double -Dynamic_cast -Else -Enum -Explicit -Export -Extern -False_ -Final -Float -For -Friend -Goto -If -Inline -Int -Long -Mutable -Namespace -New -Noexcept -Nullptr -Operator -Override -Private -Protected -Public -Register -Reinterpret_cast -Return -Short -Signed -Sizeof -Static -Static_assert -Static_cast -Struct -Switch -Template -This -Thread_local -Throw -True_ -Try -Typedef -Typeid_ -Typename_ -Union -Unsigned -Using -Virtual -Void -Volatile -Wchar -While -LeftParen -RightParen -LeftBracket -RightBracket -LeftBrace -RightBrace -Plus -Minus -Star -Div -Mod -Caret -And -Or -Tilde -Not -Assign -Less -Greater -PlusAssign -MinusAssign -StarAssign -DivAssign -ModAssign -XorAssign -AndAssign -OrAssign -LeftShiftAssign -RightShiftAssign -Equal -NotEqual -LessEqual -GreaterEqual -AndAnd -OrOr -PlusPlus -MinusMinus -Comma -ArrowStar -Arrow -Question -Colon -Doublecolon -Semi -Dot -DotStar -Ellipsis -Hexquad -Universalcharactername -Identifier -Identifiernondigit -NONDIGIT -DIGIT -DecimalLiteral -OctalLiteral -HexadecimalLiteral -BinaryLiteral -NONZERODIGIT -OCTALDIGIT -HEXADECIMALDIGIT -BINARYDIGIT -Integersuffix -Unsignedsuffix -Longsuffix -Longlongsuffix -Cchar -Escapesequence -Simpleescapesequence -Octalescapesequence -Hexadecimalescapesequence -Fractionalconstant -Exponentpart -SIGN -Digitsequence -Floatingsuffix -Encodingprefix -Schar -Rawstring -UserDefinedIntegerLiteral -UserDefinedFloatingLiteral -UserDefinedStringLiteral -UserDefinedCharacterLiteral -Udsuffix -Whitespace -Newline -BlockComment -LineComment - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 147, 1460, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 3, 2, 3, 2, 5, 2, 348, 10, 2, 3, 2, 3, 2, 5, 2, 352, 10, 2, 3, 2, 3, 2, 5, 2, 356, 10, 2, 3, 2, 3, 2, 5, 2, 360, 10, 2, 5, 2, 362, 10, 2, 3, 3, 5, 3, 365, 10, 3, 3, 3, 3, 3, 6, 3, 369, 10, 3, 13, 3, 14, 3, 370, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 377, 10, 4, 3, 4, 5, 4, 380, 10, 4, 3, 4, 3, 4, 3, 4, 5, 4, 385, 10, 4, 5, 4, 387, 10, 4, 3, 5, 5, 5, 390, 10, 5, 3, 5, 3, 5, 7, 5, 394, 10, 5, 12, 5, 14, 5, 397, 11, 5, 3, 5, 3, 5, 5, 5, 401, 10, 5, 3, 5, 3, 5, 5, 5, 405, 10, 5, 3, 6, 3, 6, 5, 6, 409, 10, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 417, 10, 8, 3, 9, 3, 9, 7, 9, 421, 10, 9, 12, 9, 14, 9, 424, 11, 9, 3, 9, 3, 9, 5, 9, 428, 10, 9, 3, 9, 6, 9, 431, 10, 9, 13, 9, 14, 9, 432, 3, 9, 6, 9, 436, 10, 9, 13, 9, 14, 9, 437, 3, 9, 3, 9, 3, 10, 3, 10, 7, 10, 444, 10, 10, 12, 10, 14, 10, 447, 11, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 87, 3, 87, 3, 88, 3, 88, 3, 89, 3, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 3, 93, 3, 93, 3, 94, 3, 94, 3, 95, 3, 95, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 3, 98, 3, 99, 3, 99, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1035, 10, 101, 3, 102, 3, 102, 3, 103, 3, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 1092, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 1098, 10, 120, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 1148, 10, 134, 3, 135, 3, 135, 3, 135, 7, 135, 1153, 10, 135, 12, 135, 14, 135, 1156, 11, 135, 3, 136, 3, 136, 5, 136, 1160, 10, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1168, 10, 139, 3, 139, 7, 139, 1171, 10, 139, 12, 139, 14, 139, 1174, 11, 139, 3, 140, 3, 140, 5, 140, 1178, 10, 140, 3, 140, 7, 140, 1181, 10, 140, 12, 140, 14, 140, 1184, 11, 140, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 1190, 10, 141, 3, 141, 3, 141, 5, 141, 1194, 10, 141, 3, 141, 7, 141, 1197, 10, 141, 12, 141, 14, 141, 1200, 11, 141, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 1206, 10, 142, 3, 142, 3, 142, 5, 142, 1210, 10, 142, 3, 142, 7, 142, 1213, 10, 142, 12, 142, 14, 142, 1216, 11, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 5, 147, 1228, 10, 147, 3, 147, 3, 147, 5, 147, 1232, 10, 147, 3, 147, 3, 147, 5, 147, 1236, 10, 147, 3, 147, 3, 147, 5, 147, 1240, 10, 147, 5, 147, 1242, 10, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 1252, 10, 150, 3, 151, 3, 151, 3, 151, 5, 151, 1257, 10, 151, 3, 152, 3, 152, 3, 152, 5, 152, 1262, 10, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1285, 10, 153, 3, 153, 5, 153, 1288, 10, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1294, 10, 153, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1307, 10, 154, 3, 155, 3, 155, 3, 155, 3, 155, 6, 155, 1313, 10, 155, 13, 155, 14, 155, 1314, 3, 156, 5, 156, 1318, 10, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 1325, 10, 156, 3, 157, 3, 157, 5, 157, 1329, 10, 157, 3, 157, 3, 157, 3, 157, 5, 157, 1334, 10, 157, 3, 157, 5, 157, 1337, 10, 157, 3, 158, 3, 158, 3, 159, 3, 159, 5, 159, 1343, 10, 159, 3, 159, 7, 159, 1346, 10, 159, 12, 159, 14, 159, 1349, 11, 159, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 5, 161, 1356, 10, 161, 3, 162, 3, 162, 3, 162, 5, 162, 1361, 10, 162, 3, 163, 3, 163, 7, 163, 1365, 10, 163, 12, 163, 14, 163, 1368, 11, 163, 3, 163, 3, 163, 7, 163, 1372, 10, 163, 12, 163, 14, 163, 1375, 11, 163, 3, 163, 3, 163, 7, 163, 1379, 10, 163, 12, 163, 14, 163, 1382, 11, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 5, 164, 1398, 10, 164, 3, 165, 3, 165, 5, 165, 1402, 10, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 5, 165, 1410, 10, 165, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 169, 6, 169, 1421, 10, 169, 13, 169, 14, 169, 1422, 3, 169, 3, 169, 3, 170, 3, 170, 5, 170, 1429, 10, 170, 3, 170, 5, 170, 1432, 10, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 7, 171, 1440, 10, 171, 12, 171, 14, 171, 1443, 11, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 7, 172, 1454, 10, 172, 12, 172, 14, 172, 1457, 11, 172, 3, 172, 3, 172, 4, 422, 1441, 2, 173, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 79, 41, 81, 42, 83, 43, 85, 44, 87, 45, 89, 46, 91, 47, 93, 48, 95, 49, 97, 50, 99, 51, 101, 52, 103, 53, 105, 54, 107, 55, 109, 56, 111, 57, 113, 58, 115, 59, 117, 60, 119, 61, 121, 62, 123, 63, 125, 64, 127, 65, 129, 66, 131, 67, 133, 68, 135, 69, 137, 70, 139, 71, 141, 72, 143, 73, 145, 74, 147, 75, 149, 76, 151, 77, 153, 78, 155, 79, 157, 80, 159, 81, 161, 82, 163, 83, 165, 84, 167, 85, 169, 86, 171, 87, 173, 88, 175, 89, 177, 90, 179, 91, 181, 92, 183, 93, 185, 94, 187, 95, 189, 96, 191, 97, 193, 98, 195, 99, 197, 100, 199, 101, 201, 102, 203, 103, 205, 104, 207, 105, 209, 106, 211, 107, 213, 108, 215, 109, 217, 110, 219, 111, 221, 112, 223, 113, 225, 114, 227, 115, 229, 116, 231, 117, 233, 118, 235, 119, 237, 120, 239, 121, 241, 122, 243, 123, 245, 124, 247, 125, 249, 126, 251, 127, 253, 128, 255, 129, 257, 130, 259, 131, 261, 132, 263, 133, 265, 2, 267, 2, 269, 134, 271, 2, 273, 2, 275, 2, 277, 135, 279, 136, 281, 137, 283, 138, 285, 2, 287, 2, 289, 2, 291, 2, 293, 139, 295, 2, 297, 2, 299, 2, 301, 2, 303, 2, 305, 2, 307, 2, 309, 2, 311, 2, 313, 2, 315, 2, 317, 2, 319, 2, 321, 2, 323, 2, 325, 2, 327, 140, 329, 141, 331, 142, 333, 143, 335, 2, 337, 144, 339, 145, 341, 146, 343, 147, 3, 2, 21, 5, 2, 78, 78, 87, 87, 119, 119, 3, 2, 12, 12, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59, 3, 2, 51, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 3, 2, 50, 51, 4, 2, 87, 87, 119, 119, 4, 2, 78, 78, 110, 110, 6, 2, 12, 12, 15, 15, 41, 41, 94, 94, 4, 2, 45, 45, 47, 47, 6, 2, 72, 72, 78, 78, 104, 104, 110, 110, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 5, 2, 12, 12, 15, 15, 42, 42, 5, 2, 12, 12, 15, 15, 43, 43, 5, 2, 12, 12, 15, 15, 36, 36, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 15, 15, 2, 1527, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 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, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 2, 281, 3, 2, 2, 2, 2, 283, 3, 2, 2, 2, 2, 293, 3, 2, 2, 2, 2, 327, 3, 2, 2, 2, 2, 329, 3, 2, 2, 2, 2, 331, 3, 2, 2, 2, 2, 333, 3, 2, 2, 2, 2, 337, 3, 2, 2, 2, 2, 339, 3, 2, 2, 2, 2, 341, 3, 2, 2, 2, 2, 343, 3, 2, 2, 2, 3, 361, 3, 2, 2, 2, 5, 364, 3, 2, 2, 2, 7, 386, 3, 2, 2, 2, 9, 404, 3, 2, 2, 2, 11, 408, 3, 2, 2, 2, 13, 410, 3, 2, 2, 2, 15, 416, 3, 2, 2, 2, 17, 418, 3, 2, 2, 2, 19, 441, 3, 2, 2, 2, 21, 450, 3, 2, 2, 2, 23, 458, 3, 2, 2, 2, 25, 466, 3, 2, 2, 2, 27, 470, 3, 2, 2, 2, 29, 475, 3, 2, 2, 2, 31, 480, 3, 2, 2, 2, 33, 486, 3, 2, 2, 2, 35, 491, 3, 2, 2, 2, 37, 497, 3, 2, 2, 2, 39, 502, 3, 2, 2, 2, 41, 511, 3, 2, 2, 2, 43, 520, 3, 2, 2, 2, 45, 526, 3, 2, 2, 2, 47, 532, 3, 2, 2, 2, 49, 542, 3, 2, 2, 2, 51, 553, 3, 2, 2, 2, 53, 562, 3, 2, 2, 2, 55, 571, 3, 2, 2, 2, 57, 579, 3, 2, 2, 2, 59, 586, 3, 2, 2, 2, 61, 589, 3, 2, 2, 2, 63, 596, 3, 2, 2, 2, 65, 609, 3, 2, 2, 2, 67, 614, 3, 2, 2, 2, 69, 619, 3, 2, 2, 2, 71, 628, 3, 2, 2, 2, 73, 635, 3, 2, 2, 2, 75, 642, 3, 2, 2, 2, 77, 648, 3, 2, 2, 2, 79, 654, 3, 2, 2, 2, 81, 660, 3, 2, 2, 2, 83, 664, 3, 2, 2, 2, 85, 671, 3, 2, 2, 2, 87, 676, 3, 2, 2, 2, 89, 679, 3, 2, 2, 2, 91, 686, 3, 2, 2, 2, 93, 690, 3, 2, 2, 2, 95, 695, 3, 2, 2, 2, 97, 703, 3, 2, 2, 2, 99, 713, 3, 2, 2, 2, 101, 717, 3, 2, 2, 2, 103, 726, 3, 2, 2, 2, 105, 734, 3, 2, 2, 2, 107, 743, 3, 2, 2, 2, 109, 752, 3, 2, 2, 2, 111, 760, 3, 2, 2, 2, 113, 770, 3, 2, 2, 2, 115, 777, 3, 2, 2, 2, 117, 786, 3, 2, 2, 2, 119, 803, 3, 2, 2, 2, 121, 810, 3, 2, 2, 2, 123, 816, 3, 2, 2, 2, 125, 823, 3, 2, 2, 2, 127, 830, 3, 2, 2, 2, 129, 837, 3, 2, 2, 2, 131, 851, 3, 2, 2, 2, 133, 863, 3, 2, 2, 2, 135, 870, 3, 2, 2, 2, 137, 877, 3, 2, 2, 2, 139, 886, 3, 2, 2, 2, 141, 891, 3, 2, 2, 2, 143, 904, 3, 2, 2, 2, 145, 910, 3, 2, 2, 2, 147, 915, 3, 2, 2, 2, 149, 919, 3, 2, 2, 2, 151, 927, 3, 2, 2, 2, 153, 934, 3, 2, 2, 2, 155, 943, 3, 2, 2, 2, 157, 949, 3, 2, 2, 2, 159, 958, 3, 2, 2, 2, 161, 964, 3, 2, 2, 2, 163, 972, 3, 2, 2, 2, 165, 977, 3, 2, 2, 2, 167, 986, 3, 2, 2, 2, 169, 994, 3, 2, 2, 2, 171, 1000, 3, 2, 2, 2, 173, 1002, 3, 2, 2, 2, 175, 1004, 3, 2, 2, 2, 177, 1006, 3, 2, 2, 2, 179, 1008, 3, 2, 2, 2, 181, 1010, 3, 2, 2, 2, 183, 1012, 3, 2, 2, 2, 185, 1014, 3, 2, 2, 2, 187, 1016, 3, 2, 2, 2, 189, 1018, 3, 2, 2, 2, 191, 1020, 3, 2, 2, 2, 193, 1022, 3, 2, 2, 2, 195, 1024, 3, 2, 2, 2, 197, 1026, 3, 2, 2, 2, 199, 1028, 3, 2, 2, 2, 201, 1034, 3, 2, 2, 2, 203, 1036, 3, 2, 2, 2, 205, 1038, 3, 2, 2, 2, 207, 1040, 3, 2, 2, 2, 209, 1042, 3, 2, 2, 2, 211, 1045, 3, 2, 2, 2, 213, 1048, 3, 2, 2, 2, 215, 1051, 3, 2, 2, 2, 217, 1054, 3, 2, 2, 2, 219, 1057, 3, 2, 2, 2, 221, 1060, 3, 2, 2, 2, 223, 1063, 3, 2, 2, 2, 225, 1066, 3, 2, 2, 2, 227, 1070, 3, 2, 2, 2, 229, 1074, 3, 2, 2, 2, 231, 1077, 3, 2, 2, 2, 233, 1080, 3, 2, 2, 2, 235, 1083, 3, 2, 2, 2, 237, 1091, 3, 2, 2, 2, 239, 1097, 3, 2, 2, 2, 241, 1099, 3, 2, 2, 2, 243, 1102, 3, 2, 2, 2, 245, 1105, 3, 2, 2, 2, 247, 1107, 3, 2, 2, 2, 249, 1111, 3, 2, 2, 2, 251, 1114, 3, 2, 2, 2, 253, 1116, 3, 2, 2, 2, 255, 1118, 3, 2, 2, 2, 257, 1121, 3, 2, 2, 2, 259, 1123, 3, 2, 2, 2, 261, 1125, 3, 2, 2, 2, 263, 1128, 3, 2, 2, 2, 265, 1132, 3, 2, 2, 2, 267, 1147, 3, 2, 2, 2, 269, 1149, 3, 2, 2, 2, 271, 1159, 3, 2, 2, 2, 273, 1161, 3, 2, 2, 2, 275, 1163, 3, 2, 2, 2, 277, 1165, 3, 2, 2, 2, 279, 1175, 3, 2, 2, 2, 281, 1189, 3, 2, 2, 2, 283, 1205, 3, 2, 2, 2, 285, 1217, 3, 2, 2, 2, 287, 1219, 3, 2, 2, 2, 289, 1221, 3, 2, 2, 2, 291, 1223, 3, 2, 2, 2, 293, 1241, 3, 2, 2, 2, 295, 1243, 3, 2, 2, 2, 297, 1245, 3, 2, 2, 2, 299, 1251, 3, 2, 2, 2, 301, 1256, 3, 2, 2, 2, 303, 1261, 3, 2, 2, 2, 305, 1293, 3, 2, 2, 2, 307, 1306, 3, 2, 2, 2, 309, 1308, 3, 2, 2, 2, 311, 1324, 3, 2, 2, 2, 313, 1336, 3, 2, 2, 2, 315, 1338, 3, 2, 2, 2, 317, 1340, 3, 2, 2, 2, 319, 1350, 3, 2, 2, 2, 321, 1355, 3, 2, 2, 2, 323, 1360, 3, 2, 2, 2, 325, 1362, 3, 2, 2, 2, 327, 1397, 3, 2, 2, 2, 329, 1409, 3, 2, 2, 2, 331, 1411, 3, 2, 2, 2, 333, 1414, 3, 2, 2, 2, 335, 1417, 3, 2, 2, 2, 337, 1420, 3, 2, 2, 2, 339, 1431, 3, 2, 2, 2, 341, 1435, 3, 2, 2, 2, 343, 1449, 3, 2, 2, 2, 345, 347, 5, 277, 139, 2, 346, 348, 5, 293, 147, 2, 347, 346, 3, 2, 2, 2, 347, 348, 3, 2, 2, 2, 348, 362, 3, 2, 2, 2, 349, 351, 5, 279, 140, 2, 350, 352, 5, 293, 147, 2, 351, 350, 3, 2, 2, 2, 351, 352, 3, 2, 2, 2, 352, 362, 3, 2, 2, 2, 353, 355, 5, 281, 141, 2, 354, 356, 5, 293, 147, 2, 355, 354, 3, 2, 2, 2, 355, 356, 3, 2, 2, 2, 356, 362, 3, 2, 2, 2, 357, 359, 5, 283, 142, 2, 358, 360, 5, 293, 147, 2, 359, 358, 3, 2, 2, 2, 359, 360, 3, 2, 2, 2, 360, 362, 3, 2, 2, 2, 361, 345, 3, 2, 2, 2, 361, 349, 3, 2, 2, 2, 361, 353, 3, 2, 2, 2, 361, 357, 3, 2, 2, 2, 362, 4, 3, 2, 2, 2, 363, 365, 9, 2, 2, 2, 364, 363, 3, 2, 2, 2, 364, 365, 3, 2, 2, 2, 365, 366, 3, 2, 2, 2, 366, 368, 7, 41, 2, 2, 367, 369, 5, 301, 151, 2, 368, 367, 3, 2, 2, 2, 369, 370, 3, 2, 2, 2, 370, 368, 3, 2, 2, 2, 370, 371, 3, 2, 2, 2, 371, 372, 3, 2, 2, 2, 372, 373, 7, 41, 2, 2, 373, 6, 3, 2, 2, 2, 374, 376, 5, 311, 156, 2, 375, 377, 5, 313, 157, 2, 376, 375, 3, 2, 2, 2, 376, 377, 3, 2, 2, 2, 377, 379, 3, 2, 2, 2, 378, 380, 5, 319, 160, 2, 379, 378, 3, 2, 2, 2, 379, 380, 3, 2, 2, 2, 380, 387, 3, 2, 2, 2, 381, 382, 5, 317, 159, 2, 382, 384, 5, 313, 157, 2, 383, 385, 5, 319, 160, 2, 384, 383, 3, 2, 2, 2, 384, 385, 3, 2, 2, 2, 385, 387, 3, 2, 2, 2, 386, 374, 3, 2, 2, 2, 386, 381, 3, 2, 2, 2, 387, 8, 3, 2, 2, 2, 388, 390, 5, 321, 161, 2, 389, 388, 3, 2, 2, 2, 389, 390, 3, 2, 2, 2, 390, 391, 3, 2, 2, 2, 391, 395, 7, 36, 2, 2, 392, 394, 5, 323, 162, 2, 393, 392, 3, 2, 2, 2, 394, 397, 3, 2, 2, 2, 395, 393, 3, 2, 2, 2, 395, 396, 3, 2, 2, 2, 396, 398, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 398, 405, 7, 36, 2, 2, 399, 401, 5, 321, 161, 2, 400, 399, 3, 2, 2, 2, 400, 401, 3, 2, 2, 2, 401, 402, 3, 2, 2, 2, 402, 403, 7, 84, 2, 2, 403, 405, 5, 325, 163, 2, 404, 389, 3, 2, 2, 2, 404, 400, 3, 2, 2, 2, 405, 10, 3, 2, 2, 2, 406, 409, 5, 75, 38, 2, 407, 409, 5, 145, 73, 2, 408, 406, 3, 2, 2, 2, 408, 407, 3, 2, 2, 2, 409, 12, 3, 2, 2, 2, 410, 411, 5, 103, 52, 2, 411, 14, 3, 2, 2, 2, 412, 417, 5, 327, 164, 2, 413, 417, 5, 329, 165, 2, 414, 417, 5, 331, 166, 2, 415, 417, 5, 333, 167, 2, 416, 412, 3, 2, 2, 2, 416, 413, 3, 2, 2, 2, 416, 414, 3, 2, 2, 2, 416, 415, 3, 2, 2, 2, 417, 16, 3, 2, 2, 2, 418, 430, 7, 37, 2, 2, 419, 421, 10, 3, 2, 2, 420, 419, 3, 2, 2, 2, 421, 424, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 422, 420, 3, 2, 2, 2, 423, 425, 3, 2, 2, 2, 424, 422, 3, 2, 2, 2, 425, 427, 7, 94, 2, 2, 426, 428, 7, 15, 2, 2, 427, 426, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 429, 3, 2, 2, 2, 429, 431, 7, 12, 2, 2, 430, 422, 3, 2, 2, 2, 431, 432, 3, 2, 2, 2, 432, 430, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 435, 3, 2, 2, 2, 434, 436, 10, 3, 2, 2, 435, 434, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 435, 3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 439, 3, 2, 2, 2, 439, 440, 8, 9, 2, 2, 440, 18, 3, 2, 2, 2, 441, 445, 7, 37, 2, 2, 442, 444, 10, 3, 2, 2, 443, 442, 3, 2, 2, 2, 444, 447, 3, 2, 2, 2, 445, 443, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 448, 3, 2, 2, 2, 447, 445, 3, 2, 2, 2, 448, 449, 8, 10, 2, 2, 449, 20, 3, 2, 2, 2, 450, 451, 7, 99, 2, 2, 451, 452, 7, 110, 2, 2, 452, 453, 7, 107, 2, 2, 453, 454, 7, 105, 2, 2, 454, 455, 7, 112, 2, 2, 455, 456, 7, 99, 2, 2, 456, 457, 7, 117, 2, 2, 457, 22, 3, 2, 2, 2, 458, 459, 7, 99, 2, 2, 459, 460, 7, 110, 2, 2, 460, 461, 7, 107, 2, 2, 461, 462, 7, 105, 2, 2, 462, 463, 7, 112, 2, 2, 463, 464, 7, 113, 2, 2, 464, 465, 7, 104, 2, 2, 465, 24, 3, 2, 2, 2, 466, 467, 7, 99, 2, 2, 467, 468, 7, 117, 2, 2, 468, 469, 7, 111, 2, 2, 469, 26, 3, 2, 2, 2, 470, 471, 7, 99, 2, 2, 471, 472, 7, 119, 2, 2, 472, 473, 7, 118, 2, 2, 473, 474, 7, 113, 2, 2, 474, 28, 3, 2, 2, 2, 475, 476, 7, 100, 2, 2, 476, 477, 7, 113, 2, 2, 477, 478, 7, 113, 2, 2, 478, 479, 7, 110, 2, 2, 479, 30, 3, 2, 2, 2, 480, 481, 7, 100, 2, 2, 481, 482, 7, 116, 2, 2, 482, 483, 7, 103, 2, 2, 483, 484, 7, 99, 2, 2, 484, 485, 7, 109, 2, 2, 485, 32, 3, 2, 2, 2, 486, 487, 7, 101, 2, 2, 487, 488, 7, 99, 2, 2, 488, 489, 7, 117, 2, 2, 489, 490, 7, 103, 2, 2, 490, 34, 3, 2, 2, 2, 491, 492, 7, 101, 2, 2, 492, 493, 7, 99, 2, 2, 493, 494, 7, 118, 2, 2, 494, 495, 7, 101, 2, 2, 495, 496, 7, 106, 2, 2, 496, 36, 3, 2, 2, 2, 497, 498, 7, 101, 2, 2, 498, 499, 7, 106, 2, 2, 499, 500, 7, 99, 2, 2, 500, 501, 7, 116, 2, 2, 501, 38, 3, 2, 2, 2, 502, 503, 7, 101, 2, 2, 503, 504, 7, 106, 2, 2, 504, 505, 7, 99, 2, 2, 505, 506, 7, 116, 2, 2, 506, 507, 7, 51, 2, 2, 507, 508, 7, 56, 2, 2, 508, 509, 7, 97, 2, 2, 509, 510, 7, 118, 2, 2, 510, 40, 3, 2, 2, 2, 511, 512, 7, 101, 2, 2, 512, 513, 7, 106, 2, 2, 513, 514, 7, 99, 2, 2, 514, 515, 7, 116, 2, 2, 515, 516, 7, 53, 2, 2, 516, 517, 7, 52, 2, 2, 517, 518, 7, 97, 2, 2, 518, 519, 7, 118, 2, 2, 519, 42, 3, 2, 2, 2, 520, 521, 7, 101, 2, 2, 521, 522, 7, 110, 2, 2, 522, 523, 7, 99, 2, 2, 523, 524, 7, 117, 2, 2, 524, 525, 7, 117, 2, 2, 525, 44, 3, 2, 2, 2, 526, 527, 7, 101, 2, 2, 527, 528, 7, 113, 2, 2, 528, 529, 7, 112, 2, 2, 529, 530, 7, 117, 2, 2, 530, 531, 7, 118, 2, 2, 531, 46, 3, 2, 2, 2, 532, 533, 7, 101, 2, 2, 533, 534, 7, 113, 2, 2, 534, 535, 7, 112, 2, 2, 535, 536, 7, 117, 2, 2, 536, 537, 7, 118, 2, 2, 537, 538, 7, 103, 2, 2, 538, 539, 7, 122, 2, 2, 539, 540, 7, 114, 2, 2, 540, 541, 7, 116, 2, 2, 541, 48, 3, 2, 2, 2, 542, 543, 7, 101, 2, 2, 543, 544, 7, 113, 2, 2, 544, 545, 7, 112, 2, 2, 545, 546, 7, 117, 2, 2, 546, 547, 7, 118, 2, 2, 547, 548, 7, 97, 2, 2, 548, 549, 7, 101, 2, 2, 549, 550, 7, 99, 2, 2, 550, 551, 7, 117, 2, 2, 551, 552, 7, 118, 2, 2, 552, 50, 3, 2, 2, 2, 553, 554, 7, 101, 2, 2, 554, 555, 7, 113, 2, 2, 555, 556, 7, 112, 2, 2, 556, 557, 7, 118, 2, 2, 557, 558, 7, 107, 2, 2, 558, 559, 7, 112, 2, 2, 559, 560, 7, 119, 2, 2, 560, 561, 7, 103, 2, 2, 561, 52, 3, 2, 2, 2, 562, 563, 7, 102, 2, 2, 563, 564, 7, 103, 2, 2, 564, 565, 7, 101, 2, 2, 565, 566, 7, 110, 2, 2, 566, 567, 7, 118, 2, 2, 567, 568, 7, 123, 2, 2, 568, 569, 7, 114, 2, 2, 569, 570, 7, 103, 2, 2, 570, 54, 3, 2, 2, 2, 571, 572, 7, 102, 2, 2, 572, 573, 7, 103, 2, 2, 573, 574, 7, 104, 2, 2, 574, 575, 7, 99, 2, 2, 575, 576, 7, 119, 2, 2, 576, 577, 7, 110, 2, 2, 577, 578, 7, 118, 2, 2, 578, 56, 3, 2, 2, 2, 579, 580, 7, 102, 2, 2, 580, 581, 7, 103, 2, 2, 581, 582, 7, 110, 2, 2, 582, 583, 7, 103, 2, 2, 583, 584, 7, 118, 2, 2, 584, 585, 7, 103, 2, 2, 585, 58, 3, 2, 2, 2, 586, 587, 7, 102, 2, 2, 587, 588, 7, 113, 2, 2, 588, 60, 3, 2, 2, 2, 589, 590, 7, 102, 2, 2, 590, 591, 7, 113, 2, 2, 591, 592, 7, 119, 2, 2, 592, 593, 7, 100, 2, 2, 593, 594, 7, 110, 2, 2, 594, 595, 7, 103, 2, 2, 595, 62, 3, 2, 2, 2, 596, 597, 7, 102, 2, 2, 597, 598, 7, 123, 2, 2, 598, 599, 7, 112, 2, 2, 599, 600, 7, 99, 2, 2, 600, 601, 7, 111, 2, 2, 601, 602, 7, 107, 2, 2, 602, 603, 7, 101, 2, 2, 603, 604, 7, 97, 2, 2, 604, 605, 7, 101, 2, 2, 605, 606, 7, 99, 2, 2, 606, 607, 7, 117, 2, 2, 607, 608, 7, 118, 2, 2, 608, 64, 3, 2, 2, 2, 609, 610, 7, 103, 2, 2, 610, 611, 7, 110, 2, 2, 611, 612, 7, 117, 2, 2, 612, 613, 7, 103, 2, 2, 613, 66, 3, 2, 2, 2, 614, 615, 7, 103, 2, 2, 615, 616, 7, 112, 2, 2, 616, 617, 7, 119, 2, 2, 617, 618, 7, 111, 2, 2, 618, 68, 3, 2, 2, 2, 619, 620, 7, 103, 2, 2, 620, 621, 7, 122, 2, 2, 621, 622, 7, 114, 2, 2, 622, 623, 7, 110, 2, 2, 623, 624, 7, 107, 2, 2, 624, 625, 7, 101, 2, 2, 625, 626, 7, 107, 2, 2, 626, 627, 7, 118, 2, 2, 627, 70, 3, 2, 2, 2, 628, 629, 7, 103, 2, 2, 629, 630, 7, 122, 2, 2, 630, 631, 7, 114, 2, 2, 631, 632, 7, 113, 2, 2, 632, 633, 7, 116, 2, 2, 633, 634, 7, 118, 2, 2, 634, 72, 3, 2, 2, 2, 635, 636, 7, 103, 2, 2, 636, 637, 7, 122, 2, 2, 637, 638, 7, 118, 2, 2, 638, 639, 7, 103, 2, 2, 639, 640, 7, 116, 2, 2, 640, 641, 7, 112, 2, 2, 641, 74, 3, 2, 2, 2, 642, 643, 7, 104, 2, 2, 643, 644, 7, 99, 2, 2, 644, 645, 7, 110, 2, 2, 645, 646, 7, 117, 2, 2, 646, 647, 7, 103, 2, 2, 647, 76, 3, 2, 2, 2, 648, 649, 7, 104, 2, 2, 649, 650, 7, 107, 2, 2, 650, 651, 7, 112, 2, 2, 651, 652, 7, 99, 2, 2, 652, 653, 7, 110, 2, 2, 653, 78, 3, 2, 2, 2, 654, 655, 7, 104, 2, 2, 655, 656, 7, 110, 2, 2, 656, 657, 7, 113, 2, 2, 657, 658, 7, 99, 2, 2, 658, 659, 7, 118, 2, 2, 659, 80, 3, 2, 2, 2, 660, 661, 7, 104, 2, 2, 661, 662, 7, 113, 2, 2, 662, 663, 7, 116, 2, 2, 663, 82, 3, 2, 2, 2, 664, 665, 7, 104, 2, 2, 665, 666, 7, 116, 2, 2, 666, 667, 7, 107, 2, 2, 667, 668, 7, 103, 2, 2, 668, 669, 7, 112, 2, 2, 669, 670, 7, 102, 2, 2, 670, 84, 3, 2, 2, 2, 671, 672, 7, 105, 2, 2, 672, 673, 7, 113, 2, 2, 673, 674, 7, 118, 2, 2, 674, 675, 7, 113, 2, 2, 675, 86, 3, 2, 2, 2, 676, 677, 7, 107, 2, 2, 677, 678, 7, 104, 2, 2, 678, 88, 3, 2, 2, 2, 679, 680, 7, 107, 2, 2, 680, 681, 7, 112, 2, 2, 681, 682, 7, 110, 2, 2, 682, 683, 7, 107, 2, 2, 683, 684, 7, 112, 2, 2, 684, 685, 7, 103, 2, 2, 685, 90, 3, 2, 2, 2, 686, 687, 7, 107, 2, 2, 687, 688, 7, 112, 2, 2, 688, 689, 7, 118, 2, 2, 689, 92, 3, 2, 2, 2, 690, 691, 7, 110, 2, 2, 691, 692, 7, 113, 2, 2, 692, 693, 7, 112, 2, 2, 693, 694, 7, 105, 2, 2, 694, 94, 3, 2, 2, 2, 695, 696, 7, 111, 2, 2, 696, 697, 7, 119, 2, 2, 697, 698, 7, 118, 2, 2, 698, 699, 7, 99, 2, 2, 699, 700, 7, 100, 2, 2, 700, 701, 7, 110, 2, 2, 701, 702, 7, 103, 2, 2, 702, 96, 3, 2, 2, 2, 703, 704, 7, 112, 2, 2, 704, 705, 7, 99, 2, 2, 705, 706, 7, 111, 2, 2, 706, 707, 7, 103, 2, 2, 707, 708, 7, 117, 2, 2, 708, 709, 7, 114, 2, 2, 709, 710, 7, 99, 2, 2, 710, 711, 7, 101, 2, 2, 711, 712, 7, 103, 2, 2, 712, 98, 3, 2, 2, 2, 713, 714, 7, 112, 2, 2, 714, 715, 7, 103, 2, 2, 715, 716, 7, 121, 2, 2, 716, 100, 3, 2, 2, 2, 717, 718, 7, 112, 2, 2, 718, 719, 7, 113, 2, 2, 719, 720, 7, 103, 2, 2, 720, 721, 7, 122, 2, 2, 721, 722, 7, 101, 2, 2, 722, 723, 7, 103, 2, 2, 723, 724, 7, 114, 2, 2, 724, 725, 7, 118, 2, 2, 725, 102, 3, 2, 2, 2, 726, 727, 7, 112, 2, 2, 727, 728, 7, 119, 2, 2, 728, 729, 7, 110, 2, 2, 729, 730, 7, 110, 2, 2, 730, 731, 7, 114, 2, 2, 731, 732, 7, 118, 2, 2, 732, 733, 7, 116, 2, 2, 733, 104, 3, 2, 2, 2, 734, 735, 7, 113, 2, 2, 735, 736, 7, 114, 2, 2, 736, 737, 7, 103, 2, 2, 737, 738, 7, 116, 2, 2, 738, 739, 7, 99, 2, 2, 739, 740, 7, 118, 2, 2, 740, 741, 7, 113, 2, 2, 741, 742, 7, 116, 2, 2, 742, 106, 3, 2, 2, 2, 743, 744, 7, 113, 2, 2, 744, 745, 7, 120, 2, 2, 745, 746, 7, 103, 2, 2, 746, 747, 7, 116, 2, 2, 747, 748, 7, 116, 2, 2, 748, 749, 7, 107, 2, 2, 749, 750, 7, 102, 2, 2, 750, 751, 7, 103, 2, 2, 751, 108, 3, 2, 2, 2, 752, 753, 7, 114, 2, 2, 753, 754, 7, 116, 2, 2, 754, 755, 7, 107, 2, 2, 755, 756, 7, 120, 2, 2, 756, 757, 7, 99, 2, 2, 757, 758, 7, 118, 2, 2, 758, 759, 7, 103, 2, 2, 759, 110, 3, 2, 2, 2, 760, 761, 7, 114, 2, 2, 761, 762, 7, 116, 2, 2, 762, 763, 7, 113, 2, 2, 763, 764, 7, 118, 2, 2, 764, 765, 7, 103, 2, 2, 765, 766, 7, 101, 2, 2, 766, 767, 7, 118, 2, 2, 767, 768, 7, 103, 2, 2, 768, 769, 7, 102, 2, 2, 769, 112, 3, 2, 2, 2, 770, 771, 7, 114, 2, 2, 771, 772, 7, 119, 2, 2, 772, 773, 7, 100, 2, 2, 773, 774, 7, 110, 2, 2, 774, 775, 7, 107, 2, 2, 775, 776, 7, 101, 2, 2, 776, 114, 3, 2, 2, 2, 777, 778, 7, 116, 2, 2, 778, 779, 7, 103, 2, 2, 779, 780, 7, 105, 2, 2, 780, 781, 7, 107, 2, 2, 781, 782, 7, 117, 2, 2, 782, 783, 7, 118, 2, 2, 783, 784, 7, 103, 2, 2, 784, 785, 7, 116, 2, 2, 785, 116, 3, 2, 2, 2, 786, 787, 7, 116, 2, 2, 787, 788, 7, 103, 2, 2, 788, 789, 7, 107, 2, 2, 789, 790, 7, 112, 2, 2, 790, 791, 7, 118, 2, 2, 791, 792, 7, 103, 2, 2, 792, 793, 7, 116, 2, 2, 793, 794, 7, 114, 2, 2, 794, 795, 7, 116, 2, 2, 795, 796, 7, 103, 2, 2, 796, 797, 7, 118, 2, 2, 797, 798, 7, 97, 2, 2, 798, 799, 7, 101, 2, 2, 799, 800, 7, 99, 2, 2, 800, 801, 7, 117, 2, 2, 801, 802, 7, 118, 2, 2, 802, 118, 3, 2, 2, 2, 803, 804, 7, 116, 2, 2, 804, 805, 7, 103, 2, 2, 805, 806, 7, 118, 2, 2, 806, 807, 7, 119, 2, 2, 807, 808, 7, 116, 2, 2, 808, 809, 7, 112, 2, 2, 809, 120, 3, 2, 2, 2, 810, 811, 7, 117, 2, 2, 811, 812, 7, 106, 2, 2, 812, 813, 7, 113, 2, 2, 813, 814, 7, 116, 2, 2, 814, 815, 7, 118, 2, 2, 815, 122, 3, 2, 2, 2, 816, 817, 7, 117, 2, 2, 817, 818, 7, 107, 2, 2, 818, 819, 7, 105, 2, 2, 819, 820, 7, 112, 2, 2, 820, 821, 7, 103, 2, 2, 821, 822, 7, 102, 2, 2, 822, 124, 3, 2, 2, 2, 823, 824, 7, 117, 2, 2, 824, 825, 7, 107, 2, 2, 825, 826, 7, 124, 2, 2, 826, 827, 7, 103, 2, 2, 827, 828, 7, 113, 2, 2, 828, 829, 7, 104, 2, 2, 829, 126, 3, 2, 2, 2, 830, 831, 7, 117, 2, 2, 831, 832, 7, 118, 2, 2, 832, 833, 7, 99, 2, 2, 833, 834, 7, 118, 2, 2, 834, 835, 7, 107, 2, 2, 835, 836, 7, 101, 2, 2, 836, 128, 3, 2, 2, 2, 837, 838, 7, 117, 2, 2, 838, 839, 7, 118, 2, 2, 839, 840, 7, 99, 2, 2, 840, 841, 7, 118, 2, 2, 841, 842, 7, 107, 2, 2, 842, 843, 7, 101, 2, 2, 843, 844, 7, 97, 2, 2, 844, 845, 7, 99, 2, 2, 845, 846, 7, 117, 2, 2, 846, 847, 7, 117, 2, 2, 847, 848, 7, 103, 2, 2, 848, 849, 7, 116, 2, 2, 849, 850, 7, 118, 2, 2, 850, 130, 3, 2, 2, 2, 851, 852, 7, 117, 2, 2, 852, 853, 7, 118, 2, 2, 853, 854, 7, 99, 2, 2, 854, 855, 7, 118, 2, 2, 855, 856, 7, 107, 2, 2, 856, 857, 7, 101, 2, 2, 857, 858, 7, 97, 2, 2, 858, 859, 7, 101, 2, 2, 859, 860, 7, 99, 2, 2, 860, 861, 7, 117, 2, 2, 861, 862, 7, 118, 2, 2, 862, 132, 3, 2, 2, 2, 863, 864, 7, 117, 2, 2, 864, 865, 7, 118, 2, 2, 865, 866, 7, 116, 2, 2, 866, 867, 7, 119, 2, 2, 867, 868, 7, 101, 2, 2, 868, 869, 7, 118, 2, 2, 869, 134, 3, 2, 2, 2, 870, 871, 7, 117, 2, 2, 871, 872, 7, 121, 2, 2, 872, 873, 7, 107, 2, 2, 873, 874, 7, 118, 2, 2, 874, 875, 7, 101, 2, 2, 875, 876, 7, 106, 2, 2, 876, 136, 3, 2, 2, 2, 877, 878, 7, 118, 2, 2, 878, 879, 7, 103, 2, 2, 879, 880, 7, 111, 2, 2, 880, 881, 7, 114, 2, 2, 881, 882, 7, 110, 2, 2, 882, 883, 7, 99, 2, 2, 883, 884, 7, 118, 2, 2, 884, 885, 7, 103, 2, 2, 885, 138, 3, 2, 2, 2, 886, 887, 7, 118, 2, 2, 887, 888, 7, 106, 2, 2, 888, 889, 7, 107, 2, 2, 889, 890, 7, 117, 2, 2, 890, 140, 3, 2, 2, 2, 891, 892, 7, 118, 2, 2, 892, 893, 7, 106, 2, 2, 893, 894, 7, 116, 2, 2, 894, 895, 7, 103, 2, 2, 895, 896, 7, 99, 2, 2, 896, 897, 7, 102, 2, 2, 897, 898, 7, 97, 2, 2, 898, 899, 7, 110, 2, 2, 899, 900, 7, 113, 2, 2, 900, 901, 7, 101, 2, 2, 901, 902, 7, 99, 2, 2, 902, 903, 7, 110, 2, 2, 903, 142, 3, 2, 2, 2, 904, 905, 7, 118, 2, 2, 905, 906, 7, 106, 2, 2, 906, 907, 7, 116, 2, 2, 907, 908, 7, 113, 2, 2, 908, 909, 7, 121, 2, 2, 909, 144, 3, 2, 2, 2, 910, 911, 7, 118, 2, 2, 911, 912, 7, 116, 2, 2, 912, 913, 7, 119, 2, 2, 913, 914, 7, 103, 2, 2, 914, 146, 3, 2, 2, 2, 915, 916, 7, 118, 2, 2, 916, 917, 7, 116, 2, 2, 917, 918, 7, 123, 2, 2, 918, 148, 3, 2, 2, 2, 919, 920, 7, 118, 2, 2, 920, 921, 7, 123, 2, 2, 921, 922, 7, 114, 2, 2, 922, 923, 7, 103, 2, 2, 923, 924, 7, 102, 2, 2, 924, 925, 7, 103, 2, 2, 925, 926, 7, 104, 2, 2, 926, 150, 3, 2, 2, 2, 927, 928, 7, 118, 2, 2, 928, 929, 7, 123, 2, 2, 929, 930, 7, 114, 2, 2, 930, 931, 7, 103, 2, 2, 931, 932, 7, 107, 2, 2, 932, 933, 7, 102, 2, 2, 933, 152, 3, 2, 2, 2, 934, 935, 7, 118, 2, 2, 935, 936, 7, 123, 2, 2, 936, 937, 7, 114, 2, 2, 937, 938, 7, 103, 2, 2, 938, 939, 7, 112, 2, 2, 939, 940, 7, 99, 2, 2, 940, 941, 7, 111, 2, 2, 941, 942, 7, 103, 2, 2, 942, 154, 3, 2, 2, 2, 943, 944, 7, 119, 2, 2, 944, 945, 7, 112, 2, 2, 945, 946, 7, 107, 2, 2, 946, 947, 7, 113, 2, 2, 947, 948, 7, 112, 2, 2, 948, 156, 3, 2, 2, 2, 949, 950, 7, 119, 2, 2, 950, 951, 7, 112, 2, 2, 951, 952, 7, 117, 2, 2, 952, 953, 7, 107, 2, 2, 953, 954, 7, 105, 2, 2, 954, 955, 7, 112, 2, 2, 955, 956, 7, 103, 2, 2, 956, 957, 7, 102, 2, 2, 957, 158, 3, 2, 2, 2, 958, 959, 7, 119, 2, 2, 959, 960, 7, 117, 2, 2, 960, 961, 7, 107, 2, 2, 961, 962, 7, 112, 2, 2, 962, 963, 7, 105, 2, 2, 963, 160, 3, 2, 2, 2, 964, 965, 7, 120, 2, 2, 965, 966, 7, 107, 2, 2, 966, 967, 7, 116, 2, 2, 967, 968, 7, 118, 2, 2, 968, 969, 7, 119, 2, 2, 969, 970, 7, 99, 2, 2, 970, 971, 7, 110, 2, 2, 971, 162, 3, 2, 2, 2, 972, 973, 7, 120, 2, 2, 973, 974, 7, 113, 2, 2, 974, 975, 7, 107, 2, 2, 975, 976, 7, 102, 2, 2, 976, 164, 3, 2, 2, 2, 977, 978, 7, 120, 2, 2, 978, 979, 7, 113, 2, 2, 979, 980, 7, 110, 2, 2, 980, 981, 7, 99, 2, 2, 981, 982, 7, 118, 2, 2, 982, 983, 7, 107, 2, 2, 983, 984, 7, 110, 2, 2, 984, 985, 7, 103, 2, 2, 985, 166, 3, 2, 2, 2, 986, 987, 7, 121, 2, 2, 987, 988, 7, 101, 2, 2, 988, 989, 7, 106, 2, 2, 989, 990, 7, 99, 2, 2, 990, 991, 7, 116, 2, 2, 991, 992, 7, 97, 2, 2, 992, 993, 7, 118, 2, 2, 993, 168, 3, 2, 2, 2, 994, 995, 7, 121, 2, 2, 995, 996, 7, 106, 2, 2, 996, 997, 7, 107, 2, 2, 997, 998, 7, 110, 2, 2, 998, 999, 7, 103, 2, 2, 999, 170, 3, 2, 2, 2, 1000, 1001, 7, 42, 2, 2, 1001, 172, 3, 2, 2, 2, 1002, 1003, 7, 43, 2, 2, 1003, 174, 3, 2, 2, 2, 1004, 1005, 7, 93, 2, 2, 1005, 176, 3, 2, 2, 2, 1006, 1007, 7, 95, 2, 2, 1007, 178, 3, 2, 2, 2, 1008, 1009, 7, 125, 2, 2, 1009, 180, 3, 2, 2, 2, 1010, 1011, 7, 127, 2, 2, 1011, 182, 3, 2, 2, 2, 1012, 1013, 7, 45, 2, 2, 1013, 184, 3, 2, 2, 2, 1014, 1015, 7, 47, 2, 2, 1015, 186, 3, 2, 2, 2, 1016, 1017, 7, 44, 2, 2, 1017, 188, 3, 2, 2, 2, 1018, 1019, 7, 49, 2, 2, 1019, 190, 3, 2, 2, 2, 1020, 1021, 7, 39, 2, 2, 1021, 192, 3, 2, 2, 2, 1022, 1023, 7, 96, 2, 2, 1023, 194, 3, 2, 2, 2, 1024, 1025, 7, 40, 2, 2, 1025, 196, 3, 2, 2, 2, 1026, 1027, 7, 126, 2, 2, 1027, 198, 3, 2, 2, 2, 1028, 1029, 7, 128, 2, 2, 1029, 200, 3, 2, 2, 2, 1030, 1035, 7, 35, 2, 2, 1031, 1032, 7, 112, 2, 2, 1032, 1033, 7, 113, 2, 2, 1033, 1035, 7, 118, 2, 2, 1034, 1030, 3, 2, 2, 2, 1034, 1031, 3, 2, 2, 2, 1035, 202, 3, 2, 2, 2, 1036, 1037, 7, 63, 2, 2, 1037, 204, 3, 2, 2, 2, 1038, 1039, 7, 62, 2, 2, 1039, 206, 3, 2, 2, 2, 1040, 1041, 7, 64, 2, 2, 1041, 208, 3, 2, 2, 2, 1042, 1043, 7, 45, 2, 2, 1043, 1044, 7, 63, 2, 2, 1044, 210, 3, 2, 2, 2, 1045, 1046, 7, 47, 2, 2, 1046, 1047, 7, 63, 2, 2, 1047, 212, 3, 2, 2, 2, 1048, 1049, 7, 44, 2, 2, 1049, 1050, 7, 63, 2, 2, 1050, 214, 3, 2, 2, 2, 1051, 1052, 7, 49, 2, 2, 1052, 1053, 7, 63, 2, 2, 1053, 216, 3, 2, 2, 2, 1054, 1055, 7, 39, 2, 2, 1055, 1056, 7, 63, 2, 2, 1056, 218, 3, 2, 2, 2, 1057, 1058, 7, 96, 2, 2, 1058, 1059, 7, 63, 2, 2, 1059, 220, 3, 2, 2, 2, 1060, 1061, 7, 40, 2, 2, 1061, 1062, 7, 63, 2, 2, 1062, 222, 3, 2, 2, 2, 1063, 1064, 7, 126, 2, 2, 1064, 1065, 7, 63, 2, 2, 1065, 224, 3, 2, 2, 2, 1066, 1067, 7, 62, 2, 2, 1067, 1068, 7, 62, 2, 2, 1068, 1069, 7, 63, 2, 2, 1069, 226, 3, 2, 2, 2, 1070, 1071, 7, 64, 2, 2, 1071, 1072, 7, 64, 2, 2, 1072, 1073, 7, 63, 2, 2, 1073, 228, 3, 2, 2, 2, 1074, 1075, 7, 63, 2, 2, 1075, 1076, 7, 63, 2, 2, 1076, 230, 3, 2, 2, 2, 1077, 1078, 7, 35, 2, 2, 1078, 1079, 7, 63, 2, 2, 1079, 232, 3, 2, 2, 2, 1080, 1081, 7, 62, 2, 2, 1081, 1082, 7, 63, 2, 2, 1082, 234, 3, 2, 2, 2, 1083, 1084, 7, 64, 2, 2, 1084, 1085, 7, 63, 2, 2, 1085, 236, 3, 2, 2, 2, 1086, 1087, 7, 40, 2, 2, 1087, 1092, 7, 40, 2, 2, 1088, 1089, 7, 99, 2, 2, 1089, 1090, 7, 112, 2, 2, 1090, 1092, 7, 102, 2, 2, 1091, 1086, 3, 2, 2, 2, 1091, 1088, 3, 2, 2, 2, 1092, 238, 3, 2, 2, 2, 1093, 1094, 7, 126, 2, 2, 1094, 1098, 7, 126, 2, 2, 1095, 1096, 7, 113, 2, 2, 1096, 1098, 7, 116, 2, 2, 1097, 1093, 3, 2, 2, 2, 1097, 1095, 3, 2, 2, 2, 1098, 240, 3, 2, 2, 2, 1099, 1100, 7, 45, 2, 2, 1100, 1101, 7, 45, 2, 2, 1101, 242, 3, 2, 2, 2, 1102, 1103, 7, 47, 2, 2, 1103, 1104, 7, 47, 2, 2, 1104, 244, 3, 2, 2, 2, 1105, 1106, 7, 46, 2, 2, 1106, 246, 3, 2, 2, 2, 1107, 1108, 7, 47, 2, 2, 1108, 1109, 7, 64, 2, 2, 1109, 1110, 7, 44, 2, 2, 1110, 248, 3, 2, 2, 2, 1111, 1112, 7, 47, 2, 2, 1112, 1113, 7, 64, 2, 2, 1113, 250, 3, 2, 2, 2, 1114, 1115, 7, 65, 2, 2, 1115, 252, 3, 2, 2, 2, 1116, 1117, 7, 60, 2, 2, 1117, 254, 3, 2, 2, 2, 1118, 1119, 7, 60, 2, 2, 1119, 1120, 7, 60, 2, 2, 1120, 256, 3, 2, 2, 2, 1121, 1122, 7, 61, 2, 2, 1122, 258, 3, 2, 2, 2, 1123, 1124, 7, 48, 2, 2, 1124, 260, 3, 2, 2, 2, 1125, 1126, 7, 48, 2, 2, 1126, 1127, 7, 44, 2, 2, 1127, 262, 3, 2, 2, 2, 1128, 1129, 7, 48, 2, 2, 1129, 1130, 7, 48, 2, 2, 1130, 1131, 7, 48, 2, 2, 1131, 264, 3, 2, 2, 2, 1132, 1133, 5, 289, 145, 2, 1133, 1134, 5, 289, 145, 2, 1134, 1135, 5, 289, 145, 2, 1135, 1136, 5, 289, 145, 2, 1136, 266, 3, 2, 2, 2, 1137, 1138, 7, 94, 2, 2, 1138, 1139, 7, 119, 2, 2, 1139, 1140, 3, 2, 2, 2, 1140, 1148, 5, 265, 133, 2, 1141, 1142, 7, 94, 2, 2, 1142, 1143, 7, 87, 2, 2, 1143, 1144, 3, 2, 2, 2, 1144, 1145, 5, 265, 133, 2, 1145, 1146, 5, 265, 133, 2, 1146, 1148, 3, 2, 2, 2, 1147, 1137, 3, 2, 2, 2, 1147, 1141, 3, 2, 2, 2, 1148, 268, 3, 2, 2, 2, 1149, 1154, 5, 271, 136, 2, 1150, 1153, 5, 271, 136, 2, 1151, 1153, 5, 275, 138, 2, 1152, 1150, 3, 2, 2, 2, 1152, 1151, 3, 2, 2, 2, 1153, 1156, 3, 2, 2, 2, 1154, 1152, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 270, 3, 2, 2, 2, 1156, 1154, 3, 2, 2, 2, 1157, 1160, 5, 273, 137, 2, 1158, 1160, 5, 267, 134, 2, 1159, 1157, 3, 2, 2, 2, 1159, 1158, 3, 2, 2, 2, 1160, 272, 3, 2, 2, 2, 1161, 1162, 9, 4, 2, 2, 1162, 274, 3, 2, 2, 2, 1163, 1164, 9, 5, 2, 2, 1164, 276, 3, 2, 2, 2, 1165, 1172, 5, 285, 143, 2, 1166, 1168, 7, 41, 2, 2, 1167, 1166, 3, 2, 2, 2, 1167, 1168, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 1171, 5, 275, 138, 2, 1170, 1167, 3, 2, 2, 2, 1171, 1174, 3, 2, 2, 2, 1172, 1170, 3, 2, 2, 2, 1172, 1173, 3, 2, 2, 2, 1173, 278, 3, 2, 2, 2, 1174, 1172, 3, 2, 2, 2, 1175, 1182, 7, 50, 2, 2, 1176, 1178, 7, 41, 2, 2, 1177, 1176, 3, 2, 2, 2, 1177, 1178, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1181, 5, 287, 144, 2, 1180, 1177, 3, 2, 2, 2, 1181, 1184, 3, 2, 2, 2, 1182, 1180, 3, 2, 2, 2, 1182, 1183, 3, 2, 2, 2, 1183, 280, 3, 2, 2, 2, 1184, 1182, 3, 2, 2, 2, 1185, 1186, 7, 50, 2, 2, 1186, 1190, 7, 122, 2, 2, 1187, 1188, 7, 50, 2, 2, 1188, 1190, 7, 90, 2, 2, 1189, 1185, 3, 2, 2, 2, 1189, 1187, 3, 2, 2, 2, 1190, 1191, 3, 2, 2, 2, 1191, 1198, 5, 289, 145, 2, 1192, 1194, 7, 41, 2, 2, 1193, 1192, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 1195, 3, 2, 2, 2, 1195, 1197, 5, 289, 145, 2, 1196, 1193, 3, 2, 2, 2, 1197, 1200, 3, 2, 2, 2, 1198, 1196, 3, 2, 2, 2, 1198, 1199, 3, 2, 2, 2, 1199, 282, 3, 2, 2, 2, 1200, 1198, 3, 2, 2, 2, 1201, 1202, 7, 50, 2, 2, 1202, 1206, 7, 100, 2, 2, 1203, 1204, 7, 50, 2, 2, 1204, 1206, 7, 68, 2, 2, 1205, 1201, 3, 2, 2, 2, 1205, 1203, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2, 1207, 1214, 5, 291, 146, 2, 1208, 1210, 7, 41, 2, 2, 1209, 1208, 3, 2, 2, 2, 1209, 1210, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1213, 5, 291, 146, 2, 1212, 1209, 3, 2, 2, 2, 1213, 1216, 3, 2, 2, 2, 1214, 1212, 3, 2, 2, 2, 1214, 1215, 3, 2, 2, 2, 1215, 284, 3, 2, 2, 2, 1216, 1214, 3, 2, 2, 2, 1217, 1218, 9, 6, 2, 2, 1218, 286, 3, 2, 2, 2, 1219, 1220, 9, 7, 2, 2, 1220, 288, 3, 2, 2, 2, 1221, 1222, 9, 8, 2, 2, 1222, 290, 3, 2, 2, 2, 1223, 1224, 9, 9, 2, 2, 1224, 292, 3, 2, 2, 2, 1225, 1227, 5, 295, 148, 2, 1226, 1228, 5, 297, 149, 2, 1227, 1226, 3, 2, 2, 2, 1227, 1228, 3, 2, 2, 2, 1228, 1242, 3, 2, 2, 2, 1229, 1231, 5, 295, 148, 2, 1230, 1232, 5, 299, 150, 2, 1231, 1230, 3, 2, 2, 2, 1231, 1232, 3, 2, 2, 2, 1232, 1242, 3, 2, 2, 2, 1233, 1235, 5, 297, 149, 2, 1234, 1236, 5, 295, 148, 2, 1235, 1234, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 1242, 3, 2, 2, 2, 1237, 1239, 5, 299, 150, 2, 1238, 1240, 5, 295, 148, 2, 1239, 1238, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1242, 3, 2, 2, 2, 1241, 1225, 3, 2, 2, 2, 1241, 1229, 3, 2, 2, 2, 1241, 1233, 3, 2, 2, 2, 1241, 1237, 3, 2, 2, 2, 1242, 294, 3, 2, 2, 2, 1243, 1244, 9, 10, 2, 2, 1244, 296, 3, 2, 2, 2, 1245, 1246, 9, 11, 2, 2, 1246, 298, 3, 2, 2, 2, 1247, 1248, 7, 110, 2, 2, 1248, 1252, 7, 110, 2, 2, 1249, 1250, 7, 78, 2, 2, 1250, 1252, 7, 78, 2, 2, 1251, 1247, 3, 2, 2, 2, 1251, 1249, 3, 2, 2, 2, 1252, 300, 3, 2, 2, 2, 1253, 1257, 10, 12, 2, 2, 1254, 1257, 5, 303, 152, 2, 1255, 1257, 5, 267, 134, 2, 1256, 1253, 3, 2, 2, 2, 1256, 1254, 3, 2, 2, 2, 1256, 1255, 3, 2, 2, 2, 1257, 302, 3, 2, 2, 2, 1258, 1262, 5, 305, 153, 2, 1259, 1262, 5, 307, 154, 2, 1260, 1262, 5, 309, 155, 2, 1261, 1258, 3, 2, 2, 2, 1261, 1259, 3, 2, 2, 2, 1261, 1260, 3, 2, 2, 2, 1262, 304, 3, 2, 2, 2, 1263, 1264, 7, 94, 2, 2, 1264, 1294, 7, 41, 2, 2, 1265, 1266, 7, 94, 2, 2, 1266, 1294, 7, 36, 2, 2, 1267, 1268, 7, 94, 2, 2, 1268, 1294, 7, 65, 2, 2, 1269, 1270, 7, 94, 2, 2, 1270, 1294, 7, 94, 2, 2, 1271, 1272, 7, 94, 2, 2, 1272, 1294, 7, 99, 2, 2, 1273, 1274, 7, 94, 2, 2, 1274, 1294, 7, 100, 2, 2, 1275, 1276, 7, 94, 2, 2, 1276, 1294, 7, 104, 2, 2, 1277, 1278, 7, 94, 2, 2, 1278, 1294, 7, 112, 2, 2, 1279, 1280, 7, 94, 2, 2, 1280, 1294, 7, 116, 2, 2, 1281, 1287, 7, 94, 2, 2, 1282, 1284, 7, 15, 2, 2, 1283, 1285, 7, 12, 2, 2, 1284, 1283, 3, 2, 2, 2, 1284, 1285, 3, 2, 2, 2, 1285, 1288, 3, 2, 2, 2, 1286, 1288, 7, 12, 2, 2, 1287, 1282, 3, 2, 2, 2, 1287, 1286, 3, 2, 2, 2, 1288, 1294, 3, 2, 2, 2, 1289, 1290, 7, 94, 2, 2, 1290, 1294, 7, 118, 2, 2, 1291, 1292, 7, 94, 2, 2, 1292, 1294, 7, 120, 2, 2, 1293, 1263, 3, 2, 2, 2, 1293, 1265, 3, 2, 2, 2, 1293, 1267, 3, 2, 2, 2, 1293, 1269, 3, 2, 2, 2, 1293, 1271, 3, 2, 2, 2, 1293, 1273, 3, 2, 2, 2, 1293, 1275, 3, 2, 2, 2, 1293, 1277, 3, 2, 2, 2, 1293, 1279, 3, 2, 2, 2, 1293, 1281, 3, 2, 2, 2, 1293, 1289, 3, 2, 2, 2, 1293, 1291, 3, 2, 2, 2, 1294, 306, 3, 2, 2, 2, 1295, 1296, 7, 94, 2, 2, 1296, 1307, 5, 287, 144, 2, 1297, 1298, 7, 94, 2, 2, 1298, 1299, 5, 287, 144, 2, 1299, 1300, 5, 287, 144, 2, 1300, 1307, 3, 2, 2, 2, 1301, 1302, 7, 94, 2, 2, 1302, 1303, 5, 287, 144, 2, 1303, 1304, 5, 287, 144, 2, 1304, 1305, 5, 287, 144, 2, 1305, 1307, 3, 2, 2, 2, 1306, 1295, 3, 2, 2, 2, 1306, 1297, 3, 2, 2, 2, 1306, 1301, 3, 2, 2, 2, 1307, 308, 3, 2, 2, 2, 1308, 1309, 7, 94, 2, 2, 1309, 1310, 7, 122, 2, 2, 1310, 1312, 3, 2, 2, 2, 1311, 1313, 5, 289, 145, 2, 1312, 1311, 3, 2, 2, 2, 1313, 1314, 3, 2, 2, 2, 1314, 1312, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 310, 3, 2, 2, 2, 1316, 1318, 5, 317, 159, 2, 1317, 1316, 3, 2, 2, 2, 1317, 1318, 3, 2, 2, 2, 1318, 1319, 3, 2, 2, 2, 1319, 1320, 7, 48, 2, 2, 1320, 1325, 5, 317, 159, 2, 1321, 1322, 5, 317, 159, 2, 1322, 1323, 7, 48, 2, 2, 1323, 1325, 3, 2, 2, 2, 1324, 1317, 3, 2, 2, 2, 1324, 1321, 3, 2, 2, 2, 1325, 312, 3, 2, 2, 2, 1326, 1328, 7, 103, 2, 2, 1327, 1329, 5, 315, 158, 2, 1328, 1327, 3, 2, 2, 2, 1328, 1329, 3, 2, 2, 2, 1329, 1330, 3, 2, 2, 2, 1330, 1337, 5, 317, 159, 2, 1331, 1333, 7, 71, 2, 2, 1332, 1334, 5, 315, 158, 2, 1333, 1332, 3, 2, 2, 2, 1333, 1334, 3, 2, 2, 2, 1334, 1335, 3, 2, 2, 2, 1335, 1337, 5, 317, 159, 2, 1336, 1326, 3, 2, 2, 2, 1336, 1331, 3, 2, 2, 2, 1337, 314, 3, 2, 2, 2, 1338, 1339, 9, 13, 2, 2, 1339, 316, 3, 2, 2, 2, 1340, 1347, 5, 275, 138, 2, 1341, 1343, 7, 41, 2, 2, 1342, 1341, 3, 2, 2, 2, 1342, 1343, 3, 2, 2, 2, 1343, 1344, 3, 2, 2, 2, 1344, 1346, 5, 275, 138, 2, 1345, 1342, 3, 2, 2, 2, 1346, 1349, 3, 2, 2, 2, 1347, 1345, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 318, 3, 2, 2, 2, 1349, 1347, 3, 2, 2, 2, 1350, 1351, 9, 14, 2, 2, 1351, 320, 3, 2, 2, 2, 1352, 1353, 7, 119, 2, 2, 1353, 1356, 7, 58, 2, 2, 1354, 1356, 9, 2, 2, 2, 1355, 1352, 3, 2, 2, 2, 1355, 1354, 3, 2, 2, 2, 1356, 322, 3, 2, 2, 2, 1357, 1361, 10, 15, 2, 2, 1358, 1361, 5, 303, 152, 2, 1359, 1361, 5, 267, 134, 2, 1360, 1357, 3, 2, 2, 2, 1360, 1358, 3, 2, 2, 2, 1360, 1359, 3, 2, 2, 2, 1361, 324, 3, 2, 2, 2, 1362, 1366, 7, 36, 2, 2, 1363, 1365, 10, 16, 2, 2, 1364, 1363, 3, 2, 2, 2, 1365, 1368, 3, 2, 2, 2, 1366, 1364, 3, 2, 2, 2, 1366, 1367, 3, 2, 2, 2, 1367, 1369, 3, 2, 2, 2, 1368, 1366, 3, 2, 2, 2, 1369, 1373, 7, 42, 2, 2, 1370, 1372, 10, 17, 2, 2, 1371, 1370, 3, 2, 2, 2, 1372, 1375, 3, 2, 2, 2, 1373, 1371, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1373, 3, 2, 2, 2, 1376, 1380, 7, 43, 2, 2, 1377, 1379, 10, 18, 2, 2, 1378, 1377, 3, 2, 2, 2, 1379, 1382, 3, 2, 2, 2, 1380, 1378, 3, 2, 2, 2, 1380, 1381, 3, 2, 2, 2, 1381, 1383, 3, 2, 2, 2, 1382, 1380, 3, 2, 2, 2, 1383, 1384, 7, 36, 2, 2, 1384, 326, 3, 2, 2, 2, 1385, 1386, 5, 277, 139, 2, 1386, 1387, 5, 335, 168, 2, 1387, 1398, 3, 2, 2, 2, 1388, 1389, 5, 279, 140, 2, 1389, 1390, 5, 335, 168, 2, 1390, 1398, 3, 2, 2, 2, 1391, 1392, 5, 281, 141, 2, 1392, 1393, 5, 335, 168, 2, 1393, 1398, 3, 2, 2, 2, 1394, 1395, 5, 283, 142, 2, 1395, 1396, 5, 335, 168, 2, 1396, 1398, 3, 2, 2, 2, 1397, 1385, 3, 2, 2, 2, 1397, 1388, 3, 2, 2, 2, 1397, 1391, 3, 2, 2, 2, 1397, 1394, 3, 2, 2, 2, 1398, 328, 3, 2, 2, 2, 1399, 1401, 5, 311, 156, 2, 1400, 1402, 5, 313, 157, 2, 1401, 1400, 3, 2, 2, 2, 1401, 1402, 3, 2, 2, 2, 1402, 1403, 3, 2, 2, 2, 1403, 1404, 5, 335, 168, 2, 1404, 1410, 3, 2, 2, 2, 1405, 1406, 5, 317, 159, 2, 1406, 1407, 5, 313, 157, 2, 1407, 1408, 5, 335, 168, 2, 1408, 1410, 3, 2, 2, 2, 1409, 1399, 3, 2, 2, 2, 1409, 1405, 3, 2, 2, 2, 1410, 330, 3, 2, 2, 2, 1411, 1412, 5, 9, 5, 2, 1412, 1413, 5, 335, 168, 2, 1413, 332, 3, 2, 2, 2, 1414, 1415, 5, 5, 3, 2, 1415, 1416, 5, 335, 168, 2, 1416, 334, 3, 2, 2, 2, 1417, 1418, 5, 269, 135, 2, 1418, 336, 3, 2, 2, 2, 1419, 1421, 9, 19, 2, 2, 1420, 1419, 3, 2, 2, 2, 1421, 1422, 3, 2, 2, 2, 1422, 1420, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1424, 3, 2, 2, 2, 1424, 1425, 8, 169, 3, 2, 1425, 338, 3, 2, 2, 2, 1426, 1428, 7, 15, 2, 2, 1427, 1429, 7, 12, 2, 2, 1428, 1427, 3, 2, 2, 2, 1428, 1429, 3, 2, 2, 2, 1429, 1432, 3, 2, 2, 2, 1430, 1432, 7, 12, 2, 2, 1431, 1426, 3, 2, 2, 2, 1431, 1430, 3, 2, 2, 2, 1432, 1433, 3, 2, 2, 2, 1433, 1434, 8, 170, 3, 2, 1434, 340, 3, 2, 2, 2, 1435, 1436, 7, 49, 2, 2, 1436, 1437, 7, 44, 2, 2, 1437, 1441, 3, 2, 2, 2, 1438, 1440, 11, 2, 2, 2, 1439, 1438, 3, 2, 2, 2, 1440, 1443, 3, 2, 2, 2, 1441, 1442, 3, 2, 2, 2, 1441, 1439, 3, 2, 2, 2, 1442, 1444, 3, 2, 2, 2, 1443, 1441, 3, 2, 2, 2, 1444, 1445, 7, 44, 2, 2, 1445, 1446, 7, 49, 2, 2, 1446, 1447, 3, 2, 2, 2, 1447, 1448, 8, 171, 3, 2, 1448, 342, 3, 2, 2, 2, 1449, 1450, 7, 49, 2, 2, 1450, 1451, 7, 49, 2, 2, 1451, 1455, 3, 2, 2, 2, 1452, 1454, 10, 20, 2, 2, 1453, 1452, 3, 2, 2, 2, 1454, 1457, 3, 2, 2, 2, 1455, 1453, 3, 2, 2, 2, 1455, 1456, 3, 2, 2, 2, 1456, 1458, 3, 2, 2, 2, 1457, 1455, 3, 2, 2, 2, 1458, 1459, 8, 172, 3, 2, 1459, 344, 3, 2, 2, 2, 75, 2, 347, 351, 355, 359, 361, 364, 370, 376, 379, 384, 386, 389, 395, 400, 404, 408, 416, 422, 427, 432, 437, 445, 1034, 1091, 1097, 1147, 1152, 1154, 1159, 1167, 1172, 1177, 1182, 1189, 1193, 1198, 1205, 1209, 1214, 1227, 1231, 1235, 1239, 1241, 1251, 1256, 1261, 1284, 1287, 1293, 1306, 1314, 1317, 1324, 1328, 1333, 1336, 1342, 1347, 1355, 1360, 1366, 1373, 1380, 1397, 1401, 1409, 1422, 1428, 1431, 1441, 1455, 4, 2, 3, 2, 8, 2, 2] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.java deleted file mode 100644 index 33cf176..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Lexer.java +++ /dev/null @@ -1,781 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.cpp; - -// Generated from CPP14Lexer.g4 by ANTLR 4.9.1 - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.LexerATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class CPP14Lexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - IntegerLiteral = 1, CharacterLiteral = 2, FloatingLiteral = 3, StringLiteral = 4, - BooleanLiteral = 5, PointerLiteral = 6, UserDefinedLiteral = 7, MultiLineMacro = 8, - Directive = 9, Alignas = 10, Alignof = 11, Asm = 12, Auto = 13, Bool = 14, Break = 15, - Case = 16, Catch = 17, Char = 18, Char16 = 19, Char32 = 20, Class = 21, Const = 22, - Constexpr = 23, Const_cast = 24, Continue = 25, Decltype = 26, Default = 27, Delete = 28, - Do = 29, Double = 30, Dynamic_cast = 31, Else = 32, Enum = 33, Explicit = 34, Export = 35, - Extern = 36, False_ = 37, Final = 38, Float = 39, For = 40, Friend = 41, Goto = 42, - If = 43, Inline = 44, Int = 45, Long = 46, Mutable = 47, Namespace = 48, New = 49, Noexcept = 50, - Nullptr = 51, Operator = 52, Override = 53, Private = 54, Protected = 55, Public = 56, - Register = 57, Reinterpret_cast = 58, Return = 59, Short = 60, Signed = 61, Sizeof = 62, - Static = 63, Static_assert = 64, Static_cast = 65, Struct = 66, Switch = 67, Template = 68, - This = 69, Thread_local = 70, Throw = 71, True_ = 72, Try = 73, Typedef = 74, Typeid_ = 75, - Typename_ = 76, Union = 77, Unsigned = 78, Using = 79, Virtual = 80, Void = 81, Volatile = 82, - Wchar = 83, While = 84, LeftParen = 85, RightParen = 86, LeftBracket = 87, RightBracket = 88, - LeftBrace = 89, RightBrace = 90, Plus = 91, Minus = 92, Star = 93, Div = 94, Mod = 95, - Caret = 96, And = 97, Or = 98, Tilde = 99, Not = 100, Assign = 101, Less = 102, Greater = 103, - PlusAssign = 104, MinusAssign = 105, StarAssign = 106, DivAssign = 107, ModAssign = 108, - XorAssign = 109, AndAssign = 110, OrAssign = 111, LeftShiftAssign = 112, RightShiftAssign = 113, - Equal = 114, NotEqual = 115, LessEqual = 116, GreaterEqual = 117, AndAnd = 118, - OrOr = 119, PlusPlus = 120, MinusMinus = 121, Comma = 122, ArrowStar = 123, Arrow = 124, - Question = 125, Colon = 126, Doublecolon = 127, Semi = 128, Dot = 129, DotStar = 130, - Ellipsis = 131, Identifier = 132, DecimalLiteral = 133, OctalLiteral = 134, HexadecimalLiteral = 135, - BinaryLiteral = 136, Integersuffix = 137, UserDefinedIntegerLiteral = 138, UserDefinedFloatingLiteral = 139, - UserDefinedStringLiteral = 140, UserDefinedCharacterLiteral = 141, Whitespace = 142, - Newline = 143, BlockComment = 144, LineComment = 145; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; - - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - private static String[] makeRuleNames() { - return new String[]{ - "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", - "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", - "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", - "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", - "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", - "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", - "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", - "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", - "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", - "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", - "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", - "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", - "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", - "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", - "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", - "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", - "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", - "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", - "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", - "Semi", "Dot", "DotStar", "Ellipsis", "Hexquad", "Universalcharactername", - "Identifier", "Identifiernondigit", "NONDIGIT", "DIGIT", "DecimalLiteral", - "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "NONZERODIGIT", - "OCTALDIGIT", "HEXADECIMALDIGIT", "BINARYDIGIT", "Integersuffix", "Unsignedsuffix", - "Longsuffix", "Longlongsuffix", "Cchar", "Escapesequence", "Simpleescapesequence", - "Octalescapesequence", "Hexadecimalescapesequence", "Fractionalconstant", - "Exponentpart", "SIGN", "Digitsequence", "Floatingsuffix", "Encodingprefix", - "Schar", "Rawstring", "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", - "UserDefinedStringLiteral", "UserDefinedCharacterLiteral", "Udsuffix", - "Whitespace", "Newline", "BlockComment", "LineComment" - }; - } - - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[]{ - null, null, null, null, null, null, null, null, null, null, "'alignas'", - "'alignof'", "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", - "'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", - "'const_cast'", "'continue'", "'decltype'", "'default'", "'delete'", - "'do'", "'double'", "'dynamic_cast'", "'else'", "'enum'", "'explicit'", - "'export'", "'extern'", "'false'", "'final'", "'float'", "'for'", "'friend'", - "'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", - "'new'", "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", - "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", - "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", "'static_cast'", - "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", "'throw'", - "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", - "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", - "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", - "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", null, "'='", "'<'", "'>'", - "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", "'|='", "'<<='", - "'>>='", "'=='", "'!='", "'<='", "'>='", null, null, "'++'", "'--'", - "','", "'->*'", "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[]{ - null, "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", - "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", - "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", - "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", - "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", - "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", - "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", - "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", - "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", - "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", - "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", - "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", - "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", - "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", - "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", - "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", - "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", - "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", - "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", - "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", - "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", - "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", - "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", - "LineComment" - }; - } - - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - public CPP14Lexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "CPP14Lexer.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public String[] getChannelNames() { - return channelNames; - } - - @Override - public String[] getModeNames() { - return modeNames; - } - - @Override - public ATN getATN() { - return _ATN; - } - - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0093\u05b4\b\1\4" + - "\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n" + - "\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22" + - "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31" + - "\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t" + - " \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t" + - "+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64" + - "\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t" + - "=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4" + - "I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t" + - "T\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_" + - "\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k" + - "\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv" + - "\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t" + - "\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084" + - "\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089" + - "\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d" + - "\4\u008e\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092" + - "\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096" + - "\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b" + - "\t\u009b\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f" + - "\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4" + - "\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8" + - "\4\u00a9\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\3\2\3" + - "\2\5\2\u015c\n\2\3\2\3\2\5\2\u0160\n\2\3\2\3\2\5\2\u0164\n\2\3\2\3\2\5" + - "\2\u0168\n\2\5\2\u016a\n\2\3\3\5\3\u016d\n\3\3\3\3\3\6\3\u0171\n\3\r\3" + - "\16\3\u0172\3\3\3\3\3\4\3\4\5\4\u0179\n\4\3\4\5\4\u017c\n\4\3\4\3\4\3" + - "\4\5\4\u0181\n\4\5\4\u0183\n\4\3\5\5\5\u0186\n\5\3\5\3\5\7\5\u018a\n\5" + - "\f\5\16\5\u018d\13\5\3\5\3\5\5\5\u0191\n\5\3\5\3\5\5\5\u0195\n\5\3\6\3" + - "\6\5\6\u0199\n\6\3\7\3\7\3\b\3\b\3\b\3\b\5\b\u01a1\n\b\3\t\3\t\7\t\u01a5" + - "\n\t\f\t\16\t\u01a8\13\t\3\t\3\t\5\t\u01ac\n\t\3\t\6\t\u01af\n\t\r\t\16" + - "\t\u01b0\3\t\6\t\u01b4\n\t\r\t\16\t\u01b5\3\t\3\t\3\n\3\n\7\n\u01bc\n" + - "\n\f\n\16\n\u01bf\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13" + - "\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3" + - "\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3" + - "\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3" + - "\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3" + - "\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3" + - "\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3" + - "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3" + - "\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3" + - "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3" + - "\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 " + - "\3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3" + - "#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\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\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61" + - "\3\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63" + - "\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\65" + - "\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66" + - "\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\38\38\38\38\3" + - "8\38\38\38\38\38\39\39\39\39\39\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=\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\3A\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3" + - "B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3" + - "E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3" + - "G\3G\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3" + - "K\3K\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3" + - "N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3" + - "Q\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3" + - "U\3U\3U\3U\3U\3U\3V\3V\3W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3\\\3\\\3]\3]\3^" + - "\3^\3_\3_\3`\3`\3a\3a\3b\3b\3c\3c\3d\3d\3e\3e\3e\3e\5e\u040b\ne\3f\3f" + - "\3g\3g\3h\3h\3i\3i\3i\3j\3j\3j\3k\3k\3k\3l\3l\3l\3m\3m\3m\3n\3n\3n\3o" + - "\3o\3o\3p\3p\3p\3q\3q\3q\3q\3r\3r\3r\3r\3s\3s\3s\3t\3t\3t\3u\3u\3u\3v" + - "\3v\3v\3w\3w\3w\3w\3w\5w\u0444\nw\3x\3x\3x\3x\5x\u044a\nx\3y\3y\3y\3z" + - "\3z\3z\3{\3{\3|\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3" + - "\u0080\3\u0081\3\u0081\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0084" + - "\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086" + - "\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086" + - "\5\u0086\u047c\n\u0086\3\u0087\3\u0087\3\u0087\7\u0087\u0481\n\u0087\f" + - "\u0087\16\u0087\u0484\13\u0087\3\u0088\3\u0088\5\u0088\u0488\n\u0088\3" + - "\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b\5\u008b\u0490\n\u008b\3" + - "\u008b\7\u008b\u0493\n\u008b\f\u008b\16\u008b\u0496\13\u008b\3\u008c\3" + - "\u008c\5\u008c\u049a\n\u008c\3\u008c\7\u008c\u049d\n\u008c\f\u008c\16" + - "\u008c\u04a0\13\u008c\3\u008d\3\u008d\3\u008d\3\u008d\5\u008d\u04a6\n" + - "\u008d\3\u008d\3\u008d\5\u008d\u04aa\n\u008d\3\u008d\7\u008d\u04ad\n\u008d" + - "\f\u008d\16\u008d\u04b0\13\u008d\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e" + - "\u04b6\n\u008e\3\u008e\3\u008e\5\u008e\u04ba\n\u008e\3\u008e\7\u008e\u04bd" + - "\n\u008e\f\u008e\16\u008e\u04c0\13\u008e\3\u008f\3\u008f\3\u0090\3\u0090" + - "\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\5\u0093\u04cc\n\u0093" + - "\3\u0093\3\u0093\5\u0093\u04d0\n\u0093\3\u0093\3\u0093\5\u0093\u04d4\n" + - "\u0093\3\u0093\3\u0093\5\u0093\u04d8\n\u0093\5\u0093\u04da\n\u0093\3\u0094" + - "\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\5\u0096\u04e4" + - "\n\u0096\3\u0097\3\u0097\3\u0097\5\u0097\u04e9\n\u0097\3\u0098\3\u0098" + - "\3\u0098\5\u0098\u04ee\n\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099" + - "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099" + - "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u0505" + - "\n\u0099\3\u0099\5\u0099\u0508\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099" + - "\5\u0099\u050e\n\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a" + - "\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u051b\n\u009a\3\u009b" + - "\3\u009b\3\u009b\3\u009b\6\u009b\u0521\n\u009b\r\u009b\16\u009b\u0522" + - "\3\u009c\5\u009c\u0526\n\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c" + - "\5\u009c\u052d\n\u009c\3\u009d\3\u009d\5\u009d\u0531\n\u009d\3\u009d\3" + - "\u009d\3\u009d\5\u009d\u0536\n\u009d\3\u009d\5\u009d\u0539\n\u009d\3\u009e" + - "\3\u009e\3\u009f\3\u009f\5\u009f\u053f\n\u009f\3\u009f\7\u009f\u0542\n" + - "\u009f\f\u009f\16\u009f\u0545\13\u009f\3\u00a0\3\u00a0\3\u00a1\3\u00a1" + - "\3\u00a1\5\u00a1\u054c\n\u00a1\3\u00a2\3\u00a2\3\u00a2\5\u00a2\u0551\n" + - "\u00a2\3\u00a3\3\u00a3\7\u00a3\u0555\n\u00a3\f\u00a3\16\u00a3\u0558\13" + - "\u00a3\3\u00a3\3\u00a3\7\u00a3\u055c\n\u00a3\f\u00a3\16\u00a3\u055f\13" + - "\u00a3\3\u00a3\3\u00a3\7\u00a3\u0563\n\u00a3\f\u00a3\16\u00a3\u0566\13" + - "\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4" + - "\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0576\n\u00a4" + - "\3\u00a5\3\u00a5\5\u00a5\u057a\n\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5" + - "\3\u00a5\3\u00a5\5\u00a5\u0582\n\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7" + - "\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\6\u00a9\u058d\n\u00a9\r\u00a9" + - "\16\u00a9\u058e\3\u00a9\3\u00a9\3\u00aa\3\u00aa\5\u00aa\u0595\n\u00aa" + - "\3\u00aa\5\u00aa\u0598\n\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab" + - "\3\u00ab\7\u00ab\u05a0\n\u00ab\f\u00ab\16\u00ab\u05a3\13\u00ab\3\u00ab" + - "\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\7\u00ac" + - "\u05ae\n\u00ac\f\u00ac\16\u00ac\u05b1\13\u00ac\3\u00ac\3\u00ac\4\u01a6" + - "\u05a1\2\u00ad\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16" + - "\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34" + - "\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g" + - "\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089F" + - "\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009d" + - "P\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1" + - "Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5" + - "d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9" + - "n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00ed" + - "x\u00efy\u00f1z\u00f3{\u00f5|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff" + - "\u0081\u0101\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\2\u010b\2" + - "\u010d\u0086\u010f\2\u0111\2\u0113\2\u0115\u0087\u0117\u0088\u0119\u0089" + - "\u011b\u008a\u011d\2\u011f\2\u0121\2\u0123\2\u0125\u008b\u0127\2\u0129" + - "\2\u012b\2\u012d\2\u012f\2\u0131\2\u0133\2\u0135\2\u0137\2\u0139\2\u013b" + - "\2\u013d\2\u013f\2\u0141\2\u0143\2\u0145\2\u0147\u008c\u0149\u008d\u014b" + - "\u008e\u014d\u008f\u014f\2\u0151\u0090\u0153\u0091\u0155\u0092\u0157\u0093" + - "\3\2\25\5\2NNWWww\3\2\f\f\5\2C\\aac|\3\2\62;\3\2\63;\3\2\629\5\2\62;C" + - "Hch\3\2\62\63\4\2WWww\4\2NNnn\6\2\f\f\17\17))^^\4\2--//\6\2HHNNhhnn\6" + - "\2\f\f\17\17$$^^\5\2\f\f\17\17**\5\2\f\f\17\17++\5\2\f\f\17\17$$\4\2\13" + - "\13\"\"\4\2\f\f\17\17\2\u05f7\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t" + - "\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2" + - "\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2" + - "\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2" + - "+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2" + - "\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2" + - "C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3" + - "\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2" + - "\2\2]\3\2\2\2\2_\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" + - "i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3" + - "\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081" + - "\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2" + - "\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093" + - "\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2" + - "\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5" + - "\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2" + - "\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7" + - "\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2" + - "\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9" + - "\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2" + - "\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db" + - "\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2" + - "\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed" + - "\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2" + - "\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff" + - "\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2\2\2\u0107\3\2\2" + - "\2\2\u010d\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119\3\2\2\2\2\u011b" + - "\3\2\2\2\2\u0125\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2\2\2\u014b\3\2\2" + - "\2\2\u014d\3\2\2\2\2\u0151\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157" + - "\3\2\2\2\3\u0169\3\2\2\2\5\u016c\3\2\2\2\7\u0182\3\2\2\2\t\u0194\3\2\2" + - "\2\13\u0198\3\2\2\2\r\u019a\3\2\2\2\17\u01a0\3\2\2\2\21\u01a2\3\2\2\2" + - "\23\u01b9\3\2\2\2\25\u01c2\3\2\2\2\27\u01ca\3\2\2\2\31\u01d2\3\2\2\2\33" + - "\u01d6\3\2\2\2\35\u01db\3\2\2\2\37\u01e0\3\2\2\2!\u01e6\3\2\2\2#\u01eb" + - "\3\2\2\2%\u01f1\3\2\2\2\'\u01f6\3\2\2\2)\u01ff\3\2\2\2+\u0208\3\2\2\2" + - "-\u020e\3\2\2\2/\u0214\3\2\2\2\61\u021e\3\2\2\2\63\u0229\3\2\2\2\65\u0232" + - "\3\2\2\2\67\u023b\3\2\2\29\u0243\3\2\2\2;\u024a\3\2\2\2=\u024d\3\2\2\2" + - "?\u0254\3\2\2\2A\u0261\3\2\2\2C\u0266\3\2\2\2E\u026b\3\2\2\2G\u0274\3" + - "\2\2\2I\u027b\3\2\2\2K\u0282\3\2\2\2M\u0288\3\2\2\2O\u028e\3\2\2\2Q\u0294" + - "\3\2\2\2S\u0298\3\2\2\2U\u029f\3\2\2\2W\u02a4\3\2\2\2Y\u02a7\3\2\2\2[" + - "\u02ae\3\2\2\2]\u02b2\3\2\2\2_\u02b7\3\2\2\2a\u02bf\3\2\2\2c\u02c9\3\2" + - "\2\2e\u02cd\3\2\2\2g\u02d6\3\2\2\2i\u02de\3\2\2\2k\u02e7\3\2\2\2m\u02f0" + - "\3\2\2\2o\u02f8\3\2\2\2q\u0302\3\2\2\2s\u0309\3\2\2\2u\u0312\3\2\2\2w" + - "\u0323\3\2\2\2y\u032a\3\2\2\2{\u0330\3\2\2\2}\u0337\3\2\2\2\177\u033e" + - "\3\2\2\2\u0081\u0345\3\2\2\2\u0083\u0353\3\2\2\2\u0085\u035f\3\2\2\2\u0087" + - "\u0366\3\2\2\2\u0089\u036d\3\2\2\2\u008b\u0376\3\2\2\2\u008d\u037b\3\2" + - "\2\2\u008f\u0388\3\2\2\2\u0091\u038e\3\2\2\2\u0093\u0393\3\2\2\2\u0095" + - "\u0397\3\2\2\2\u0097\u039f\3\2\2\2\u0099\u03a6\3\2\2\2\u009b\u03af\3\2" + - "\2\2\u009d\u03b5\3\2\2\2\u009f\u03be\3\2\2\2\u00a1\u03c4\3\2\2\2\u00a3" + - "\u03cc\3\2\2\2\u00a5\u03d1\3\2\2\2\u00a7\u03da\3\2\2\2\u00a9\u03e2\3\2" + - "\2\2\u00ab\u03e8\3\2\2\2\u00ad\u03ea\3\2\2\2\u00af\u03ec\3\2\2\2\u00b1" + - "\u03ee\3\2\2\2\u00b3\u03f0\3\2\2\2\u00b5\u03f2\3\2\2\2\u00b7\u03f4\3\2" + - "\2\2\u00b9\u03f6\3\2\2\2\u00bb\u03f8\3\2\2\2\u00bd\u03fa\3\2\2\2\u00bf" + - "\u03fc\3\2\2\2\u00c1\u03fe\3\2\2\2\u00c3\u0400\3\2\2\2\u00c5\u0402\3\2" + - "\2\2\u00c7\u0404\3\2\2\2\u00c9\u040a\3\2\2\2\u00cb\u040c\3\2\2\2\u00cd" + - "\u040e\3\2\2\2\u00cf\u0410\3\2\2\2\u00d1\u0412\3\2\2\2\u00d3\u0415\3\2" + - "\2\2\u00d5\u0418\3\2\2\2\u00d7\u041b\3\2\2\2\u00d9\u041e\3\2\2\2\u00db" + - "\u0421\3\2\2\2\u00dd\u0424\3\2\2\2\u00df\u0427\3\2\2\2\u00e1\u042a\3\2" + - "\2\2\u00e3\u042e\3\2\2\2\u00e5\u0432\3\2\2\2\u00e7\u0435\3\2\2\2\u00e9" + - "\u0438\3\2\2\2\u00eb\u043b\3\2\2\2\u00ed\u0443\3\2\2\2\u00ef\u0449\3\2" + - "\2\2\u00f1\u044b\3\2\2\2\u00f3\u044e\3\2\2\2\u00f5\u0451\3\2\2\2\u00f7" + - "\u0453\3\2\2\2\u00f9\u0457\3\2\2\2\u00fb\u045a\3\2\2\2\u00fd\u045c\3\2" + - "\2\2\u00ff\u045e\3\2\2\2\u0101\u0461\3\2\2\2\u0103\u0463\3\2\2\2\u0105" + - "\u0465\3\2\2\2\u0107\u0468\3\2\2\2\u0109\u046c\3\2\2\2\u010b\u047b\3\2" + - "\2\2\u010d\u047d\3\2\2\2\u010f\u0487\3\2\2\2\u0111\u0489\3\2\2\2\u0113" + - "\u048b\3\2\2\2\u0115\u048d\3\2\2\2\u0117\u0497\3\2\2\2\u0119\u04a5\3\2" + - "\2\2\u011b\u04b5\3\2\2\2\u011d\u04c1\3\2\2\2\u011f\u04c3\3\2\2\2\u0121" + - "\u04c5\3\2\2\2\u0123\u04c7\3\2\2\2\u0125\u04d9\3\2\2\2\u0127\u04db\3\2" + - "\2\2\u0129\u04dd\3\2\2\2\u012b\u04e3\3\2\2\2\u012d\u04e8\3\2\2\2\u012f" + - "\u04ed\3\2\2\2\u0131\u050d\3\2\2\2\u0133\u051a\3\2\2\2\u0135\u051c\3\2" + - "\2\2\u0137\u052c\3\2\2\2\u0139\u0538\3\2\2\2\u013b\u053a\3\2\2\2\u013d" + - "\u053c\3\2\2\2\u013f\u0546\3\2\2\2\u0141\u054b\3\2\2\2\u0143\u0550\3\2" + - "\2\2\u0145\u0552\3\2\2\2\u0147\u0575\3\2\2\2\u0149\u0581\3\2\2\2\u014b" + - "\u0583\3\2\2\2\u014d\u0586\3\2\2\2\u014f\u0589\3\2\2\2\u0151\u058c\3\2" + - "\2\2\u0153\u0597\3\2\2\2\u0155\u059b\3\2\2\2\u0157\u05a9\3\2\2\2\u0159" + - "\u015b\5\u0115\u008b\2\u015a\u015c\5\u0125\u0093\2\u015b\u015a\3\2\2\2" + - "\u015b\u015c\3\2\2\2\u015c\u016a\3\2\2\2\u015d\u015f\5\u0117\u008c\2\u015e" + - "\u0160\5\u0125\u0093\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u016a" + - "\3\2\2\2\u0161\u0163\5\u0119\u008d\2\u0162\u0164\5\u0125\u0093\2\u0163" + - "\u0162\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u016a\3\2\2\2\u0165\u0167\5\u011b" + - "\u008e\2\u0166\u0168\5\u0125\u0093\2\u0167\u0166\3\2\2\2\u0167\u0168\3" + - "\2\2\2\u0168\u016a\3\2\2\2\u0169\u0159\3\2\2\2\u0169\u015d\3\2\2\2\u0169" + - "\u0161\3\2\2\2\u0169\u0165\3\2\2\2\u016a\4\3\2\2\2\u016b\u016d\t\2\2\2" + - "\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170" + - "\7)\2\2\u016f\u0171\5\u012d\u0097\2\u0170\u016f\3\2\2\2\u0171\u0172\3" + - "\2\2\2\u0172\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174" + - "\u0175\7)\2\2\u0175\6\3\2\2\2\u0176\u0178\5\u0137\u009c\2\u0177\u0179" + - "\5\u0139\u009d\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\3" + - "\2\2\2\u017a\u017c\5\u013f\u00a0\2\u017b\u017a\3\2\2\2\u017b\u017c\3\2" + - "\2\2\u017c\u0183\3\2\2\2\u017d\u017e\5\u013d\u009f\2\u017e\u0180\5\u0139" + - "\u009d\2\u017f\u0181\5\u013f\u00a0\2\u0180\u017f\3\2\2\2\u0180\u0181\3" + - "\2\2\2\u0181\u0183\3\2\2\2\u0182\u0176\3\2\2\2\u0182\u017d\3\2\2\2\u0183" + - "\b\3\2\2\2\u0184\u0186\5\u0141\u00a1\2\u0185\u0184\3\2\2\2\u0185\u0186" + - "\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u018b\7$\2\2\u0188\u018a\5\u0143\u00a2" + - "\2\u0189\u0188\3\2\2\2\u018a\u018d\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018c" + - "\3\2\2\2\u018c\u018e\3\2\2\2\u018d\u018b\3\2\2\2\u018e\u0195\7$\2\2\u018f" + - "\u0191\5\u0141\u00a1\2\u0190\u018f\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0192" + - "\3\2\2\2\u0192\u0193\7T\2\2\u0193\u0195\5\u0145\u00a3\2\u0194\u0185\3" + - "\2\2\2\u0194\u0190\3\2\2\2\u0195\n\3\2\2\2\u0196\u0199\5K&\2\u0197\u0199" + - "\5\u0091I\2\u0198\u0196\3\2\2\2\u0198\u0197\3\2\2\2\u0199\f\3\2\2\2\u019a" + - "\u019b\5g\64\2\u019b\16\3\2\2\2\u019c\u01a1\5\u0147\u00a4\2\u019d\u01a1" + - "\5\u0149\u00a5\2\u019e\u01a1\5\u014b\u00a6\2\u019f\u01a1\5\u014d\u00a7" + - "\2\u01a0\u019c\3\2\2\2\u01a0\u019d\3\2\2\2\u01a0\u019e\3\2\2\2\u01a0\u019f" + - "\3\2\2\2\u01a1\20\3\2\2\2\u01a2\u01ae\7%\2\2\u01a3\u01a5\n\3\2\2\u01a4" + - "\u01a3\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a6\u01a4\3\2" + - "\2\2\u01a7\u01a9\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a9\u01ab\7^\2\2\u01aa" + - "\u01ac\7\17\2\2\u01ab\u01aa\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\3" + - "\2\2\2\u01ad\u01af\7\f\2\2\u01ae\u01a6\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0" + - "\u01ae\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\3\2\2\2\u01b2\u01b4\n\3" + - "\2\2\u01b3\u01b2\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5" + - "\u01b6\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01b8\b\t\2\2\u01b8\22\3\2\2" + - "\2\u01b9\u01bd\7%\2\2\u01ba\u01bc\n\3\2\2\u01bb\u01ba\3\2\2\2\u01bc\u01bf" + - "\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01c0\3\2\2\2\u01bf" + - "\u01bd\3\2\2\2\u01c0\u01c1\b\n\2\2\u01c1\24\3\2\2\2\u01c2\u01c3\7c\2\2" + - "\u01c3\u01c4\7n\2\2\u01c4\u01c5\7k\2\2\u01c5\u01c6\7i\2\2\u01c6\u01c7" + - "\7p\2\2\u01c7\u01c8\7c\2\2\u01c8\u01c9\7u\2\2\u01c9\26\3\2\2\2\u01ca\u01cb" + - "\7c\2\2\u01cb\u01cc\7n\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce\7i\2\2\u01ce" + - "\u01cf\7p\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7h\2\2\u01d1\30\3\2\2\2\u01d2" + - "\u01d3\7c\2\2\u01d3\u01d4\7u\2\2\u01d4\u01d5\7o\2\2\u01d5\32\3\2\2\2\u01d6" + - "\u01d7\7c\2\2\u01d7\u01d8\7w\2\2\u01d8\u01d9\7v\2\2\u01d9\u01da\7q\2\2" + - "\u01da\34\3\2\2\2\u01db\u01dc\7d\2\2\u01dc\u01dd\7q\2\2\u01dd\u01de\7" + - "q\2\2\u01de\u01df\7n\2\2\u01df\36\3\2\2\2\u01e0\u01e1\7d\2\2\u01e1\u01e2" + - "\7t\2\2\u01e2\u01e3\7g\2\2\u01e3\u01e4\7c\2\2\u01e4\u01e5\7m\2\2\u01e5" + - " \3\2\2\2\u01e6\u01e7\7e\2\2\u01e7\u01e8\7c\2\2\u01e8\u01e9\7u\2\2\u01e9" + - "\u01ea\7g\2\2\u01ea\"\3\2\2\2\u01eb\u01ec\7e\2\2\u01ec\u01ed\7c\2\2\u01ed" + - "\u01ee\7v\2\2\u01ee\u01ef\7e\2\2\u01ef\u01f0\7j\2\2\u01f0$\3\2\2\2\u01f1" + - "\u01f2\7e\2\2\u01f2\u01f3\7j\2\2\u01f3\u01f4\7c\2\2\u01f4\u01f5\7t\2\2" + - "\u01f5&\3\2\2\2\u01f6\u01f7\7e\2\2\u01f7\u01f8\7j\2\2\u01f8\u01f9\7c\2" + - "\2\u01f9\u01fa\7t\2\2\u01fa\u01fb\7\63\2\2\u01fb\u01fc\78\2\2\u01fc\u01fd" + - "\7a\2\2\u01fd\u01fe\7v\2\2\u01fe(\3\2\2\2\u01ff\u0200\7e\2\2\u0200\u0201" + - "\7j\2\2\u0201\u0202\7c\2\2\u0202\u0203\7t\2\2\u0203\u0204\7\65\2\2\u0204" + - "\u0205\7\64\2\2\u0205\u0206\7a\2\2\u0206\u0207\7v\2\2\u0207*\3\2\2\2\u0208" + - "\u0209\7e\2\2\u0209\u020a\7n\2\2\u020a\u020b\7c\2\2\u020b\u020c\7u\2\2" + - "\u020c\u020d\7u\2\2\u020d,\3\2\2\2\u020e\u020f\7e\2\2\u020f\u0210\7q\2" + - "\2\u0210\u0211\7p\2\2\u0211\u0212\7u\2\2\u0212\u0213\7v\2\2\u0213.\3\2" + - "\2\2\u0214\u0215\7e\2\2\u0215\u0216\7q\2\2\u0216\u0217\7p\2\2\u0217\u0218" + - "\7u\2\2\u0218\u0219\7v\2\2\u0219\u021a\7g\2\2\u021a\u021b\7z\2\2\u021b" + - "\u021c\7r\2\2\u021c\u021d\7t\2\2\u021d\60\3\2\2\2\u021e\u021f\7e\2\2\u021f" + - "\u0220\7q\2\2\u0220\u0221\7p\2\2\u0221\u0222\7u\2\2\u0222\u0223\7v\2\2" + - "\u0223\u0224\7a\2\2\u0224\u0225\7e\2\2\u0225\u0226\7c\2\2\u0226\u0227" + - "\7u\2\2\u0227\u0228\7v\2\2\u0228\62\3\2\2\2\u0229\u022a\7e\2\2\u022a\u022b" + - "\7q\2\2\u022b\u022c\7p\2\2\u022c\u022d\7v\2\2\u022d\u022e\7k\2\2\u022e" + - "\u022f\7p\2\2\u022f\u0230\7w\2\2\u0230\u0231\7g\2\2\u0231\64\3\2\2\2\u0232" + - "\u0233\7f\2\2\u0233\u0234\7g\2\2\u0234\u0235\7e\2\2\u0235\u0236\7n\2\2" + - "\u0236\u0237\7v\2\2\u0237\u0238\7{\2\2\u0238\u0239\7r\2\2\u0239\u023a" + - "\7g\2\2\u023a\66\3\2\2\2\u023b\u023c\7f\2\2\u023c\u023d\7g\2\2\u023d\u023e" + - "\7h\2\2\u023e\u023f\7c\2\2\u023f\u0240\7w\2\2\u0240\u0241\7n\2\2\u0241" + - "\u0242\7v\2\2\u02428\3\2\2\2\u0243\u0244\7f\2\2\u0244\u0245\7g\2\2\u0245" + - "\u0246\7n\2\2\u0246\u0247\7g\2\2\u0247\u0248\7v\2\2\u0248\u0249\7g\2\2" + - "\u0249:\3\2\2\2\u024a\u024b\7f\2\2\u024b\u024c\7q\2\2\u024c<\3\2\2\2\u024d" + - "\u024e\7f\2\2\u024e\u024f\7q\2\2\u024f\u0250\7w\2\2\u0250\u0251\7d\2\2" + - "\u0251\u0252\7n\2\2\u0252\u0253\7g\2\2\u0253>\3\2\2\2\u0254\u0255\7f\2" + - "\2\u0255\u0256\7{\2\2\u0256\u0257\7p\2\2\u0257\u0258\7c\2\2\u0258\u0259" + - "\7o\2\2\u0259\u025a\7k\2\2\u025a\u025b\7e\2\2\u025b\u025c\7a\2\2\u025c" + - "\u025d\7e\2\2\u025d\u025e\7c\2\2\u025e\u025f\7u\2\2\u025f\u0260\7v\2\2" + - "\u0260@\3\2\2\2\u0261\u0262\7g\2\2\u0262\u0263\7n\2\2\u0263\u0264\7u\2" + - "\2\u0264\u0265\7g\2\2\u0265B\3\2\2\2\u0266\u0267\7g\2\2\u0267\u0268\7" + - "p\2\2\u0268\u0269\7w\2\2\u0269\u026a\7o\2\2\u026aD\3\2\2\2\u026b\u026c" + - "\7g\2\2\u026c\u026d\7z\2\2\u026d\u026e\7r\2\2\u026e\u026f\7n\2\2\u026f" + - "\u0270\7k\2\2\u0270\u0271\7e\2\2\u0271\u0272\7k\2\2\u0272\u0273\7v\2\2" + - "\u0273F\3\2\2\2\u0274\u0275\7g\2\2\u0275\u0276\7z\2\2\u0276\u0277\7r\2" + - "\2\u0277\u0278\7q\2\2\u0278\u0279\7t\2\2\u0279\u027a\7v\2\2\u027aH\3\2" + - "\2\2\u027b\u027c\7g\2\2\u027c\u027d\7z\2\2\u027d\u027e\7v\2\2\u027e\u027f" + - "\7g\2\2\u027f\u0280\7t\2\2\u0280\u0281\7p\2\2\u0281J\3\2\2\2\u0282\u0283" + - "\7h\2\2\u0283\u0284\7c\2\2\u0284\u0285\7n\2\2\u0285\u0286\7u\2\2\u0286" + - "\u0287\7g\2\2\u0287L\3\2\2\2\u0288\u0289\7h\2\2\u0289\u028a\7k\2\2\u028a" + - "\u028b\7p\2\2\u028b\u028c\7c\2\2\u028c\u028d\7n\2\2\u028dN\3\2\2\2\u028e" + - "\u028f\7h\2\2\u028f\u0290\7n\2\2\u0290\u0291\7q\2\2\u0291\u0292\7c\2\2" + - "\u0292\u0293\7v\2\2\u0293P\3\2\2\2\u0294\u0295\7h\2\2\u0295\u0296\7q\2" + - "\2\u0296\u0297\7t\2\2\u0297R\3\2\2\2\u0298\u0299\7h\2\2\u0299\u029a\7" + - "t\2\2\u029a\u029b\7k\2\2\u029b\u029c\7g\2\2\u029c\u029d\7p\2\2\u029d\u029e" + - "\7f\2\2\u029eT\3\2\2\2\u029f\u02a0\7i\2\2\u02a0\u02a1\7q\2\2\u02a1\u02a2" + - "\7v\2\2\u02a2\u02a3\7q\2\2\u02a3V\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6" + - "\7h\2\2\u02a6X\3\2\2\2\u02a7\u02a8\7k\2\2\u02a8\u02a9\7p\2\2\u02a9\u02aa" + - "\7n\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7p\2\2\u02ac\u02ad\7g\2\2\u02ad" + - "Z\3\2\2\2\u02ae\u02af\7k\2\2\u02af\u02b0\7p\2\2\u02b0\u02b1\7v\2\2\u02b1" + - "\\\3\2\2\2\u02b2\u02b3\7n\2\2\u02b3\u02b4\7q\2\2\u02b4\u02b5\7p\2\2\u02b5" + - "\u02b6\7i\2\2\u02b6^\3\2\2\2\u02b7\u02b8\7o\2\2\u02b8\u02b9\7w\2\2\u02b9" + - "\u02ba\7v\2\2\u02ba\u02bb\7c\2\2\u02bb\u02bc\7d\2\2\u02bc\u02bd\7n\2\2" + - "\u02bd\u02be\7g\2\2\u02be`\3\2\2\2\u02bf\u02c0\7p\2\2\u02c0\u02c1\7c\2" + - "\2\u02c1\u02c2\7o\2\2\u02c2\u02c3\7g\2\2\u02c3\u02c4\7u\2\2\u02c4\u02c5" + - "\7r\2\2\u02c5\u02c6\7c\2\2\u02c6\u02c7\7e\2\2\u02c7\u02c8\7g\2\2\u02c8" + - "b\3\2\2\2\u02c9\u02ca\7p\2\2\u02ca\u02cb\7g\2\2\u02cb\u02cc\7y\2\2\u02cc" + - "d\3\2\2\2\u02cd\u02ce\7p\2\2\u02ce\u02cf\7q\2\2\u02cf\u02d0\7g\2\2\u02d0" + - "\u02d1\7z\2\2\u02d1\u02d2\7e\2\2\u02d2\u02d3\7g\2\2\u02d3\u02d4\7r\2\2" + - "\u02d4\u02d5\7v\2\2\u02d5f\3\2\2\2\u02d6\u02d7\7p\2\2\u02d7\u02d8\7w\2" + - "\2\u02d8\u02d9\7n\2\2\u02d9\u02da\7n\2\2\u02da\u02db\7r\2\2\u02db\u02dc" + - "\7v\2\2\u02dc\u02dd\7t\2\2\u02ddh\3\2\2\2\u02de\u02df\7q\2\2\u02df\u02e0" + - "\7r\2\2\u02e0\u02e1\7g\2\2\u02e1\u02e2\7t\2\2\u02e2\u02e3\7c\2\2\u02e3" + - "\u02e4\7v\2\2\u02e4\u02e5\7q\2\2\u02e5\u02e6\7t\2\2\u02e6j\3\2\2\2\u02e7" + - "\u02e8\7q\2\2\u02e8\u02e9\7x\2\2\u02e9\u02ea\7g\2\2\u02ea\u02eb\7t\2\2" + - "\u02eb\u02ec\7t\2\2\u02ec\u02ed\7k\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef" + - "\7g\2\2\u02efl\3\2\2\2\u02f0\u02f1\7r\2\2\u02f1\u02f2\7t\2\2\u02f2\u02f3" + - "\7k\2\2\u02f3\u02f4\7x\2\2\u02f4\u02f5\7c\2\2\u02f5\u02f6\7v\2\2\u02f6" + - "\u02f7\7g\2\2\u02f7n\3\2\2\2\u02f8\u02f9\7r\2\2\u02f9\u02fa\7t\2\2\u02fa" + - "\u02fb\7q\2\2\u02fb\u02fc\7v\2\2\u02fc\u02fd\7g\2\2\u02fd\u02fe\7e\2\2" + - "\u02fe\u02ff\7v\2\2\u02ff\u0300\7g\2\2\u0300\u0301\7f\2\2\u0301p\3\2\2" + - "\2\u0302\u0303\7r\2\2\u0303\u0304\7w\2\2\u0304\u0305\7d\2\2\u0305\u0306" + - "\7n\2\2\u0306\u0307\7k\2\2\u0307\u0308\7e\2\2\u0308r\3\2\2\2\u0309\u030a" + - "\7t\2\2\u030a\u030b\7g\2\2\u030b\u030c\7i\2\2\u030c\u030d\7k\2\2\u030d" + - "\u030e\7u\2\2\u030e\u030f\7v\2\2\u030f\u0310\7g\2\2\u0310\u0311\7t\2\2" + - "\u0311t\3\2\2\2\u0312\u0313\7t\2\2\u0313\u0314\7g\2\2\u0314\u0315\7k\2" + - "\2\u0315\u0316\7p\2\2\u0316\u0317\7v\2\2\u0317\u0318\7g\2\2\u0318\u0319" + - "\7t\2\2\u0319\u031a\7r\2\2\u031a\u031b\7t\2\2\u031b\u031c\7g\2\2\u031c" + - "\u031d\7v\2\2\u031d\u031e\7a\2\2\u031e\u031f\7e\2\2\u031f\u0320\7c\2\2" + - "\u0320\u0321\7u\2\2\u0321\u0322\7v\2\2\u0322v\3\2\2\2\u0323\u0324\7t\2" + - "\2\u0324\u0325\7g\2\2\u0325\u0326\7v\2\2\u0326\u0327\7w\2\2\u0327\u0328" + - "\7t\2\2\u0328\u0329\7p\2\2\u0329x\3\2\2\2\u032a\u032b\7u\2\2\u032b\u032c" + - "\7j\2\2\u032c\u032d\7q\2\2\u032d\u032e\7t\2\2\u032e\u032f\7v\2\2\u032f" + - "z\3\2\2\2\u0330\u0331\7u\2\2\u0331\u0332\7k\2\2\u0332\u0333\7i\2\2\u0333" + - "\u0334\7p\2\2\u0334\u0335\7g\2\2\u0335\u0336\7f\2\2\u0336|\3\2\2\2\u0337" + - "\u0338\7u\2\2\u0338\u0339\7k\2\2\u0339\u033a\7|\2\2\u033a\u033b\7g\2\2" + - "\u033b\u033c\7q\2\2\u033c\u033d\7h\2\2\u033d~\3\2\2\2\u033e\u033f\7u\2" + - "\2\u033f\u0340\7v\2\2\u0340\u0341\7c\2\2\u0341\u0342\7v\2\2\u0342\u0343" + - "\7k\2\2\u0343\u0344\7e\2\2\u0344\u0080\3\2\2\2\u0345\u0346\7u\2\2\u0346" + - "\u0347\7v\2\2\u0347\u0348\7c\2\2\u0348\u0349\7v\2\2\u0349\u034a\7k\2\2" + - "\u034a\u034b\7e\2\2\u034b\u034c\7a\2\2\u034c\u034d\7c\2\2\u034d\u034e" + - "\7u\2\2\u034e\u034f\7u\2\2\u034f\u0350\7g\2\2\u0350\u0351\7t\2\2\u0351" + - "\u0352\7v\2\2\u0352\u0082\3\2\2\2\u0353\u0354\7u\2\2\u0354\u0355\7v\2" + - "\2\u0355\u0356\7c\2\2\u0356\u0357\7v\2\2\u0357\u0358\7k\2\2\u0358\u0359" + - "\7e\2\2\u0359\u035a\7a\2\2\u035a\u035b\7e\2\2\u035b\u035c\7c\2\2\u035c" + - "\u035d\7u\2\2\u035d\u035e\7v\2\2\u035e\u0084\3\2\2\2\u035f\u0360\7u\2" + - "\2\u0360\u0361\7v\2\2\u0361\u0362\7t\2\2\u0362\u0363\7w\2\2\u0363\u0364" + - "\7e\2\2\u0364\u0365\7v\2\2\u0365\u0086\3\2\2\2\u0366\u0367\7u\2\2\u0367" + - "\u0368\7y\2\2\u0368\u0369\7k\2\2\u0369\u036a\7v\2\2\u036a\u036b\7e\2\2" + - "\u036b\u036c\7j\2\2\u036c\u0088\3\2\2\2\u036d\u036e\7v\2\2\u036e\u036f" + - "\7g\2\2\u036f\u0370\7o\2\2\u0370\u0371\7r\2\2\u0371\u0372\7n\2\2\u0372" + - "\u0373\7c\2\2\u0373\u0374\7v\2\2\u0374\u0375\7g\2\2\u0375\u008a\3\2\2" + - "\2\u0376\u0377\7v\2\2\u0377\u0378\7j\2\2\u0378\u0379\7k\2\2\u0379\u037a" + - "\7u\2\2\u037a\u008c\3\2\2\2\u037b\u037c\7v\2\2\u037c\u037d\7j\2\2\u037d" + - "\u037e\7t\2\2\u037e\u037f\7g\2\2\u037f\u0380\7c\2\2\u0380\u0381\7f\2\2" + - "\u0381\u0382\7a\2\2\u0382\u0383\7n\2\2\u0383\u0384\7q\2\2\u0384\u0385" + - "\7e\2\2\u0385\u0386\7c\2\2\u0386\u0387\7n\2\2\u0387\u008e\3\2\2\2\u0388" + - "\u0389\7v\2\2\u0389\u038a\7j\2\2\u038a\u038b\7t\2\2\u038b\u038c\7q\2\2" + - "\u038c\u038d\7y\2\2\u038d\u0090\3\2\2\2\u038e\u038f\7v\2\2\u038f\u0390" + - "\7t\2\2\u0390\u0391\7w\2\2\u0391\u0392\7g\2\2\u0392\u0092\3\2\2\2\u0393" + - "\u0394\7v\2\2\u0394\u0395\7t\2\2\u0395\u0396\7{\2\2\u0396\u0094\3\2\2" + - "\2\u0397\u0398\7v\2\2\u0398\u0399\7{\2\2\u0399\u039a\7r\2\2\u039a\u039b" + - "\7g\2\2\u039b\u039c\7f\2\2\u039c\u039d\7g\2\2\u039d\u039e\7h\2\2\u039e" + - "\u0096\3\2\2\2\u039f\u03a0\7v\2\2\u03a0\u03a1\7{\2\2\u03a1\u03a2\7r\2" + - "\2\u03a2\u03a3\7g\2\2\u03a3\u03a4\7k\2\2\u03a4\u03a5\7f\2\2\u03a5\u0098" + - "\3\2\2\2\u03a6\u03a7\7v\2\2\u03a7\u03a8\7{\2\2\u03a8\u03a9\7r\2\2\u03a9" + - "\u03aa\7g\2\2\u03aa\u03ab\7p\2\2\u03ab\u03ac\7c\2\2\u03ac\u03ad\7o\2\2" + - "\u03ad\u03ae\7g\2\2\u03ae\u009a\3\2\2\2\u03af\u03b0\7w\2\2\u03b0\u03b1" + - "\7p\2\2\u03b1\u03b2\7k\2\2\u03b2\u03b3\7q\2\2\u03b3\u03b4\7p\2\2\u03b4" + - "\u009c\3\2\2\2\u03b5\u03b6\7w\2\2\u03b6\u03b7\7p\2\2\u03b7\u03b8\7u\2" + - "\2\u03b8\u03b9\7k\2\2\u03b9\u03ba\7i\2\2\u03ba\u03bb\7p\2\2\u03bb\u03bc" + - "\7g\2\2\u03bc\u03bd\7f\2\2\u03bd\u009e\3\2\2\2\u03be\u03bf\7w\2\2\u03bf" + - "\u03c0\7u\2\2\u03c0\u03c1\7k\2\2\u03c1\u03c2\7p\2\2\u03c2\u03c3\7i\2\2" + - "\u03c3\u00a0\3\2\2\2\u03c4\u03c5\7x\2\2\u03c5\u03c6\7k\2\2\u03c6\u03c7" + - "\7t\2\2\u03c7\u03c8\7v\2\2\u03c8\u03c9\7w\2\2\u03c9\u03ca\7c\2\2\u03ca" + - "\u03cb\7n\2\2\u03cb\u00a2\3\2\2\2\u03cc\u03cd\7x\2\2\u03cd\u03ce\7q\2" + - "\2\u03ce\u03cf\7k\2\2\u03cf\u03d0\7f\2\2\u03d0\u00a4\3\2\2\2\u03d1\u03d2" + - "\7x\2\2\u03d2\u03d3\7q\2\2\u03d3\u03d4\7n\2\2\u03d4\u03d5\7c\2\2\u03d5" + - "\u03d6\7v\2\2\u03d6\u03d7\7k\2\2\u03d7\u03d8\7n\2\2\u03d8\u03d9\7g\2\2" + - "\u03d9\u00a6\3\2\2\2\u03da\u03db\7y\2\2\u03db\u03dc\7e\2\2\u03dc\u03dd" + - "\7j\2\2\u03dd\u03de\7c\2\2\u03de\u03df\7t\2\2\u03df\u03e0\7a\2\2\u03e0" + - "\u03e1\7v\2\2\u03e1\u00a8\3\2\2\2\u03e2\u03e3\7y\2\2\u03e3\u03e4\7j\2" + - "\2\u03e4\u03e5\7k\2\2\u03e5\u03e6\7n\2\2\u03e6\u03e7\7g\2\2\u03e7\u00aa" + - "\3\2\2\2\u03e8\u03e9\7*\2\2\u03e9\u00ac\3\2\2\2\u03ea\u03eb\7+\2\2\u03eb" + - "\u00ae\3\2\2\2\u03ec\u03ed\7]\2\2\u03ed\u00b0\3\2\2\2\u03ee\u03ef\7_\2" + - "\2\u03ef\u00b2\3\2\2\2\u03f0\u03f1\7}\2\2\u03f1\u00b4\3\2\2\2\u03f2\u03f3" + - "\7\177\2\2\u03f3\u00b6\3\2\2\2\u03f4\u03f5\7-\2\2\u03f5\u00b8\3\2\2\2" + - "\u03f6\u03f7\7/\2\2\u03f7\u00ba\3\2\2\2\u03f8\u03f9\7,\2\2\u03f9\u00bc" + - "\3\2\2\2\u03fa\u03fb\7\61\2\2\u03fb\u00be\3\2\2\2\u03fc\u03fd\7\'\2\2" + - "\u03fd\u00c0\3\2\2\2\u03fe\u03ff\7`\2\2\u03ff\u00c2\3\2\2\2\u0400\u0401" + - "\7(\2\2\u0401\u00c4\3\2\2\2\u0402\u0403\7~\2\2\u0403\u00c6\3\2\2\2\u0404" + - "\u0405\7\u0080\2\2\u0405\u00c8\3\2\2\2\u0406\u040b\7#\2\2\u0407\u0408" + - "\7p\2\2\u0408\u0409\7q\2\2\u0409\u040b\7v\2\2\u040a\u0406\3\2\2\2\u040a" + - "\u0407\3\2\2\2\u040b\u00ca\3\2\2\2\u040c\u040d\7?\2\2\u040d\u00cc\3\2" + - "\2\2\u040e\u040f\7>\2\2\u040f\u00ce\3\2\2\2\u0410\u0411\7@\2\2\u0411\u00d0" + - "\3\2\2\2\u0412\u0413\7-\2\2\u0413\u0414\7?\2\2\u0414\u00d2\3\2\2\2\u0415" + - "\u0416\7/\2\2\u0416\u0417\7?\2\2\u0417\u00d4\3\2\2\2\u0418\u0419\7,\2" + - "\2\u0419\u041a\7?\2\2\u041a\u00d6\3\2\2\2\u041b\u041c\7\61\2\2\u041c\u041d" + - "\7?\2\2\u041d\u00d8\3\2\2\2\u041e\u041f\7\'\2\2\u041f\u0420\7?\2\2\u0420" + - "\u00da\3\2\2\2\u0421\u0422\7`\2\2\u0422\u0423\7?\2\2\u0423\u00dc\3\2\2" + - "\2\u0424\u0425\7(\2\2\u0425\u0426\7?\2\2\u0426\u00de\3\2\2\2\u0427\u0428" + - "\7~\2\2\u0428\u0429\7?\2\2\u0429\u00e0\3\2\2\2\u042a\u042b\7>\2\2\u042b" + - "\u042c\7>\2\2\u042c\u042d\7?\2\2\u042d\u00e2\3\2\2\2\u042e\u042f\7@\2" + - "\2\u042f\u0430\7@\2\2\u0430\u0431\7?\2\2\u0431\u00e4\3\2\2\2\u0432\u0433" + - "\7?\2\2\u0433\u0434\7?\2\2\u0434\u00e6\3\2\2\2\u0435\u0436\7#\2\2\u0436" + - "\u0437\7?\2\2\u0437\u00e8\3\2\2\2\u0438\u0439\7>\2\2\u0439\u043a\7?\2" + - "\2\u043a\u00ea\3\2\2\2\u043b\u043c\7@\2\2\u043c\u043d\7?\2\2\u043d\u00ec" + - "\3\2\2\2\u043e\u043f\7(\2\2\u043f\u0444\7(\2\2\u0440\u0441\7c\2\2\u0441" + - "\u0442\7p\2\2\u0442\u0444\7f\2\2\u0443\u043e\3\2\2\2\u0443\u0440\3\2\2" + - "\2\u0444\u00ee\3\2\2\2\u0445\u0446\7~\2\2\u0446\u044a\7~\2\2\u0447\u0448" + - "\7q\2\2\u0448\u044a\7t\2\2\u0449\u0445\3\2\2\2\u0449\u0447\3\2\2\2\u044a" + - "\u00f0\3\2\2\2\u044b\u044c\7-\2\2\u044c\u044d\7-\2\2\u044d\u00f2\3\2\2" + - "\2\u044e\u044f\7/\2\2\u044f\u0450\7/\2\2\u0450\u00f4\3\2\2\2\u0451\u0452" + - "\7.\2\2\u0452\u00f6\3\2\2\2\u0453\u0454\7/\2\2\u0454\u0455\7@\2\2\u0455" + - "\u0456\7,\2\2\u0456\u00f8\3\2\2\2\u0457\u0458\7/\2\2\u0458\u0459\7@\2" + - "\2\u0459\u00fa\3\2\2\2\u045a\u045b\7A\2\2\u045b\u00fc\3\2\2\2\u045c\u045d" + - "\7<\2\2\u045d\u00fe\3\2\2\2\u045e\u045f\7<\2\2\u045f\u0460\7<\2\2\u0460" + - "\u0100\3\2\2\2\u0461\u0462\7=\2\2\u0462\u0102\3\2\2\2\u0463\u0464\7\60" + - "\2\2\u0464\u0104\3\2\2\2\u0465\u0466\7\60\2\2\u0466\u0467\7,\2\2\u0467" + - "\u0106\3\2\2\2\u0468\u0469\7\60\2\2\u0469\u046a\7\60\2\2\u046a\u046b\7" + - "\60\2\2\u046b\u0108\3\2\2\2\u046c\u046d\5\u0121\u0091\2\u046d\u046e\5" + - "\u0121\u0091\2\u046e\u046f\5\u0121\u0091\2\u046f\u0470\5\u0121\u0091\2" + - "\u0470\u010a\3\2\2\2\u0471\u0472\7^\2\2\u0472\u0473\7w\2\2\u0473\u0474" + - "\3\2\2\2\u0474\u047c\5\u0109\u0085\2\u0475\u0476\7^\2\2\u0476\u0477\7" + - "W\2\2\u0477\u0478\3\2\2\2\u0478\u0479\5\u0109\u0085\2\u0479\u047a\5\u0109" + - "\u0085\2\u047a\u047c\3\2\2\2\u047b\u0471\3\2\2\2\u047b\u0475\3\2\2\2\u047c" + - "\u010c\3\2\2\2\u047d\u0482\5\u010f\u0088\2\u047e\u0481\5\u010f\u0088\2" + - "\u047f\u0481\5\u0113\u008a\2\u0480\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481" + - "\u0484\3\2\2\2\u0482\u0480\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u010e\3\2" + - "\2\2\u0484\u0482\3\2\2\2\u0485\u0488\5\u0111\u0089\2\u0486\u0488\5\u010b" + - "\u0086\2\u0487\u0485\3\2\2\2\u0487\u0486\3\2\2\2\u0488\u0110\3\2\2\2\u0489" + - "\u048a\t\4\2\2\u048a\u0112\3\2\2\2\u048b\u048c\t\5\2\2\u048c\u0114\3\2" + - "\2\2\u048d\u0494\5\u011d\u008f\2\u048e\u0490\7)\2\2\u048f\u048e\3\2\2" + - "\2\u048f\u0490\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0493\5\u0113\u008a\2" + - "\u0492\u048f\3\2\2\2\u0493\u0496\3\2\2\2\u0494\u0492\3\2\2\2\u0494\u0495" + - "\3\2\2\2\u0495\u0116\3\2\2\2\u0496\u0494\3\2\2\2\u0497\u049e\7\62\2\2" + - "\u0498\u049a\7)\2\2\u0499\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b" + - "\3\2\2\2\u049b\u049d\5\u011f\u0090\2\u049c\u0499\3\2\2\2\u049d\u04a0\3" + - "\2\2\2\u049e\u049c\3\2\2\2\u049e\u049f\3\2\2\2\u049f\u0118\3\2\2\2\u04a0" + - "\u049e\3\2\2\2\u04a1\u04a2\7\62\2\2\u04a2\u04a6\7z\2\2\u04a3\u04a4\7\62" + - "\2\2\u04a4\u04a6\7Z\2\2\u04a5\u04a1\3\2\2\2\u04a5\u04a3\3\2\2\2\u04a6" + - "\u04a7\3\2\2\2\u04a7\u04ae\5\u0121\u0091\2\u04a8\u04aa\7)\2\2\u04a9\u04a8" + - "\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab\3\2\2\2\u04ab\u04ad\5\u0121\u0091" + - "\2\u04ac\u04a9\3\2\2\2\u04ad\u04b0\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae\u04af" + - "\3\2\2\2\u04af\u011a\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b1\u04b2\7\62\2\2" + - "\u04b2\u04b6\7d\2\2\u04b3\u04b4\7\62\2\2\u04b4\u04b6\7D\2\2\u04b5\u04b1" + - "\3\2\2\2\u04b5\u04b3\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04be\5\u0123\u0092" + - "\2\u04b8\u04ba\7)\2\2\u04b9\u04b8\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bb" + - "\3\2\2\2\u04bb\u04bd\5\u0123\u0092\2\u04bc\u04b9\3\2\2\2\u04bd\u04c0\3" + - "\2\2\2\u04be\u04bc\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u011c\3\2\2\2\u04c0" + - "\u04be\3\2\2\2\u04c1\u04c2\t\6\2\2\u04c2\u011e\3\2\2\2\u04c3\u04c4\t\7" + - "\2\2\u04c4\u0120\3\2\2\2\u04c5\u04c6\t\b\2\2\u04c6\u0122\3\2\2\2\u04c7" + - "\u04c8\t\t\2\2\u04c8\u0124\3\2\2\2\u04c9\u04cb\5\u0127\u0094\2\u04ca\u04cc" + - "\5\u0129\u0095\2\u04cb\u04ca\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04da\3" + - "\2\2\2\u04cd\u04cf\5\u0127\u0094\2\u04ce\u04d0\5\u012b\u0096\2\u04cf\u04ce" + - "\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04da\3\2\2\2\u04d1\u04d3\5\u0129\u0095" + - "\2\u04d2\u04d4\5\u0127\u0094\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2" + - "\u04d4\u04da\3\2\2\2\u04d5\u04d7\5\u012b\u0096\2\u04d6\u04d8\5\u0127\u0094" + - "\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2\u04d9\u04c9" + - "\3\2\2\2\u04d9\u04cd\3\2\2\2\u04d9\u04d1\3\2\2\2\u04d9\u04d5\3\2\2\2\u04da" + - "\u0126\3\2\2\2\u04db\u04dc\t\n\2\2\u04dc\u0128\3\2\2\2\u04dd\u04de\t\13" + - "\2\2\u04de\u012a\3\2\2\2\u04df\u04e0\7n\2\2\u04e0\u04e4\7n\2\2\u04e1\u04e2" + - "\7N\2\2\u04e2\u04e4\7N\2\2\u04e3\u04df\3\2\2\2\u04e3\u04e1\3\2\2\2\u04e4" + - "\u012c\3\2\2\2\u04e5\u04e9\n\f\2\2\u04e6\u04e9\5\u012f\u0098\2\u04e7\u04e9" + - "\5\u010b\u0086\2\u04e8\u04e5\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e8\u04e7\3" + - "\2\2\2\u04e9\u012e\3\2\2\2\u04ea\u04ee\5\u0131\u0099\2\u04eb\u04ee\5\u0133" + - "\u009a\2\u04ec\u04ee\5\u0135\u009b\2\u04ed\u04ea\3\2\2\2\u04ed\u04eb\3" + - "\2\2\2\u04ed\u04ec\3\2\2\2\u04ee\u0130\3\2\2\2\u04ef\u04f0\7^\2\2\u04f0" + - "\u050e\7)\2\2\u04f1\u04f2\7^\2\2\u04f2\u050e\7$\2\2\u04f3\u04f4\7^\2\2" + - "\u04f4\u050e\7A\2\2\u04f5\u04f6\7^\2\2\u04f6\u050e\7^\2\2\u04f7\u04f8" + - "\7^\2\2\u04f8\u050e\7c\2\2\u04f9\u04fa\7^\2\2\u04fa\u050e\7d\2\2\u04fb" + - "\u04fc\7^\2\2\u04fc\u050e\7h\2\2\u04fd\u04fe\7^\2\2\u04fe\u050e\7p\2\2" + - "\u04ff\u0500\7^\2\2\u0500\u050e\7t\2\2\u0501\u0507\7^\2\2\u0502\u0504" + - "\7\17\2\2\u0503\u0505\7\f\2\2\u0504\u0503\3\2\2\2\u0504\u0505\3\2\2\2" + - "\u0505\u0508\3\2\2\2\u0506\u0508\7\f\2\2\u0507\u0502\3\2\2\2\u0507\u0506" + - "\3\2\2\2\u0508\u050e\3\2\2\2\u0509\u050a\7^\2\2\u050a\u050e\7v\2\2\u050b" + - "\u050c\7^\2\2\u050c\u050e\7x\2\2\u050d\u04ef\3\2\2\2\u050d\u04f1\3\2\2" + - "\2\u050d\u04f3\3\2\2\2\u050d\u04f5\3\2\2\2\u050d\u04f7\3\2\2\2\u050d\u04f9" + - "\3\2\2\2\u050d\u04fb\3\2\2\2\u050d\u04fd\3\2\2\2\u050d\u04ff\3\2\2\2\u050d" + - "\u0501\3\2\2\2\u050d\u0509\3\2\2\2\u050d\u050b\3\2\2\2\u050e\u0132\3\2" + - "\2\2\u050f\u0510\7^\2\2\u0510\u051b\5\u011f\u0090\2\u0511\u0512\7^\2\2" + - "\u0512\u0513\5\u011f\u0090\2\u0513\u0514\5\u011f\u0090\2\u0514\u051b\3" + - "\2\2\2\u0515\u0516\7^\2\2\u0516\u0517\5\u011f\u0090\2\u0517\u0518\5\u011f" + - "\u0090\2\u0518\u0519\5\u011f\u0090\2\u0519\u051b\3\2\2\2\u051a\u050f\3" + - "\2\2\2\u051a\u0511\3\2\2\2\u051a\u0515\3\2\2\2\u051b\u0134\3\2\2\2\u051c" + - "\u051d\7^\2\2\u051d\u051e\7z\2\2\u051e\u0520\3\2\2\2\u051f\u0521\5\u0121" + - "\u0091\2\u0520\u051f\3\2\2\2\u0521\u0522\3\2\2\2\u0522\u0520\3\2\2\2\u0522" + - "\u0523\3\2\2\2\u0523\u0136\3\2\2\2\u0524\u0526\5\u013d\u009f\2\u0525\u0524" + - "\3\2\2\2\u0525\u0526\3\2\2\2\u0526\u0527\3\2\2\2\u0527\u0528\7\60\2\2" + - "\u0528\u052d\5\u013d\u009f\2\u0529\u052a\5\u013d\u009f\2\u052a\u052b\7" + - "\60\2\2\u052b\u052d\3\2\2\2\u052c\u0525\3\2\2\2\u052c\u0529\3\2\2\2\u052d" + - "\u0138\3\2\2\2\u052e\u0530\7g\2\2\u052f\u0531\5\u013b\u009e\2\u0530\u052f" + - "\3\2\2\2\u0530\u0531\3\2\2\2\u0531\u0532\3\2\2\2\u0532\u0539\5\u013d\u009f" + - "\2\u0533\u0535\7G\2\2\u0534\u0536\5\u013b\u009e\2\u0535\u0534\3\2\2\2" + - "\u0535\u0536\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\5\u013d\u009f\2\u0538" + - "\u052e\3\2\2\2\u0538\u0533\3\2\2\2\u0539\u013a\3\2\2\2\u053a\u053b\t\r" + - "\2\2\u053b\u013c\3\2\2\2\u053c\u0543\5\u0113\u008a\2\u053d\u053f\7)\2" + - "\2\u053e\u053d\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0542" + - "\5\u0113\u008a\2\u0541\u053e\3\2\2\2\u0542\u0545\3\2\2\2\u0543\u0541\3" + - "\2\2\2\u0543\u0544\3\2\2\2\u0544\u013e\3\2\2\2\u0545\u0543\3\2\2\2\u0546" + - "\u0547\t\16\2\2\u0547\u0140\3\2\2\2\u0548\u0549\7w\2\2\u0549\u054c\7:" + - "\2\2\u054a\u054c\t\2\2\2\u054b\u0548\3\2\2\2\u054b\u054a\3\2\2\2\u054c" + - "\u0142\3\2\2\2\u054d\u0551\n\17\2\2\u054e\u0551\5\u012f\u0098\2\u054f" + - "\u0551\5\u010b\u0086\2\u0550\u054d\3\2\2\2\u0550\u054e\3\2\2\2\u0550\u054f" + - "\3\2\2\2\u0551\u0144\3\2\2\2\u0552\u0556\7$\2\2\u0553\u0555\n\20\2\2\u0554" + - "\u0553\3\2\2\2\u0555\u0558\3\2\2\2\u0556\u0554\3\2\2\2\u0556\u0557\3\2" + - "\2\2\u0557\u0559\3\2\2\2\u0558\u0556\3\2\2\2\u0559\u055d\7*\2\2\u055a" + - "\u055c\n\21\2\2\u055b\u055a\3\2\2\2\u055c\u055f\3\2\2\2\u055d\u055b\3" + - "\2\2\2\u055d\u055e\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055d\3\2\2\2\u0560" + - "\u0564\7+\2\2\u0561\u0563\n\22\2\2\u0562\u0561\3\2\2\2\u0563\u0566\3\2" + - "\2\2\u0564\u0562\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u0567\3\2\2\2\u0566" + - "\u0564\3\2\2\2\u0567\u0568\7$\2\2\u0568\u0146\3\2\2\2\u0569\u056a\5\u0115" + - "\u008b\2\u056a\u056b\5\u014f\u00a8\2\u056b\u0576\3\2\2\2\u056c\u056d\5" + - "\u0117\u008c\2\u056d\u056e\5\u014f\u00a8\2\u056e\u0576\3\2\2\2\u056f\u0570" + - "\5\u0119\u008d\2\u0570\u0571\5\u014f\u00a8\2\u0571\u0576\3\2\2\2\u0572" + - "\u0573\5\u011b\u008e\2\u0573\u0574\5\u014f\u00a8\2\u0574\u0576\3\2\2\2" + - "\u0575\u0569\3\2\2\2\u0575\u056c\3\2\2\2\u0575\u056f\3\2\2\2\u0575\u0572" + - "\3\2\2\2\u0576\u0148\3\2\2\2\u0577\u0579\5\u0137\u009c\2\u0578\u057a\5" + - "\u0139\u009d\2\u0579\u0578\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057b\3\2" + - "\2\2\u057b\u057c\5\u014f\u00a8\2\u057c\u0582\3\2\2\2\u057d\u057e\5\u013d" + - "\u009f\2\u057e\u057f\5\u0139\u009d\2\u057f\u0580\5\u014f\u00a8\2\u0580" + - "\u0582\3\2\2\2\u0581\u0577\3\2\2\2\u0581\u057d\3\2\2\2\u0582\u014a\3\2" + - "\2\2\u0583\u0584\5\t\5\2\u0584\u0585\5\u014f\u00a8\2\u0585\u014c\3\2\2" + - "\2\u0586\u0587\5\5\3\2\u0587\u0588\5\u014f\u00a8\2\u0588\u014e\3\2\2\2" + - "\u0589\u058a\5\u010d\u0087\2\u058a\u0150\3\2\2\2\u058b\u058d\t\23\2\2" + - "\u058c\u058b\3\2\2\2\u058d\u058e\3\2\2\2\u058e\u058c\3\2\2\2\u058e\u058f" + - "\3\2\2\2\u058f\u0590\3\2\2\2\u0590\u0591\b\u00a9\3\2\u0591\u0152\3\2\2" + - "\2\u0592\u0594\7\17\2\2\u0593\u0595\7\f\2\2\u0594\u0593\3\2\2\2\u0594" + - "\u0595\3\2\2\2\u0595\u0598\3\2\2\2\u0596\u0598\7\f\2\2\u0597\u0592\3\2" + - "\2\2\u0597\u0596\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059a\b\u00aa\3\2\u059a" + - "\u0154\3\2\2\2\u059b\u059c\7\61\2\2\u059c\u059d\7,\2\2\u059d\u05a1\3\2" + - "\2\2\u059e\u05a0\13\2\2\2\u059f\u059e\3\2\2\2\u05a0\u05a3\3\2\2\2\u05a1" + - "\u05a2\3\2\2\2\u05a1\u059f\3\2\2\2\u05a2\u05a4\3\2\2\2\u05a3\u05a1\3\2" + - "\2\2\u05a4\u05a5\7,\2\2\u05a5\u05a6\7\61\2\2\u05a6\u05a7\3\2\2\2\u05a7" + - "\u05a8\b\u00ab\3\2\u05a8\u0156\3\2\2\2\u05a9\u05aa\7\61\2\2\u05aa\u05ab" + - "\7\61\2\2\u05ab\u05af\3\2\2\2\u05ac\u05ae\n\24\2\2\u05ad\u05ac\3\2\2\2" + - "\u05ae\u05b1\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05b0\3\2\2\2\u05b0\u05b2" + - "\3\2\2\2\u05b1\u05af\3\2\2\2\u05b2\u05b3\b\u00ac\3\2\u05b3\u0158\3\2\2" + - "\2K\2\u015b\u015f\u0163\u0167\u0169\u016c\u0172\u0178\u017b\u0180\u0182" + - "\u0185\u018b\u0190\u0194\u0198\u01a0\u01a6\u01ab\u01b0\u01b5\u01bd\u040a" + - "\u0443\u0449\u047b\u0480\u0482\u0487\u048f\u0494\u0499\u049e\u04a5\u04a9" + - "\u04ae\u04b5\u04b9\u04be\u04cb\u04cf\u04d3\u04d7\u04d9\u04e3\u04e8\u04ed" + - "\u0504\u0507\u050d\u051a\u0522\u0525\u052c\u0530\u0535\u0538\u053e\u0543" + - "\u054b\u0550\u0556\u055d\u0564\u0575\u0579\u0581\u058e\u0594\u0597\u05a1" + - "\u05af\4\2\3\2\b\2\2"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.interp deleted file mode 100644 index 58bb343..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cpp/CPP14Parser.interp +++ /dev/null @@ -1,490 +0,0 @@ -token literal names: -null -null -null -null -null -null -null -null -null -null -'alignas' -'alignof' -'asm' -'auto' -'bool' -'break' -'case' -'catch' -'char' -'char16_t' -'char32_t' -'class' -'const' -'constexpr' -'const_cast' -'continue' -'decltype' -'default' -'delete' -'do' -'double' -'dynamic_cast' -'else' -'enum' -'explicit' -'export' -'extern' -'false' -'final' -'float' -'for' -'friend' -'goto' -'if' -'inline' -'int' -'long' -'mutable' -'namespace' -'new' -'noexcept' -'nullptr' -'operator' -'override' -'private' -'protected' -'public' -'register' -'reinterpret_cast' -'return' -'short' -'signed' -'sizeof' -'static' -'static_assert' -'static_cast' -'struct' -'switch' -'template' -'this' -'thread_local' -'throw' -'true' -'try' -'typedef' -'typeid' -'typename' -'union' -'unsigned' -'using' -'virtual' -'void' -'volatile' -'wchar_t' -'while' -'(' -')' -'[' -']' -'{' -'}' -'+' -'-' -'*' -'/' -'%' -'^' -'&' -'|' -'~' -null -'=' -'<' -'>' -'+=' -'-=' -'*=' -'/=' -'%=' -'^=' -'&=' -'|=' -'<<=' -'>>=' -'==' -'!=' -'<=' -'>=' -null -null -'++' -'--' -',' -'->*' -'->' -'?' -':' -'::' -';' -'.' -'.*' -'...' -null -null -null -null -null -null -null -null -null -null -null -null -null -null - -token symbolic names: -null -IntegerLiteral -CharacterLiteral -FloatingLiteral -StringLiteral -BooleanLiteral -PointerLiteral -UserDefinedLiteral -MultiLineMacro -Directive -Alignas -Alignof -Asm -Auto -Bool -Break -Case -Catch -Char -Char16 -Char32 -Class -Const -Constexpr -Const_cast -Continue -Decltype -Default -Delete -Do -Double -Dynamic_cast -Else -Enum -Explicit -Export -Extern -False_ -Final -Float -For -Friend -Goto -If -Inline -Int -Long -Mutable -Namespace -New -Noexcept -Nullptr -Operator -Override -Private -Protected -Public -Register -Reinterpret_cast -Return -Short -Signed -Sizeof -Static -Static_assert -Static_cast -Struct -Switch -Template -This -Thread_local -Throw -True_ -Try -Typedef -Typeid_ -Typename_ -Union -Unsigned -Using -Virtual -Void -Volatile -Wchar -While -LeftParen -RightParen -LeftBracket -RightBracket -LeftBrace -RightBrace -Plus -Minus -Star -Div -Mod -Caret -And -Or -Tilde -Not -Assign -Less -Greater -PlusAssign -MinusAssign -StarAssign -DivAssign -ModAssign -XorAssign -AndAssign -OrAssign -LeftShiftAssign -RightShiftAssign -Equal -NotEqual -LessEqual -GreaterEqual -AndAnd -OrOr -PlusPlus -MinusMinus -Comma -ArrowStar -Arrow -Question -Colon -Doublecolon -Semi -Dot -DotStar -Ellipsis -Identifier -DecimalLiteral -OctalLiteral -HexadecimalLiteral -BinaryLiteral -Integersuffix -UserDefinedIntegerLiteral -UserDefinedFloatingLiteral -UserDefinedStringLiteral -UserDefinedCharacterLiteral -Whitespace -Newline -BlockComment -LineComment - -rule names: -translationUnit -primaryExpression -idExpression -unqualifiedId -qualifiedId -nestedNameSpecifier -lambdaExpression -lambdaIntroducer -lambdaCapture -captureDefault -captureList -capture -simpleCapture -initcapture -lambdaDeclarator -postfixExpression -typeIdOfTheTypeId -expressionList -pseudoDestructorName -unaryExpression -unaryOperator -newExpression -newPlacement -newTypeId -newDeclarator -noPointerNewDeclarator -newInitializer -deleteExpression -noExceptExpression -castExpression -pointerMemberExpression -multiplicativeExpression -additiveExpression -shiftExpression -shiftOperator -relationalExpression -equalityExpression -andExpression -exclusiveOrExpression -inclusiveOrExpression -logicalAndExpression -logicalOrExpression -conditionalExpression -assignmentExpression -assignmentOperator -expression -constantExpression -statement -labeledStatement -expressionStatement -compoundStatement -statementSeq -selectionStatement -condition -iterationStatement -forInitStatement -forRangeDeclaration -forRangeInitializer -jumpStatement -declarationStatement -declarationseq -declaration -blockDeclaration -aliasDeclaration -simpleDeclaration -staticAssertDeclaration -emptyDeclaration -attributeDeclaration -declSpecifier -declSpecifierSeq -storageClassSpecifier -functionSpecifier -typedefName -typeSpecifier -trailingTypeSpecifier -typeSpecifierSeq -trailingTypeSpecifierSeq -simpleTypeSpecifier -theTypeName -decltypeSpecifier -elaboratedTypeSpecifier -enumName -enumSpecifier -enumHead -opaqueEnumDeclaration -enumkey -enumbase -enumeratorList -enumeratorDefinition -enumerator -namespaceName -originalNamespaceName -namespaceDefinition -namespaceAlias -namespaceAliasDefinition -qualifiednamespacespecifier -usingDeclaration -usingDirective -asmDefinition -linkageSpecification -attributeSpecifierSeq -attributeSpecifier -alignmentspecifier -attributeList -attribute -attributeNamespace -attributeArgumentClause -balancedTokenSeq -balancedtoken -initDeclaratorList -initDeclarator -declarator -pointerDeclarator -noPointerDeclarator -parametersAndQualifiers -trailingReturnType -pointerOperator -cvqualifierseq -cvQualifier -refqualifier -declaratorid -theTypeId -abstractDeclarator -pointerAbstractDeclarator -noPointerAbstractDeclarator -abstractPackDeclarator -noPointerAbstractPackDeclarator -parameterDeclarationClause -parameterDeclarationList -parameterDeclaration -functionDefinition -functionBody -initializer -braceOrEqualInitializer -initializerClause -initializerList -bracedInitList -className -classSpecifier -classHead -classHeadName -classVirtSpecifier -classKey -memberSpecification -memberdeclaration -memberDeclaratorList -memberDeclarator -virtualSpecifierSeq -virtualSpecifier -pureSpecifier -baseClause -baseSpecifierList -baseSpecifier -classOrDeclType -baseTypeSpecifier -accessSpecifier -conversionFunctionId -conversionTypeId -conversionDeclarator -constructorInitializer -memInitializerList -memInitializer -meminitializerid -operatorFunctionId -literalOperatorId -templateDeclaration -templateparameterList -templateParameter -typeParameter -simpleTemplateId -templateId -templateName -templateArgumentList -templateArgument -typeNameSpecifier -explicitInstantiation -explicitSpecialization -tryBlock -functionTryBlock -handlerSeq -handler -exceptionDeclaration -throwExpression -exceptionSpecification -dynamicExceptionSpecification -typeIdList -noeExceptSpecification -theOperator -literal - - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 147, 2077, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 3, 2, 5, 2, 382, 10, 2, 3, 2, 3, 2, 3, 3, 6, 3, 387, 10, 3, 13, 3, 14, 3, 388, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 398, 10, 3, 3, 4, 3, 4, 5, 4, 402, 10, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 411, 10, 5, 3, 5, 5, 5, 414, 10, 5, 3, 6, 3, 6, 5, 6, 418, 10, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 426, 10, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 433, 10, 7, 3, 7, 5, 7, 436, 10, 7, 3, 7, 7, 7, 439, 10, 7, 12, 7, 14, 7, 442, 11, 7, 3, 8, 3, 8, 5, 8, 446, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 5, 9, 452, 10, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 460, 10, 10, 5, 10, 462, 10, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 7, 12, 469, 10, 12, 12, 12, 14, 12, 472, 11, 12, 3, 12, 5, 12, 475, 10, 12, 3, 13, 3, 13, 5, 13, 479, 10, 13, 3, 14, 5, 14, 482, 10, 14, 3, 14, 3, 14, 5, 14, 486, 10, 14, 3, 15, 5, 15, 489, 10, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 5, 16, 496, 10, 16, 3, 16, 3, 16, 5, 16, 500, 10, 16, 3, 16, 5, 16, 503, 10, 16, 3, 16, 5, 16, 506, 10, 16, 3, 16, 5, 16, 509, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 515, 10, 17, 3, 17, 3, 17, 5, 17, 519, 10, 17, 3, 17, 3, 17, 5, 17, 523, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 537, 10, 17, 3, 17, 3, 17, 5, 17, 541, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 547, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 554, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 560, 10, 17, 3, 17, 3, 17, 5, 17, 564, 10, 17, 3, 17, 3, 17, 7, 17, 568, 10, 17, 12, 17, 14, 17, 571, 11, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 5, 20, 578, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 583, 10, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 596, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 603, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 615, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 625, 10, 21, 3, 22, 3, 22, 3, 23, 5, 23, 630, 10, 23, 3, 23, 3, 23, 5, 23, 634, 10, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 641, 10, 23, 3, 23, 5, 23, 644, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 5, 25, 652, 10, 25, 3, 26, 3, 26, 5, 26, 656, 10, 26, 3, 26, 5, 26, 659, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 666, 10, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 673, 10, 27, 7, 27, 675, 10, 27, 12, 27, 14, 27, 678, 11, 27, 3, 28, 3, 28, 5, 28, 682, 10, 28, 3, 28, 3, 28, 5, 28, 686, 10, 28, 3, 29, 5, 29, 689, 10, 29, 3, 29, 3, 29, 3, 29, 5, 29, 694, 10, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 5, 31, 709, 10, 31, 3, 32, 3, 32, 3, 32, 7, 32, 714, 10, 32, 12, 32, 14, 32, 717, 11, 32, 3, 33, 3, 33, 3, 33, 7, 33, 722, 10, 33, 12, 33, 14, 33, 725, 11, 33, 3, 34, 3, 34, 3, 34, 7, 34, 730, 10, 34, 12, 34, 14, 34, 733, 11, 34, 3, 35, 3, 35, 3, 35, 3, 35, 7, 35, 739, 10, 35, 12, 35, 14, 35, 742, 11, 35, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 748, 10, 36, 3, 37, 3, 37, 3, 37, 7, 37, 753, 10, 37, 12, 37, 14, 37, 756, 11, 37, 3, 38, 3, 38, 3, 38, 7, 38, 761, 10, 38, 12, 38, 14, 38, 764, 11, 38, 3, 39, 3, 39, 3, 39, 7, 39, 769, 10, 39, 12, 39, 14, 39, 772, 11, 39, 3, 40, 3, 40, 3, 40, 7, 40, 777, 10, 40, 12, 40, 14, 40, 780, 11, 40, 3, 41, 3, 41, 3, 41, 7, 41, 785, 10, 41, 12, 41, 14, 41, 788, 11, 41, 3, 42, 3, 42, 3, 42, 7, 42, 793, 10, 42, 12, 42, 14, 42, 796, 11, 42, 3, 43, 3, 43, 3, 43, 7, 43, 801, 10, 43, 12, 43, 14, 43, 804, 11, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 812, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 820, 10, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 7, 47, 827, 10, 47, 12, 47, 14, 47, 830, 11, 47, 3, 48, 3, 48, 3, 49, 3, 49, 5, 49, 836, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 844, 10, 49, 3, 49, 5, 49, 847, 10, 49, 3, 50, 5, 50, 850, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 856, 10, 50, 3, 50, 3, 50, 3, 50, 3, 51, 5, 51, 862, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 5, 52, 868, 10, 52, 3, 52, 3, 52, 3, 53, 6, 53, 873, 10, 53, 13, 53, 14, 53, 874, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 884, 10, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 892, 10, 54, 3, 55, 3, 55, 5, 55, 896, 10, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 903, 10, 55, 5, 55, 905, 10, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 925, 10, 56, 3, 56, 3, 56, 5, 56, 929, 10, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 935, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 940, 10, 56, 3, 57, 3, 57, 5, 57, 944, 10, 57, 3, 58, 5, 58, 947, 10, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 5, 59, 954, 10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 961, 10, 60, 3, 60, 3, 60, 5, 60, 965, 10, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 6, 62, 972, 10, 62, 13, 62, 14, 62, 973, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 985, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 995, 10, 64, 3, 65, 3, 65, 3, 65, 5, 65, 1000, 10, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 5, 66, 1007, 10, 66, 3, 66, 5, 66, 1010, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1015, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1020, 10, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 1041, 10, 70, 3, 71, 6, 71, 1044, 10, 71, 13, 71, 14, 71, 1045, 3, 71, 5, 71, 1049, 10, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 5, 75, 1060, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1066, 10, 76, 3, 77, 6, 77, 1069, 10, 77, 13, 77, 14, 77, 1070, 3, 77, 5, 77, 1074, 10, 77, 3, 78, 6, 78, 1077, 10, 78, 13, 78, 14, 78, 1078, 3, 78, 5, 78, 1082, 10, 78, 3, 79, 5, 79, 1085, 10, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1107, 10, 79, 3, 80, 3, 80, 3, 80, 3, 80, 5, 80, 1113, 10, 80, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1119, 10, 81, 3, 81, 3, 81, 3, 82, 3, 82, 5, 82, 1125, 10, 82, 3, 82, 5, 82, 1128, 10, 82, 3, 82, 3, 82, 3, 82, 3, 82, 5, 82, 1134, 10, 82, 3, 82, 3, 82, 5, 82, 1138, 10, 82, 3, 82, 3, 82, 5, 82, 1142, 10, 82, 3, 82, 5, 82, 1145, 10, 82, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1153, 10, 84, 5, 84, 1155, 10, 84, 3, 84, 3, 84, 3, 85, 3, 85, 5, 85, 1161, 10, 85, 3, 85, 5, 85, 1164, 10, 85, 3, 85, 5, 85, 1167, 10, 85, 3, 85, 5, 85, 1170, 10, 85, 3, 86, 3, 86, 5, 86, 1174, 10, 86, 3, 86, 3, 86, 5, 86, 1178, 10, 86, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 1184, 10, 87, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 7, 89, 1192, 10, 89, 12, 89, 14, 89, 1195, 11, 89, 3, 90, 3, 90, 3, 90, 5, 90, 1200, 10, 90, 3, 91, 3, 91, 3, 92, 3, 92, 5, 92, 1206, 10, 92, 3, 93, 3, 93, 3, 94, 5, 94, 1211, 10, 94, 3, 94, 3, 94, 3, 94, 5, 94, 1216, 10, 94, 3, 94, 3, 94, 5, 94, 1220, 10, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 5, 97, 1233, 10, 97, 3, 97, 3, 97, 3, 98, 3, 98, 5, 98, 1239, 10, 98, 3, 98, 3, 98, 5, 98, 1243, 10, 98, 3, 98, 3, 98, 3, 98, 3, 99, 5, 99, 1249, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1254, 10, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1269, 10, 101, 3, 101, 3, 101, 5, 101, 1273, 10, 101, 3, 102, 6, 102, 1276, 10, 102, 13, 102, 14, 102, 1277, 3, 103, 3, 103, 3, 103, 5, 103, 1283, 10, 103, 3, 103, 3, 103, 3, 103, 5, 103, 1288, 10, 103, 3, 104, 3, 104, 3, 104, 3, 104, 5, 104, 1294, 10, 104, 3, 104, 5, 104, 1297, 10, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 7, 105, 1304, 10, 105, 12, 105, 14, 105, 1307, 11, 105, 3, 105, 5, 105, 1310, 10, 105, 3, 106, 3, 106, 3, 106, 5, 106, 1315, 10, 106, 3, 106, 3, 106, 5, 106, 1319, 10, 106, 3, 107, 3, 107, 3, 108, 3, 108, 5, 108, 1325, 10, 108, 3, 108, 3, 108, 3, 109, 6, 109, 1330, 10, 109, 13, 109, 14, 109, 1331, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 6, 110, 1347, 10, 110, 13, 110, 14, 110, 1348, 5, 110, 1351, 10, 110, 3, 111, 3, 111, 3, 111, 7, 111, 1356, 10, 111, 12, 111, 14, 111, 1359, 11, 111, 3, 112, 3, 112, 5, 112, 1363, 10, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 5, 113, 1370, 10, 113, 3, 114, 3, 114, 5, 114, 1374, 10, 114, 7, 114, 1376, 10, 114, 12, 114, 14, 114, 1379, 11, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 5, 115, 1386, 10, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1392, 10, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1398, 10, 115, 3, 115, 3, 115, 5, 115, 1402, 10, 115, 5, 115, 1404, 10, 115, 7, 115, 1406, 10, 115, 12, 115, 14, 115, 1409, 11, 115, 3, 116, 3, 116, 5, 116, 1413, 10, 116, 3, 116, 3, 116, 5, 116, 1417, 10, 116, 3, 116, 5, 116, 1420, 10, 116, 3, 116, 5, 116, 1423, 10, 116, 3, 116, 5, 116, 1426, 10, 116, 3, 117, 3, 117, 3, 117, 5, 117, 1431, 10, 117, 3, 118, 3, 118, 5, 118, 1435, 10, 118, 3, 118, 5, 118, 1438, 10, 118, 3, 118, 3, 118, 5, 118, 1442, 10, 118, 3, 118, 5, 118, 1445, 10, 118, 5, 118, 1447, 10, 118, 3, 119, 6, 119, 1450, 10, 119, 13, 119, 14, 119, 1451, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 5, 122, 1459, 10, 122, 3, 122, 3, 122, 3, 123, 3, 123, 5, 123, 1465, 10, 123, 3, 124, 3, 124, 5, 124, 1469, 10, 124, 3, 124, 3, 124, 3, 124, 3, 124, 5, 124, 1475, 10, 124, 3, 125, 3, 125, 6, 125, 1479, 10, 125, 13, 125, 14, 125, 1480, 3, 125, 5, 125, 1484, 10, 125, 5, 125, 1486, 10, 125, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1492, 10, 126, 3, 126, 3, 126, 5, 126, 1496, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1502, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1509, 10, 126, 3, 126, 3, 126, 5, 126, 1513, 10, 126, 5, 126, 1515, 10, 126, 7, 126, 1517, 10, 126, 12, 126, 14, 126, 1520, 11, 126, 3, 127, 7, 127, 1523, 10, 127, 12, 127, 14, 127, 1526, 11, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 1537, 10, 128, 3, 128, 3, 128, 5, 128, 1541, 10, 128, 5, 128, 1543, 10, 128, 7, 128, 1545, 10, 128, 12, 128, 14, 128, 1548, 11, 128, 3, 129, 3, 129, 5, 129, 1552, 10, 129, 3, 129, 5, 129, 1555, 10, 129, 3, 130, 3, 130, 3, 130, 7, 130, 1560, 10, 130, 12, 130, 14, 130, 1563, 11, 130, 3, 131, 5, 131, 1566, 10, 131, 3, 131, 3, 131, 3, 131, 5, 131, 1571, 10, 131, 5, 131, 1573, 10, 131, 3, 131, 3, 131, 5, 131, 1577, 10, 131, 3, 132, 5, 132, 1580, 10, 132, 3, 132, 5, 132, 1583, 10, 132, 3, 132, 3, 132, 5, 132, 1587, 10, 132, 3, 132, 3, 132, 3, 133, 5, 133, 1592, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1599, 10, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 1606, 10, 134, 3, 135, 3, 135, 3, 135, 5, 135, 1611, 10, 135, 3, 136, 3, 136, 5, 136, 1615, 10, 136, 3, 137, 3, 137, 5, 137, 1619, 10, 137, 3, 137, 3, 137, 3, 137, 5, 137, 1624, 10, 137, 7, 137, 1626, 10, 137, 12, 137, 14, 137, 1629, 11, 137, 3, 138, 3, 138, 3, 138, 5, 138, 1634, 10, 138, 5, 138, 1636, 10, 138, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1642, 10, 139, 3, 140, 3, 140, 3, 140, 5, 140, 1647, 10, 140, 3, 140, 3, 140, 3, 141, 3, 141, 5, 141, 1653, 10, 141, 3, 141, 3, 141, 5, 141, 1657, 10, 141, 5, 141, 1659, 10, 141, 3, 141, 5, 141, 1662, 10, 141, 3, 141, 3, 141, 5, 141, 1666, 10, 141, 3, 141, 3, 141, 5, 141, 1670, 10, 141, 5, 141, 1672, 10, 141, 5, 141, 1674, 10, 141, 3, 142, 5, 142, 1677, 10, 142, 3, 142, 3, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 6, 145, 1689, 10, 145, 13, 145, 14, 145, 1690, 3, 146, 5, 146, 1694, 10, 146, 3, 146, 5, 146, 1697, 10, 146, 3, 146, 5, 146, 1700, 10, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 5, 146, 1709, 10, 146, 3, 147, 3, 147, 3, 147, 7, 147, 1714, 10, 147, 12, 147, 14, 147, 1717, 11, 147, 3, 148, 3, 148, 5, 148, 1721, 10, 148, 3, 148, 5, 148, 1724, 10, 148, 3, 148, 5, 148, 1727, 10, 148, 5, 148, 1729, 10, 148, 3, 148, 5, 148, 1732, 10, 148, 3, 148, 5, 148, 1735, 10, 148, 3, 148, 3, 148, 5, 148, 1739, 10, 148, 3, 149, 6, 149, 1742, 10, 149, 13, 149, 14, 149, 1743, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 5, 153, 1757, 10, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1762, 10, 153, 7, 153, 1764, 10, 153, 12, 153, 14, 153, 1767, 11, 153, 3, 154, 5, 154, 1770, 10, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1775, 10, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1780, 10, 154, 3, 154, 3, 154, 5, 154, 1784, 10, 154, 3, 155, 5, 155, 1787, 10, 155, 3, 155, 3, 155, 5, 155, 1791, 10, 155, 3, 156, 3, 156, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 5, 159, 1802, 10, 159, 3, 160, 3, 160, 5, 160, 1806, 10, 160, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 5, 162, 1813, 10, 162, 3, 162, 3, 162, 3, 162, 5, 162, 1818, 10, 162, 7, 162, 1820, 10, 162, 12, 162, 14, 162, 1823, 11, 162, 3, 163, 3, 163, 3, 163, 5, 163, 1828, 10, 163, 3, 163, 3, 163, 5, 163, 1832, 10, 163, 3, 164, 3, 164, 5, 164, 1836, 10, 164, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 5, 166, 1845, 10, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 7, 168, 1856, 10, 168, 12, 168, 14, 168, 1859, 11, 168, 3, 169, 3, 169, 5, 169, 1863, 10, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 1870, 10, 170, 3, 170, 3, 170, 5, 170, 1874, 10, 170, 3, 170, 5, 170, 1877, 10, 170, 3, 170, 5, 170, 1880, 10, 170, 3, 170, 5, 170, 1883, 10, 170, 3, 170, 3, 170, 5, 170, 1887, 10, 170, 3, 171, 3, 171, 3, 171, 5, 171, 1892, 10, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 5, 172, 1899, 10, 172, 3, 172, 3, 172, 5, 172, 1903, 10, 172, 3, 172, 3, 172, 5, 172, 1907, 10, 172, 3, 173, 3, 173, 3, 174, 3, 174, 5, 174, 1913, 10, 174, 3, 174, 3, 174, 3, 174, 5, 174, 1918, 10, 174, 7, 174, 1920, 10, 174, 12, 174, 14, 174, 1923, 11, 174, 3, 175, 3, 175, 3, 175, 5, 175, 1928, 10, 175, 3, 176, 3, 176, 3, 176, 3, 176, 5, 176, 1934, 10, 176, 3, 176, 5, 176, 1937, 10, 176, 3, 177, 5, 177, 1940, 10, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 5, 180, 1956, 10, 180, 3, 180, 3, 180, 3, 180, 3, 181, 6, 181, 1962, 10, 181, 13, 181, 14, 181, 1963, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 183, 5, 183, 1973, 10, 183, 3, 183, 3, 183, 3, 183, 5, 183, 1978, 10, 183, 3, 183, 5, 183, 1981, 10, 183, 3, 184, 3, 184, 5, 184, 1985, 10, 184, 3, 185, 3, 185, 5, 185, 1989, 10, 185, 3, 186, 3, 186, 3, 186, 5, 186, 1994, 10, 186, 3, 186, 3, 186, 3, 187, 3, 187, 5, 187, 2000, 10, 187, 3, 187, 3, 187, 3, 187, 5, 187, 2005, 10, 187, 7, 187, 2007, 10, 187, 12, 187, 14, 187, 2010, 11, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 2018, 10, 188, 3, 189, 3, 189, 3, 189, 5, 189, 2023, 10, 189, 3, 189, 3, 189, 3, 189, 5, 189, 2028, 10, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 5, 189, 2073, 10, 189, 3, 190, 3, 190, 3, 190, 2, 8, 12, 32, 52, 228, 250, 254, 191, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 2, 23, 4, 2, 99, 99, 103, 103, 6, 2, 26, 26, 33, 33, 60, 60, 67, 67, 4, 2, 126, 126, 131, 131, 3, 2, 122, 123, 4, 2, 93, 95, 99, 102, 4, 2, 125, 125, 132, 132, 3, 2, 95, 97, 3, 2, 93, 94, 4, 2, 104, 105, 118, 119, 3, 2, 116, 117, 4, 2, 103, 103, 106, 115, 7, 2, 38, 38, 49, 49, 59, 59, 65, 65, 72, 72, 5, 2, 36, 36, 46, 46, 82, 82, 4, 2, 23, 23, 68, 68, 3, 2, 87, 92, 4, 2, 99, 99, 120, 120, 4, 2, 24, 24, 84, 84, 3, 2, 29, 30, 4, 2, 40, 40, 55, 55, 3, 2, 56, 58, 3, 2, 3, 9, 2, 2307, 2, 381, 3, 2, 2, 2, 4, 397, 3, 2, 2, 2, 6, 401, 3, 2, 2, 2, 8, 413, 3, 2, 2, 2, 10, 415, 3, 2, 2, 2, 12, 421, 3, 2, 2, 2, 14, 443, 3, 2, 2, 2, 16, 449, 3, 2, 2, 2, 18, 461, 3, 2, 2, 2, 20, 463, 3, 2, 2, 2, 22, 465, 3, 2, 2, 2, 24, 478, 3, 2, 2, 2, 26, 485, 3, 2, 2, 2, 28, 488, 3, 2, 2, 2, 30, 493, 3, 2, 2, 2, 32, 540, 3, 2, 2, 2, 34, 572, 3, 2, 2, 2, 36, 574, 3, 2, 2, 2, 38, 595, 3, 2, 2, 2, 40, 624, 3, 2, 2, 2, 42, 626, 3, 2, 2, 2, 44, 629, 3, 2, 2, 2, 46, 645, 3, 2, 2, 2, 48, 649, 3, 2, 2, 2, 50, 658, 3, 2, 2, 2, 52, 660, 3, 2, 2, 2, 54, 685, 3, 2, 2, 2, 56, 688, 3, 2, 2, 2, 58, 697, 3, 2, 2, 2, 60, 708, 3, 2, 2, 2, 62, 710, 3, 2, 2, 2, 64, 718, 3, 2, 2, 2, 66, 726, 3, 2, 2, 2, 68, 734, 3, 2, 2, 2, 70, 747, 3, 2, 2, 2, 72, 749, 3, 2, 2, 2, 74, 757, 3, 2, 2, 2, 76, 765, 3, 2, 2, 2, 78, 773, 3, 2, 2, 2, 80, 781, 3, 2, 2, 2, 82, 789, 3, 2, 2, 2, 84, 797, 3, 2, 2, 2, 86, 805, 3, 2, 2, 2, 88, 819, 3, 2, 2, 2, 90, 821, 3, 2, 2, 2, 92, 823, 3, 2, 2, 2, 94, 831, 3, 2, 2, 2, 96, 846, 3, 2, 2, 2, 98, 849, 3, 2, 2, 2, 100, 861, 3, 2, 2, 2, 102, 865, 3, 2, 2, 2, 104, 872, 3, 2, 2, 2, 106, 891, 3, 2, 2, 2, 108, 904, 3, 2, 2, 2, 110, 939, 3, 2, 2, 2, 112, 943, 3, 2, 2, 2, 114, 946, 3, 2, 2, 2, 116, 953, 3, 2, 2, 2, 118, 964, 3, 2, 2, 2, 120, 968, 3, 2, 2, 2, 122, 971, 3, 2, 2, 2, 124, 984, 3, 2, 2, 2, 126, 994, 3, 2, 2, 2, 128, 996, 3, 2, 2, 2, 130, 1019, 3, 2, 2, 2, 132, 1021, 3, 2, 2, 2, 134, 1029, 3, 2, 2, 2, 136, 1031, 3, 2, 2, 2, 138, 1040, 3, 2, 2, 2, 140, 1043, 3, 2, 2, 2, 142, 1050, 3, 2, 2, 2, 144, 1052, 3, 2, 2, 2, 146, 1054, 3, 2, 2, 2, 148, 1059, 3, 2, 2, 2, 150, 1065, 3, 2, 2, 2, 152, 1068, 3, 2, 2, 2, 154, 1076, 3, 2, 2, 2, 156, 1106, 3, 2, 2, 2, 158, 1112, 3, 2, 2, 2, 160, 1114, 3, 2, 2, 2, 162, 1144, 3, 2, 2, 2, 164, 1146, 3, 2, 2, 2, 166, 1148, 3, 2, 2, 2, 168, 1158, 3, 2, 2, 2, 170, 1171, 3, 2, 2, 2, 172, 1181, 3, 2, 2, 2, 174, 1185, 3, 2, 2, 2, 176, 1188, 3, 2, 2, 2, 178, 1196, 3, 2, 2, 2, 180, 1201, 3, 2, 2, 2, 182, 1205, 3, 2, 2, 2, 184, 1207, 3, 2, 2, 2, 186, 1210, 3, 2, 2, 2, 188, 1223, 3, 2, 2, 2, 190, 1225, 3, 2, 2, 2, 192, 1232, 3, 2, 2, 2, 194, 1236, 3, 2, 2, 2, 196, 1248, 3, 2, 2, 2, 198, 1258, 3, 2, 2, 2, 200, 1264, 3, 2, 2, 2, 202, 1275, 3, 2, 2, 2, 204, 1287, 3, 2, 2, 2, 206, 1289, 3, 2, 2, 2, 208, 1300, 3, 2, 2, 2, 210, 1314, 3, 2, 2, 2, 212, 1320, 3, 2, 2, 2, 214, 1322, 3, 2, 2, 2, 216, 1329, 3, 2, 2, 2, 218, 1350, 3, 2, 2, 2, 220, 1352, 3, 2, 2, 2, 222, 1360, 3, 2, 2, 2, 224, 1369, 3, 2, 2, 2, 226, 1377, 3, 2, 2, 2, 228, 1391, 3, 2, 2, 2, 230, 1410, 3, 2, 2, 2, 232, 1427, 3, 2, 2, 2, 234, 1446, 3, 2, 2, 2, 236, 1449, 3, 2, 2, 2, 238, 1453, 3, 2, 2, 2, 240, 1455, 3, 2, 2, 2, 242, 1458, 3, 2, 2, 2, 244, 1462, 3, 2, 2, 2, 246, 1474, 3, 2, 2, 2, 248, 1485, 3, 2, 2, 2, 250, 1501, 3, 2, 2, 2, 252, 1524, 3, 2, 2, 2, 254, 1529, 3, 2, 2, 2, 256, 1549, 3, 2, 2, 2, 258, 1556, 3, 2, 2, 2, 260, 1565, 3, 2, 2, 2, 262, 1579, 3, 2, 2, 2, 264, 1598, 3, 2, 2, 2, 266, 1605, 3, 2, 2, 2, 268, 1610, 3, 2, 2, 2, 270, 1614, 3, 2, 2, 2, 272, 1616, 3, 2, 2, 2, 274, 1630, 3, 2, 2, 2, 276, 1641, 3, 2, 2, 2, 278, 1643, 3, 2, 2, 2, 280, 1673, 3, 2, 2, 2, 282, 1676, 3, 2, 2, 2, 284, 1680, 3, 2, 2, 2, 286, 1682, 3, 2, 2, 2, 288, 1688, 3, 2, 2, 2, 290, 1708, 3, 2, 2, 2, 292, 1710, 3, 2, 2, 2, 294, 1738, 3, 2, 2, 2, 296, 1741, 3, 2, 2, 2, 298, 1745, 3, 2, 2, 2, 300, 1747, 3, 2, 2, 2, 302, 1751, 3, 2, 2, 2, 304, 1754, 3, 2, 2, 2, 306, 1769, 3, 2, 2, 2, 308, 1790, 3, 2, 2, 2, 310, 1792, 3, 2, 2, 2, 312, 1794, 3, 2, 2, 2, 314, 1796, 3, 2, 2, 2, 316, 1799, 3, 2, 2, 2, 318, 1803, 3, 2, 2, 2, 320, 1807, 3, 2, 2, 2, 322, 1810, 3, 2, 2, 2, 324, 1824, 3, 2, 2, 2, 326, 1835, 3, 2, 2, 2, 328, 1837, 3, 2, 2, 2, 330, 1840, 3, 2, 2, 2, 332, 1846, 3, 2, 2, 2, 334, 1852, 3, 2, 2, 2, 336, 1862, 3, 2, 2, 2, 338, 1873, 3, 2, 2, 2, 340, 1888, 3, 2, 2, 2, 342, 1906, 3, 2, 2, 2, 344, 1908, 3, 2, 2, 2, 346, 1910, 3, 2, 2, 2, 348, 1927, 3, 2, 2, 2, 350, 1929, 3, 2, 2, 2, 352, 1939, 3, 2, 2, 2, 354, 1944, 3, 2, 2, 2, 356, 1949, 3, 2, 2, 2, 358, 1953, 3, 2, 2, 2, 360, 1961, 3, 2, 2, 2, 362, 1965, 3, 2, 2, 2, 364, 1980, 3, 2, 2, 2, 366, 1982, 3, 2, 2, 2, 368, 1988, 3, 2, 2, 2, 370, 1990, 3, 2, 2, 2, 372, 1997, 3, 2, 2, 2, 374, 2017, 3, 2, 2, 2, 376, 2072, 3, 2, 2, 2, 378, 2074, 3, 2, 2, 2, 380, 382, 5, 122, 62, 2, 381, 380, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 383, 3, 2, 2, 2, 383, 384, 7, 2, 2, 3, 384, 3, 3, 2, 2, 2, 385, 387, 5, 378, 190, 2, 386, 385, 3, 2, 2, 2, 387, 388, 3, 2, 2, 2, 388, 386, 3, 2, 2, 2, 388, 389, 3, 2, 2, 2, 389, 398, 3, 2, 2, 2, 390, 398, 7, 71, 2, 2, 391, 392, 7, 87, 2, 2, 392, 393, 5, 92, 47, 2, 393, 394, 7, 88, 2, 2, 394, 398, 3, 2, 2, 2, 395, 398, 5, 6, 4, 2, 396, 398, 5, 14, 8, 2, 397, 386, 3, 2, 2, 2, 397, 390, 3, 2, 2, 2, 397, 391, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 397, 396, 3, 2, 2, 2, 398, 5, 3, 2, 2, 2, 399, 402, 5, 8, 5, 2, 400, 402, 5, 10, 6, 2, 401, 399, 3, 2, 2, 2, 401, 400, 3, 2, 2, 2, 402, 7, 3, 2, 2, 2, 403, 414, 7, 134, 2, 2, 404, 414, 5, 328, 165, 2, 405, 414, 5, 314, 158, 2, 406, 414, 5, 330, 166, 2, 407, 410, 7, 101, 2, 2, 408, 411, 5, 276, 139, 2, 409, 411, 5, 160, 81, 2, 410, 408, 3, 2, 2, 2, 410, 409, 3, 2, 2, 2, 411, 414, 3, 2, 2, 2, 412, 414, 5, 342, 172, 2, 413, 403, 3, 2, 2, 2, 413, 404, 3, 2, 2, 2, 413, 405, 3, 2, 2, 2, 413, 406, 3, 2, 2, 2, 413, 407, 3, 2, 2, 2, 413, 412, 3, 2, 2, 2, 414, 9, 3, 2, 2, 2, 415, 417, 5, 12, 7, 2, 416, 418, 7, 70, 2, 2, 417, 416, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418, 419, 3, 2, 2, 2, 419, 420, 5, 8, 5, 2, 420, 11, 3, 2, 2, 2, 421, 425, 8, 7, 1, 2, 422, 426, 5, 158, 80, 2, 423, 426, 5, 182, 92, 2, 424, 426, 5, 160, 81, 2, 425, 422, 3, 2, 2, 2, 425, 423, 3, 2, 2, 2, 425, 424, 3, 2, 2, 2, 425, 426, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 428, 7, 129, 2, 2, 428, 440, 3, 2, 2, 2, 429, 435, 12, 3, 2, 2, 430, 436, 7, 134, 2, 2, 431, 433, 7, 70, 2, 2, 432, 431, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 434, 3, 2, 2, 2, 434, 436, 5, 340, 171, 2, 435, 430, 3, 2, 2, 2, 435, 432, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 439, 7, 129, 2, 2, 438, 429, 3, 2, 2, 2, 439, 442, 3, 2, 2, 2, 440, 438, 3, 2, 2, 2, 440, 441, 3, 2, 2, 2, 441, 13, 3, 2, 2, 2, 442, 440, 3, 2, 2, 2, 443, 445, 5, 16, 9, 2, 444, 446, 5, 30, 16, 2, 445, 444, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 447, 3, 2, 2, 2, 447, 448, 5, 102, 52, 2, 448, 15, 3, 2, 2, 2, 449, 451, 7, 89, 2, 2, 450, 452, 5, 18, 10, 2, 451, 450, 3, 2, 2, 2, 451, 452, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 454, 7, 90, 2, 2, 454, 17, 3, 2, 2, 2, 455, 462, 5, 22, 12, 2, 456, 459, 5, 20, 11, 2, 457, 458, 7, 124, 2, 2, 458, 460, 5, 22, 12, 2, 459, 457, 3, 2, 2, 2, 459, 460, 3, 2, 2, 2, 460, 462, 3, 2, 2, 2, 461, 455, 3, 2, 2, 2, 461, 456, 3, 2, 2, 2, 462, 19, 3, 2, 2, 2, 463, 464, 9, 2, 2, 2, 464, 21, 3, 2, 2, 2, 465, 470, 5, 24, 13, 2, 466, 467, 7, 124, 2, 2, 467, 469, 5, 24, 13, 2, 468, 466, 3, 2, 2, 2, 469, 472, 3, 2, 2, 2, 470, 468, 3, 2, 2, 2, 470, 471, 3, 2, 2, 2, 471, 474, 3, 2, 2, 2, 472, 470, 3, 2, 2, 2, 473, 475, 7, 133, 2, 2, 474, 473, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 23, 3, 2, 2, 2, 476, 479, 5, 26, 14, 2, 477, 479, 5, 28, 15, 2, 478, 476, 3, 2, 2, 2, 478, 477, 3, 2, 2, 2, 479, 25, 3, 2, 2, 2, 480, 482, 7, 99, 2, 2, 481, 480, 3, 2, 2, 2, 481, 482, 3, 2, 2, 2, 482, 483, 3, 2, 2, 2, 483, 486, 7, 134, 2, 2, 484, 486, 7, 71, 2, 2, 485, 481, 3, 2, 2, 2, 485, 484, 3, 2, 2, 2, 486, 27, 3, 2, 2, 2, 487, 489, 7, 99, 2, 2, 488, 487, 3, 2, 2, 2, 488, 489, 3, 2, 2, 2, 489, 490, 3, 2, 2, 2, 490, 491, 7, 134, 2, 2, 491, 492, 5, 266, 134, 2, 492, 29, 3, 2, 2, 2, 493, 495, 7, 87, 2, 2, 494, 496, 5, 256, 129, 2, 495, 494, 3, 2, 2, 2, 495, 496, 3, 2, 2, 2, 496, 497, 3, 2, 2, 2, 497, 499, 7, 88, 2, 2, 498, 500, 7, 49, 2, 2, 499, 498, 3, 2, 2, 2, 499, 500, 3, 2, 2, 2, 500, 502, 3, 2, 2, 2, 501, 503, 5, 368, 185, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 505, 3, 2, 2, 2, 504, 506, 5, 202, 102, 2, 505, 504, 3, 2, 2, 2, 505, 506, 3, 2, 2, 2, 506, 508, 3, 2, 2, 2, 507, 509, 5, 232, 117, 2, 508, 507, 3, 2, 2, 2, 508, 509, 3, 2, 2, 2, 509, 31, 3, 2, 2, 2, 510, 511, 8, 17, 1, 2, 511, 541, 5, 4, 3, 2, 512, 515, 5, 156, 79, 2, 513, 515, 5, 350, 176, 2, 514, 512, 3, 2, 2, 2, 514, 513, 3, 2, 2, 2, 515, 522, 3, 2, 2, 2, 516, 518, 7, 87, 2, 2, 517, 519, 5, 36, 19, 2, 518, 517, 3, 2, 2, 2, 518, 519, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 523, 7, 88, 2, 2, 521, 523, 5, 274, 138, 2, 522, 516, 3, 2, 2, 2, 522, 521, 3, 2, 2, 2, 523, 541, 3, 2, 2, 2, 524, 525, 9, 3, 2, 2, 525, 526, 7, 104, 2, 2, 526, 527, 5, 244, 123, 2, 527, 528, 7, 105, 2, 2, 528, 529, 7, 87, 2, 2, 529, 530, 5, 92, 47, 2, 530, 531, 7, 88, 2, 2, 531, 541, 3, 2, 2, 2, 532, 533, 5, 34, 18, 2, 533, 536, 7, 87, 2, 2, 534, 537, 5, 92, 47, 2, 535, 537, 5, 244, 123, 2, 536, 534, 3, 2, 2, 2, 536, 535, 3, 2, 2, 2, 537, 538, 3, 2, 2, 2, 538, 539, 7, 88, 2, 2, 539, 541, 3, 2, 2, 2, 540, 510, 3, 2, 2, 2, 540, 514, 3, 2, 2, 2, 540, 524, 3, 2, 2, 2, 540, 532, 3, 2, 2, 2, 541, 569, 3, 2, 2, 2, 542, 543, 12, 9, 2, 2, 543, 546, 7, 89, 2, 2, 544, 547, 5, 92, 47, 2, 545, 547, 5, 274, 138, 2, 546, 544, 3, 2, 2, 2, 546, 545, 3, 2, 2, 2, 547, 548, 3, 2, 2, 2, 548, 549, 7, 90, 2, 2, 549, 568, 3, 2, 2, 2, 550, 551, 12, 8, 2, 2, 551, 553, 7, 87, 2, 2, 552, 554, 5, 36, 19, 2, 553, 552, 3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 568, 7, 88, 2, 2, 556, 557, 12, 6, 2, 2, 557, 563, 9, 4, 2, 2, 558, 560, 7, 70, 2, 2, 559, 558, 3, 2, 2, 2, 559, 560, 3, 2, 2, 2, 560, 561, 3, 2, 2, 2, 561, 564, 5, 6, 4, 2, 562, 564, 5, 38, 20, 2, 563, 559, 3, 2, 2, 2, 563, 562, 3, 2, 2, 2, 564, 568, 3, 2, 2, 2, 565, 566, 12, 5, 2, 2, 566, 568, 9, 5, 2, 2, 567, 542, 3, 2, 2, 2, 567, 550, 3, 2, 2, 2, 567, 556, 3, 2, 2, 2, 567, 565, 3, 2, 2, 2, 568, 571, 3, 2, 2, 2, 569, 567, 3, 2, 2, 2, 569, 570, 3, 2, 2, 2, 570, 33, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 572, 573, 7, 77, 2, 2, 573, 35, 3, 2, 2, 2, 574, 575, 5, 272, 137, 2, 575, 37, 3, 2, 2, 2, 576, 578, 5, 12, 7, 2, 577, 576, 3, 2, 2, 2, 577, 578, 3, 2, 2, 2, 578, 582, 3, 2, 2, 2, 579, 580, 5, 158, 80, 2, 580, 581, 7, 129, 2, 2, 581, 583, 3, 2, 2, 2, 582, 579, 3, 2, 2, 2, 582, 583, 3, 2, 2, 2, 583, 584, 3, 2, 2, 2, 584, 585, 7, 101, 2, 2, 585, 596, 5, 158, 80, 2, 586, 587, 5, 12, 7, 2, 587, 588, 7, 70, 2, 2, 588, 589, 5, 340, 171, 2, 589, 590, 7, 129, 2, 2, 590, 591, 7, 101, 2, 2, 591, 592, 5, 158, 80, 2, 592, 596, 3, 2, 2, 2, 593, 594, 7, 101, 2, 2, 594, 596, 5, 160, 81, 2, 595, 577, 3, 2, 2, 2, 595, 586, 3, 2, 2, 2, 595, 593, 3, 2, 2, 2, 596, 39, 3, 2, 2, 2, 597, 625, 5, 32, 17, 2, 598, 603, 7, 122, 2, 2, 599, 603, 7, 123, 2, 2, 600, 603, 5, 42, 22, 2, 601, 603, 7, 64, 2, 2, 602, 598, 3, 2, 2, 2, 602, 599, 3, 2, 2, 2, 602, 600, 3, 2, 2, 2, 602, 601, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 625, 5, 40, 21, 2, 605, 614, 7, 64, 2, 2, 606, 607, 7, 87, 2, 2, 607, 608, 5, 244, 123, 2, 608, 609, 7, 88, 2, 2, 609, 615, 3, 2, 2, 2, 610, 611, 7, 133, 2, 2, 611, 612, 7, 87, 2, 2, 612, 613, 7, 134, 2, 2, 613, 615, 7, 88, 2, 2, 614, 606, 3, 2, 2, 2, 614, 610, 3, 2, 2, 2, 615, 625, 3, 2, 2, 2, 616, 617, 7, 13, 2, 2, 617, 618, 7, 87, 2, 2, 618, 619, 5, 244, 123, 2, 619, 620, 7, 88, 2, 2, 620, 625, 3, 2, 2, 2, 621, 625, 5, 58, 30, 2, 622, 625, 5, 44, 23, 2, 623, 625, 5, 56, 29, 2, 624, 597, 3, 2, 2, 2, 624, 602, 3, 2, 2, 2, 624, 605, 3, 2, 2, 2, 624, 616, 3, 2, 2, 2, 624, 621, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 624, 623, 3, 2, 2, 2, 625, 41, 3, 2, 2, 2, 626, 627, 9, 6, 2, 2, 627, 43, 3, 2, 2, 2, 628, 630, 7, 129, 2, 2, 629, 628, 3, 2, 2, 2, 629, 630, 3, 2, 2, 2, 630, 631, 3, 2, 2, 2, 631, 633, 7, 51, 2, 2, 632, 634, 5, 46, 24, 2, 633, 632, 3, 2, 2, 2, 633, 634, 3, 2, 2, 2, 634, 640, 3, 2, 2, 2, 635, 641, 5, 48, 25, 2, 636, 637, 7, 87, 2, 2, 637, 638, 5, 244, 123, 2, 638, 639, 7, 88, 2, 2, 639, 641, 3, 2, 2, 2, 640, 635, 3, 2, 2, 2, 640, 636, 3, 2, 2, 2, 641, 643, 3, 2, 2, 2, 642, 644, 5, 54, 28, 2, 643, 642, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2, 644, 45, 3, 2, 2, 2, 645, 646, 7, 87, 2, 2, 646, 647, 5, 36, 19, 2, 647, 648, 7, 88, 2, 2, 648, 47, 3, 2, 2, 2, 649, 651, 5, 152, 77, 2, 650, 652, 5, 50, 26, 2, 651, 650, 3, 2, 2, 2, 651, 652, 3, 2, 2, 2, 652, 49, 3, 2, 2, 2, 653, 655, 5, 234, 118, 2, 654, 656, 5, 50, 26, 2, 655, 654, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2, 656, 659, 3, 2, 2, 2, 657, 659, 5, 52, 27, 2, 658, 653, 3, 2, 2, 2, 658, 657, 3, 2, 2, 2, 659, 51, 3, 2, 2, 2, 660, 661, 8, 27, 1, 2, 661, 662, 7, 89, 2, 2, 662, 663, 5, 92, 47, 2, 663, 665, 7, 90, 2, 2, 664, 666, 5, 202, 102, 2, 665, 664, 3, 2, 2, 2, 665, 666, 3, 2, 2, 2, 666, 676, 3, 2, 2, 2, 667, 668, 12, 3, 2, 2, 668, 669, 7, 89, 2, 2, 669, 670, 5, 94, 48, 2, 670, 672, 7, 90, 2, 2, 671, 673, 5, 202, 102, 2, 672, 671, 3, 2, 2, 2, 672, 673, 3, 2, 2, 2, 673, 675, 3, 2, 2, 2, 674, 667, 3, 2, 2, 2, 675, 678, 3, 2, 2, 2, 676, 674, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 53, 3, 2, 2, 2, 678, 676, 3, 2, 2, 2, 679, 681, 7, 87, 2, 2, 680, 682, 5, 36, 19, 2, 681, 680, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 683, 3, 2, 2, 2, 683, 686, 7, 88, 2, 2, 684, 686, 5, 274, 138, 2, 685, 679, 3, 2, 2, 2, 685, 684, 3, 2, 2, 2, 686, 55, 3, 2, 2, 2, 687, 689, 7, 129, 2, 2, 688, 687, 3, 2, 2, 2, 688, 689, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 693, 7, 30, 2, 2, 691, 692, 7, 89, 2, 2, 692, 694, 7, 90, 2, 2, 693, 691, 3, 2, 2, 2, 693, 694, 3, 2, 2, 2, 694, 695, 3, 2, 2, 2, 695, 696, 5, 60, 31, 2, 696, 57, 3, 2, 2, 2, 697, 698, 7, 52, 2, 2, 698, 699, 7, 87, 2, 2, 699, 700, 5, 92, 47, 2, 700, 701, 7, 88, 2, 2, 701, 59, 3, 2, 2, 2, 702, 709, 5, 40, 21, 2, 703, 704, 7, 87, 2, 2, 704, 705, 5, 244, 123, 2, 705, 706, 7, 88, 2, 2, 706, 707, 5, 60, 31, 2, 707, 709, 3, 2, 2, 2, 708, 702, 3, 2, 2, 2, 708, 703, 3, 2, 2, 2, 709, 61, 3, 2, 2, 2, 710, 715, 5, 60, 31, 2, 711, 712, 9, 7, 2, 2, 712, 714, 5, 60, 31, 2, 713, 711, 3, 2, 2, 2, 714, 717, 3, 2, 2, 2, 715, 713, 3, 2, 2, 2, 715, 716, 3, 2, 2, 2, 716, 63, 3, 2, 2, 2, 717, 715, 3, 2, 2, 2, 718, 723, 5, 62, 32, 2, 719, 720, 9, 8, 2, 2, 720, 722, 5, 62, 32, 2, 721, 719, 3, 2, 2, 2, 722, 725, 3, 2, 2, 2, 723, 721, 3, 2, 2, 2, 723, 724, 3, 2, 2, 2, 724, 65, 3, 2, 2, 2, 725, 723, 3, 2, 2, 2, 726, 731, 5, 64, 33, 2, 727, 728, 9, 9, 2, 2, 728, 730, 5, 64, 33, 2, 729, 727, 3, 2, 2, 2, 730, 733, 3, 2, 2, 2, 731, 729, 3, 2, 2, 2, 731, 732, 3, 2, 2, 2, 732, 67, 3, 2, 2, 2, 733, 731, 3, 2, 2, 2, 734, 740, 5, 66, 34, 2, 735, 736, 5, 70, 36, 2, 736, 737, 5, 66, 34, 2, 737, 739, 3, 2, 2, 2, 738, 735, 3, 2, 2, 2, 739, 742, 3, 2, 2, 2, 740, 738, 3, 2, 2, 2, 740, 741, 3, 2, 2, 2, 741, 69, 3, 2, 2, 2, 742, 740, 3, 2, 2, 2, 743, 744, 7, 105, 2, 2, 744, 748, 7, 105, 2, 2, 745, 746, 7, 104, 2, 2, 746, 748, 7, 104, 2, 2, 747, 743, 3, 2, 2, 2, 747, 745, 3, 2, 2, 2, 748, 71, 3, 2, 2, 2, 749, 754, 5, 68, 35, 2, 750, 751, 9, 10, 2, 2, 751, 753, 5, 68, 35, 2, 752, 750, 3, 2, 2, 2, 753, 756, 3, 2, 2, 2, 754, 752, 3, 2, 2, 2, 754, 755, 3, 2, 2, 2, 755, 73, 3, 2, 2, 2, 756, 754, 3, 2, 2, 2, 757, 762, 5, 72, 37, 2, 758, 759, 9, 11, 2, 2, 759, 761, 5, 72, 37, 2, 760, 758, 3, 2, 2, 2, 761, 764, 3, 2, 2, 2, 762, 760, 3, 2, 2, 2, 762, 763, 3, 2, 2, 2, 763, 75, 3, 2, 2, 2, 764, 762, 3, 2, 2, 2, 765, 770, 5, 74, 38, 2, 766, 767, 7, 99, 2, 2, 767, 769, 5, 74, 38, 2, 768, 766, 3, 2, 2, 2, 769, 772, 3, 2, 2, 2, 770, 768, 3, 2, 2, 2, 770, 771, 3, 2, 2, 2, 771, 77, 3, 2, 2, 2, 772, 770, 3, 2, 2, 2, 773, 778, 5, 76, 39, 2, 774, 775, 7, 98, 2, 2, 775, 777, 5, 76, 39, 2, 776, 774, 3, 2, 2, 2, 777, 780, 3, 2, 2, 2, 778, 776, 3, 2, 2, 2, 778, 779, 3, 2, 2, 2, 779, 79, 3, 2, 2, 2, 780, 778, 3, 2, 2, 2, 781, 786, 5, 78, 40, 2, 782, 783, 7, 100, 2, 2, 783, 785, 5, 78, 40, 2, 784, 782, 3, 2, 2, 2, 785, 788, 3, 2, 2, 2, 786, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 81, 3, 2, 2, 2, 788, 786, 3, 2, 2, 2, 789, 794, 5, 80, 41, 2, 790, 791, 7, 120, 2, 2, 791, 793, 5, 80, 41, 2, 792, 790, 3, 2, 2, 2, 793, 796, 3, 2, 2, 2, 794, 792, 3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 83, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 802, 5, 82, 42, 2, 798, 799, 7, 121, 2, 2, 799, 801, 5, 82, 42, 2, 800, 798, 3, 2, 2, 2, 801, 804, 3, 2, 2, 2, 802, 800, 3, 2, 2, 2, 802, 803, 3, 2, 2, 2, 803, 85, 3, 2, 2, 2, 804, 802, 3, 2, 2, 2, 805, 811, 5, 84, 43, 2, 806, 807, 7, 127, 2, 2, 807, 808, 5, 92, 47, 2, 808, 809, 7, 128, 2, 2, 809, 810, 5, 88, 45, 2, 810, 812, 3, 2, 2, 2, 811, 806, 3, 2, 2, 2, 811, 812, 3, 2, 2, 2, 812, 87, 3, 2, 2, 2, 813, 820, 5, 86, 44, 2, 814, 815, 5, 84, 43, 2, 815, 816, 5, 90, 46, 2, 816, 817, 5, 270, 136, 2, 817, 820, 3, 2, 2, 2, 818, 820, 5, 366, 184, 2, 819, 813, 3, 2, 2, 2, 819, 814, 3, 2, 2, 2, 819, 818, 3, 2, 2, 2, 820, 89, 3, 2, 2, 2, 821, 822, 9, 12, 2, 2, 822, 91, 3, 2, 2, 2, 823, 828, 5, 88, 45, 2, 824, 825, 7, 124, 2, 2, 825, 827, 5, 88, 45, 2, 826, 824, 3, 2, 2, 2, 827, 830, 3, 2, 2, 2, 828, 826, 3, 2, 2, 2, 828, 829, 3, 2, 2, 2, 829, 93, 3, 2, 2, 2, 830, 828, 3, 2, 2, 2, 831, 832, 5, 86, 44, 2, 832, 95, 3, 2, 2, 2, 833, 847, 5, 98, 50, 2, 834, 836, 5, 202, 102, 2, 835, 834, 3, 2, 2, 2, 835, 836, 3, 2, 2, 2, 836, 843, 3, 2, 2, 2, 837, 844, 5, 100, 51, 2, 838, 844, 5, 102, 52, 2, 839, 844, 5, 106, 54, 2, 840, 844, 5, 110, 56, 2, 841, 844, 5, 118, 60, 2, 842, 844, 5, 356, 179, 2, 843, 837, 3, 2, 2, 2, 843, 838, 3, 2, 2, 2, 843, 839, 3, 2, 2, 2, 843, 840, 3, 2, 2, 2, 843, 841, 3, 2, 2, 2, 843, 842, 3, 2, 2, 2, 844, 847, 3, 2, 2, 2, 845, 847, 5, 120, 61, 2, 846, 833, 3, 2, 2, 2, 846, 835, 3, 2, 2, 2, 846, 845, 3, 2, 2, 2, 847, 97, 3, 2, 2, 2, 848, 850, 5, 202, 102, 2, 849, 848, 3, 2, 2, 2, 849, 850, 3, 2, 2, 2, 850, 855, 3, 2, 2, 2, 851, 856, 7, 134, 2, 2, 852, 853, 7, 18, 2, 2, 853, 856, 5, 94, 48, 2, 854, 856, 7, 29, 2, 2, 855, 851, 3, 2, 2, 2, 855, 852, 3, 2, 2, 2, 855, 854, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 858, 7, 128, 2, 2, 858, 859, 5, 96, 49, 2, 859, 99, 3, 2, 2, 2, 860, 862, 5, 92, 47, 2, 861, 860, 3, 2, 2, 2, 861, 862, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 864, 7, 130, 2, 2, 864, 101, 3, 2, 2, 2, 865, 867, 7, 91, 2, 2, 866, 868, 5, 104, 53, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 870, 7, 92, 2, 2, 870, 103, 3, 2, 2, 2, 871, 873, 5, 96, 49, 2, 872, 871, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 872, 3, 2, 2, 2, 874, 875, 3, 2, 2, 2, 875, 105, 3, 2, 2, 2, 876, 877, 7, 45, 2, 2, 877, 878, 7, 87, 2, 2, 878, 879, 5, 108, 55, 2, 879, 880, 7, 88, 2, 2, 880, 883, 5, 96, 49, 2, 881, 882, 7, 34, 2, 2, 882, 884, 5, 96, 49, 2, 883, 881, 3, 2, 2, 2, 883, 884, 3, 2, 2, 2, 884, 892, 3, 2, 2, 2, 885, 886, 7, 69, 2, 2, 886, 887, 7, 87, 2, 2, 887, 888, 5, 108, 55, 2, 888, 889, 7, 88, 2, 2, 889, 890, 5, 96, 49, 2, 890, 892, 3, 2, 2, 2, 891, 876, 3, 2, 2, 2, 891, 885, 3, 2, 2, 2, 892, 107, 3, 2, 2, 2, 893, 905, 5, 92, 47, 2, 894, 896, 5, 202, 102, 2, 895, 894, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 897, 3, 2, 2, 2, 897, 898, 5, 140, 71, 2, 898, 902, 5, 224, 113, 2, 899, 900, 7, 103, 2, 2, 900, 903, 5, 270, 136, 2, 901, 903, 5, 274, 138, 2, 902, 899, 3, 2, 2, 2, 902, 901, 3, 2, 2, 2, 903, 905, 3, 2, 2, 2, 904, 893, 3, 2, 2, 2, 904, 895, 3, 2, 2, 2, 905, 109, 3, 2, 2, 2, 906, 907, 7, 86, 2, 2, 907, 908, 7, 87, 2, 2, 908, 909, 5, 108, 55, 2, 909, 910, 7, 88, 2, 2, 910, 911, 5, 96, 49, 2, 911, 940, 3, 2, 2, 2, 912, 913, 7, 31, 2, 2, 913, 914, 5, 96, 49, 2, 914, 915, 7, 86, 2, 2, 915, 916, 7, 87, 2, 2, 916, 917, 5, 92, 47, 2, 917, 918, 7, 88, 2, 2, 918, 919, 7, 130, 2, 2, 919, 940, 3, 2, 2, 2, 920, 921, 7, 42, 2, 2, 921, 934, 7, 87, 2, 2, 922, 924, 5, 112, 57, 2, 923, 925, 5, 108, 55, 2, 924, 923, 3, 2, 2, 2, 924, 925, 3, 2, 2, 2, 925, 926, 3, 2, 2, 2, 926, 928, 7, 130, 2, 2, 927, 929, 5, 92, 47, 2, 928, 927, 3, 2, 2, 2, 928, 929, 3, 2, 2, 2, 929, 935, 3, 2, 2, 2, 930, 931, 5, 114, 58, 2, 931, 932, 7, 128, 2, 2, 932, 933, 5, 116, 59, 2, 933, 935, 3, 2, 2, 2, 934, 922, 3, 2, 2, 2, 934, 930, 3, 2, 2, 2, 935, 936, 3, 2, 2, 2, 936, 937, 7, 88, 2, 2, 937, 938, 5, 96, 49, 2, 938, 940, 3, 2, 2, 2, 939, 906, 3, 2, 2, 2, 939, 912, 3, 2, 2, 2, 939, 920, 3, 2, 2, 2, 940, 111, 3, 2, 2, 2, 941, 944, 5, 100, 51, 2, 942, 944, 5, 130, 66, 2, 943, 941, 3, 2, 2, 2, 943, 942, 3, 2, 2, 2, 944, 113, 3, 2, 2, 2, 945, 947, 5, 202, 102, 2, 946, 945, 3, 2, 2, 2, 946, 947, 3, 2, 2, 2, 947, 948, 3, 2, 2, 2, 948, 949, 5, 140, 71, 2, 949, 950, 5, 224, 113, 2, 950, 115, 3, 2, 2, 2, 951, 954, 5, 92, 47, 2, 952, 954, 5, 274, 138, 2, 953, 951, 3, 2, 2, 2, 953, 952, 3, 2, 2, 2, 954, 117, 3, 2, 2, 2, 955, 965, 7, 17, 2, 2, 956, 965, 7, 27, 2, 2, 957, 960, 7, 61, 2, 2, 958, 961, 5, 92, 47, 2, 959, 961, 5, 274, 138, 2, 960, 958, 3, 2, 2, 2, 960, 959, 3, 2, 2, 2, 960, 961, 3, 2, 2, 2, 961, 965, 3, 2, 2, 2, 962, 963, 7, 44, 2, 2, 963, 965, 7, 134, 2, 2, 964, 955, 3, 2, 2, 2, 964, 956, 3, 2, 2, 2, 964, 957, 3, 2, 2, 2, 964, 962, 3, 2, 2, 2, 965, 966, 3, 2, 2, 2, 966, 967, 7, 130, 2, 2, 967, 119, 3, 2, 2, 2, 968, 969, 5, 126, 64, 2, 969, 121, 3, 2, 2, 2, 970, 972, 5, 124, 63, 2, 971, 970, 3, 2, 2, 2, 972, 973, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 973, 974, 3, 2, 2, 2, 974, 123, 3, 2, 2, 2, 975, 985, 5, 126, 64, 2, 976, 985, 5, 262, 132, 2, 977, 985, 5, 332, 167, 2, 978, 985, 5, 352, 177, 2, 979, 985, 5, 354, 178, 2, 980, 985, 5, 200, 101, 2, 981, 985, 5, 186, 94, 2, 982, 985, 5, 134, 68, 2, 983, 985, 5, 136, 69, 2, 984, 975, 3, 2, 2, 2, 984, 976, 3, 2, 2, 2, 984, 977, 3, 2, 2, 2, 984, 978, 3, 2, 2, 2, 984, 979, 3, 2, 2, 2, 984, 980, 3, 2, 2, 2, 984, 981, 3, 2, 2, 2, 984, 982, 3, 2, 2, 2, 984, 983, 3, 2, 2, 2, 985, 125, 3, 2, 2, 2, 986, 995, 5, 130, 66, 2, 987, 995, 5, 198, 100, 2, 988, 995, 5, 190, 96, 2, 989, 995, 5, 194, 98, 2, 990, 995, 5, 196, 99, 2, 991, 995, 5, 132, 67, 2, 992, 995, 5, 128, 65, 2, 993, 995, 5, 170, 86, 2, 994, 986, 3, 2, 2, 2, 994, 987, 3, 2, 2, 2, 994, 988, 3, 2, 2, 2, 994, 989, 3, 2, 2, 2, 994, 990, 3, 2, 2, 2, 994, 991, 3, 2, 2, 2, 994, 992, 3, 2, 2, 2, 994, 993, 3, 2, 2, 2, 995, 127, 3, 2, 2, 2, 996, 997, 7, 81, 2, 2, 997, 999, 7, 134, 2, 2, 998, 1000, 5, 202, 102, 2, 999, 998, 3, 2, 2, 2, 999, 1000, 3, 2, 2, 2, 1000, 1001, 3, 2, 2, 2, 1001, 1002, 7, 103, 2, 2, 1002, 1003, 5, 244, 123, 2, 1003, 1004, 7, 130, 2, 2, 1004, 129, 3, 2, 2, 2, 1005, 1007, 5, 140, 71, 2, 1006, 1005, 3, 2, 2, 2, 1006, 1007, 3, 2, 2, 2, 1007, 1009, 3, 2, 2, 2, 1008, 1010, 5, 220, 111, 2, 1009, 1008, 3, 2, 2, 2, 1009, 1010, 3, 2, 2, 2, 1010, 1011, 3, 2, 2, 2, 1011, 1020, 7, 130, 2, 2, 1012, 1014, 5, 202, 102, 2, 1013, 1015, 5, 140, 71, 2, 1014, 1013, 3, 2, 2, 2, 1014, 1015, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 1017, 5, 220, 111, 2, 1017, 1018, 7, 130, 2, 2, 1018, 1020, 3, 2, 2, 2, 1019, 1006, 3, 2, 2, 2, 1019, 1012, 3, 2, 2, 2, 1020, 131, 3, 2, 2, 2, 1021, 1022, 7, 66, 2, 2, 1022, 1023, 7, 87, 2, 2, 1023, 1024, 5, 94, 48, 2, 1024, 1025, 7, 124, 2, 2, 1025, 1026, 7, 6, 2, 2, 1026, 1027, 7, 88, 2, 2, 1027, 1028, 7, 130, 2, 2, 1028, 133, 3, 2, 2, 2, 1029, 1030, 7, 130, 2, 2, 1030, 135, 3, 2, 2, 2, 1031, 1032, 5, 202, 102, 2, 1032, 1033, 7, 130, 2, 2, 1033, 137, 3, 2, 2, 2, 1034, 1041, 5, 142, 72, 2, 1035, 1041, 5, 148, 75, 2, 1036, 1041, 5, 144, 73, 2, 1037, 1041, 7, 43, 2, 2, 1038, 1041, 7, 76, 2, 2, 1039, 1041, 7, 25, 2, 2, 1040, 1034, 3, 2, 2, 2, 1040, 1035, 3, 2, 2, 2, 1040, 1036, 3, 2, 2, 2, 1040, 1037, 3, 2, 2, 2, 1040, 1038, 3, 2, 2, 2, 1040, 1039, 3, 2, 2, 2, 1041, 139, 3, 2, 2, 2, 1042, 1044, 5, 138, 70, 2, 1043, 1042, 3, 2, 2, 2, 1044, 1045, 3, 2, 2, 2, 1045, 1043, 3, 2, 2, 2, 1045, 1046, 3, 2, 2, 2, 1046, 1048, 3, 2, 2, 2, 1047, 1049, 5, 202, 102, 2, 1048, 1047, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 141, 3, 2, 2, 2, 1050, 1051, 9, 13, 2, 2, 1051, 143, 3, 2, 2, 2, 1052, 1053, 9, 14, 2, 2, 1053, 145, 3, 2, 2, 2, 1054, 1055, 7, 134, 2, 2, 1055, 147, 3, 2, 2, 2, 1056, 1060, 5, 150, 76, 2, 1057, 1060, 5, 278, 140, 2, 1058, 1060, 5, 166, 84, 2, 1059, 1056, 3, 2, 2, 2, 1059, 1057, 3, 2, 2, 2, 1059, 1058, 3, 2, 2, 2, 1060, 149, 3, 2, 2, 2, 1061, 1066, 5, 156, 79, 2, 1062, 1066, 5, 162, 82, 2, 1063, 1066, 5, 350, 176, 2, 1064, 1066, 5, 238, 120, 2, 1065, 1061, 3, 2, 2, 2, 1065, 1062, 3, 2, 2, 2, 1065, 1063, 3, 2, 2, 2, 1065, 1064, 3, 2, 2, 2, 1066, 151, 3, 2, 2, 2, 1067, 1069, 5, 148, 75, 2, 1068, 1067, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070, 1068, 3, 2, 2, 2, 1070, 1071, 3, 2, 2, 2, 1071, 1073, 3, 2, 2, 2, 1072, 1074, 5, 202, 102, 2, 1073, 1072, 3, 2, 2, 2, 1073, 1074, 3, 2, 2, 2, 1074, 153, 3, 2, 2, 2, 1075, 1077, 5, 150, 76, 2, 1076, 1075, 3, 2, 2, 2, 1077, 1078, 3, 2, 2, 2, 1078, 1076, 3, 2, 2, 2, 1078, 1079, 3, 2, 2, 2, 1079, 1081, 3, 2, 2, 2, 1080, 1082, 5, 202, 102, 2, 1081, 1080, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 155, 3, 2, 2, 2, 1083, 1085, 5, 12, 7, 2, 1084, 1083, 3, 2, 2, 2, 1084, 1085, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086, 1107, 5, 158, 80, 2, 1087, 1088, 5, 12, 7, 2, 1088, 1089, 7, 70, 2, 2, 1089, 1090, 5, 340, 171, 2, 1090, 1107, 3, 2, 2, 2, 1091, 1107, 7, 20, 2, 2, 1092, 1107, 7, 21, 2, 2, 1093, 1107, 7, 22, 2, 2, 1094, 1107, 7, 85, 2, 2, 1095, 1107, 7, 16, 2, 2, 1096, 1107, 7, 62, 2, 2, 1097, 1107, 7, 47, 2, 2, 1098, 1107, 7, 48, 2, 2, 1099, 1107, 7, 63, 2, 2, 1100, 1107, 7, 80, 2, 2, 1101, 1107, 7, 41, 2, 2, 1102, 1107, 7, 32, 2, 2, 1103, 1107, 7, 83, 2, 2, 1104, 1107, 7, 15, 2, 2, 1105, 1107, 5, 160, 81, 2, 1106, 1084, 3, 2, 2, 2, 1106, 1087, 3, 2, 2, 2, 1106, 1091, 3, 2, 2, 2, 1106, 1092, 3, 2, 2, 2, 1106, 1093, 3, 2, 2, 2, 1106, 1094, 3, 2, 2, 2, 1106, 1095, 3, 2, 2, 2, 1106, 1096, 3, 2, 2, 2, 1106, 1097, 3, 2, 2, 2, 1106, 1098, 3, 2, 2, 2, 1106, 1099, 3, 2, 2, 2, 1106, 1100, 3, 2, 2, 2, 1106, 1101, 3, 2, 2, 2, 1106, 1102, 3, 2, 2, 2, 1106, 1103, 3, 2, 2, 2, 1106, 1104, 3, 2, 2, 2, 1106, 1105, 3, 2, 2, 2, 1107, 157, 3, 2, 2, 2, 1108, 1113, 5, 276, 139, 2, 1109, 1113, 5, 164, 83, 2, 1110, 1113, 5, 146, 74, 2, 1111, 1113, 5, 340, 171, 2, 1112, 1108, 3, 2, 2, 2, 1112, 1109, 3, 2, 2, 2, 1112, 1110, 3, 2, 2, 2, 1112, 1111, 3, 2, 2, 2, 1113, 159, 3, 2, 2, 2, 1114, 1115, 7, 28, 2, 2, 1115, 1118, 7, 87, 2, 2, 1116, 1119, 5, 92, 47, 2, 1117, 1119, 7, 15, 2, 2, 1118, 1116, 3, 2, 2, 2, 1118, 1117, 3, 2, 2, 2, 1119, 1120, 3, 2, 2, 2, 1120, 1121, 7, 88, 2, 2, 1121, 161, 3, 2, 2, 2, 1122, 1137, 5, 286, 144, 2, 1123, 1125, 5, 202, 102, 2, 1124, 1123, 3, 2, 2, 2, 1124, 1125, 3, 2, 2, 2, 1125, 1127, 3, 2, 2, 2, 1126, 1128, 5, 12, 7, 2, 1127, 1126, 3, 2, 2, 2, 1127, 1128, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1138, 7, 134, 2, 2, 1130, 1138, 5, 340, 171, 2, 1131, 1133, 5, 12, 7, 2, 1132, 1134, 7, 70, 2, 2, 1133, 1132, 3, 2, 2, 2, 1133, 1134, 3, 2, 2, 2, 1134, 1135, 3, 2, 2, 2, 1135, 1136, 5, 340, 171, 2, 1136, 1138, 3, 2, 2, 2, 1137, 1124, 3, 2, 2, 2, 1137, 1130, 3, 2, 2, 2, 1137, 1131, 3, 2, 2, 2, 1138, 1145, 3, 2, 2, 2, 1139, 1141, 7, 35, 2, 2, 1140, 1142, 5, 12, 7, 2, 1141, 1140, 3, 2, 2, 2, 1141, 1142, 3, 2, 2, 2, 1142, 1143, 3, 2, 2, 2, 1143, 1145, 7, 134, 2, 2, 1144, 1122, 3, 2, 2, 2, 1144, 1139, 3, 2, 2, 2, 1145, 163, 3, 2, 2, 2, 1146, 1147, 7, 134, 2, 2, 1147, 165, 3, 2, 2, 2, 1148, 1149, 5, 168, 85, 2, 1149, 1154, 7, 91, 2, 2, 1150, 1152, 5, 176, 89, 2, 1151, 1153, 7, 124, 2, 2, 1152, 1151, 3, 2, 2, 2, 1152, 1153, 3, 2, 2, 2, 1153, 1155, 3, 2, 2, 2, 1154, 1150, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 1156, 3, 2, 2, 2, 1156, 1157, 7, 92, 2, 2, 1157, 167, 3, 2, 2, 2, 1158, 1160, 5, 172, 87, 2, 1159, 1161, 5, 202, 102, 2, 1160, 1159, 3, 2, 2, 2, 1160, 1161, 3, 2, 2, 2, 1161, 1166, 3, 2, 2, 2, 1162, 1164, 5, 12, 7, 2, 1163, 1162, 3, 2, 2, 2, 1163, 1164, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1167, 7, 134, 2, 2, 1166, 1163, 3, 2, 2, 2, 1166, 1167, 3, 2, 2, 2, 1167, 1169, 3, 2, 2, 2, 1168, 1170, 5, 174, 88, 2, 1169, 1168, 3, 2, 2, 2, 1169, 1170, 3, 2, 2, 2, 1170, 169, 3, 2, 2, 2, 1171, 1173, 5, 172, 87, 2, 1172, 1174, 5, 202, 102, 2, 1173, 1172, 3, 2, 2, 2, 1173, 1174, 3, 2, 2, 2, 1174, 1175, 3, 2, 2, 2, 1175, 1177, 7, 134, 2, 2, 1176, 1178, 5, 174, 88, 2, 1177, 1176, 3, 2, 2, 2, 1177, 1178, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1180, 7, 130, 2, 2, 1180, 171, 3, 2, 2, 2, 1181, 1183, 7, 35, 2, 2, 1182, 1184, 9, 15, 2, 2, 1183, 1182, 3, 2, 2, 2, 1183, 1184, 3, 2, 2, 2, 1184, 173, 3, 2, 2, 2, 1185, 1186, 7, 128, 2, 2, 1186, 1187, 5, 152, 77, 2, 1187, 175, 3, 2, 2, 2, 1188, 1193, 5, 178, 90, 2, 1189, 1190, 7, 124, 2, 2, 1190, 1192, 5, 178, 90, 2, 1191, 1189, 3, 2, 2, 2, 1192, 1195, 3, 2, 2, 2, 1193, 1191, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 177, 3, 2, 2, 2, 1195, 1193, 3, 2, 2, 2, 1196, 1199, 5, 180, 91, 2, 1197, 1198, 7, 103, 2, 2, 1198, 1200, 5, 94, 48, 2, 1199, 1197, 3, 2, 2, 2, 1199, 1200, 3, 2, 2, 2, 1200, 179, 3, 2, 2, 2, 1201, 1202, 7, 134, 2, 2, 1202, 181, 3, 2, 2, 2, 1203, 1206, 5, 184, 93, 2, 1204, 1206, 5, 188, 95, 2, 1205, 1203, 3, 2, 2, 2, 1205, 1204, 3, 2, 2, 2, 1206, 183, 3, 2, 2, 2, 1207, 1208, 7, 134, 2, 2, 1208, 185, 3, 2, 2, 2, 1209, 1211, 7, 46, 2, 2, 1210, 1209, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1212, 3, 2, 2, 2, 1212, 1215, 7, 50, 2, 2, 1213, 1216, 7, 134, 2, 2, 1214, 1216, 5, 184, 93, 2, 1215, 1213, 3, 2, 2, 2, 1215, 1214, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216, 1217, 3, 2, 2, 2, 1217, 1219, 7, 91, 2, 2, 1218, 1220, 5, 122, 62, 2, 1219, 1218, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 1222, 7, 92, 2, 2, 1222, 187, 3, 2, 2, 2, 1223, 1224, 7, 134, 2, 2, 1224, 189, 3, 2, 2, 2, 1225, 1226, 7, 50, 2, 2, 1226, 1227, 7, 134, 2, 2, 1227, 1228, 7, 103, 2, 2, 1228, 1229, 5, 192, 97, 2, 1229, 1230, 7, 130, 2, 2, 1230, 191, 3, 2, 2, 2, 1231, 1233, 5, 12, 7, 2, 1232, 1231, 3, 2, 2, 2, 1232, 1233, 3, 2, 2, 2, 1233, 1234, 3, 2, 2, 2, 1234, 1235, 5, 182, 92, 2, 1235, 193, 3, 2, 2, 2, 1236, 1242, 7, 81, 2, 2, 1237, 1239, 7, 78, 2, 2, 1238, 1237, 3, 2, 2, 2, 1238, 1239, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1243, 5, 12, 7, 2, 1241, 1243, 7, 129, 2, 2, 1242, 1238, 3, 2, 2, 2, 1242, 1241, 3, 2, 2, 2, 1243, 1244, 3, 2, 2, 2, 1244, 1245, 5, 8, 5, 2, 1245, 1246, 7, 130, 2, 2, 1246, 195, 3, 2, 2, 2, 1247, 1249, 5, 202, 102, 2, 1248, 1247, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1251, 7, 81, 2, 2, 1251, 1253, 7, 50, 2, 2, 1252, 1254, 5, 12, 7, 2, 1253, 1252, 3, 2, 2, 2, 1253, 1254, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1256, 5, 182, 92, 2, 1256, 1257, 7, 130, 2, 2, 1257, 197, 3, 2, 2, 2, 1258, 1259, 7, 14, 2, 2, 1259, 1260, 7, 87, 2, 2, 1260, 1261, 7, 6, 2, 2, 1261, 1262, 7, 88, 2, 2, 1262, 1263, 7, 130, 2, 2, 1263, 199, 3, 2, 2, 2, 1264, 1265, 7, 38, 2, 2, 1265, 1272, 7, 6, 2, 2, 1266, 1268, 7, 91, 2, 2, 1267, 1269, 5, 122, 62, 2, 1268, 1267, 3, 2, 2, 2, 1268, 1269, 3, 2, 2, 2, 1269, 1270, 3, 2, 2, 2, 1270, 1273, 7, 92, 2, 2, 1271, 1273, 5, 124, 63, 2, 1272, 1266, 3, 2, 2, 2, 1272, 1271, 3, 2, 2, 2, 1273, 201, 3, 2, 2, 2, 1274, 1276, 5, 204, 103, 2, 1275, 1274, 3, 2, 2, 2, 1276, 1277, 3, 2, 2, 2, 1277, 1275, 3, 2, 2, 2, 1277, 1278, 3, 2, 2, 2, 1278, 203, 3, 2, 2, 2, 1279, 1280, 7, 89, 2, 2, 1280, 1282, 7, 89, 2, 2, 1281, 1283, 5, 208, 105, 2, 1282, 1281, 3, 2, 2, 2, 1282, 1283, 3, 2, 2, 2, 1283, 1284, 3, 2, 2, 2, 1284, 1285, 7, 90, 2, 2, 1285, 1288, 7, 90, 2, 2, 1286, 1288, 5, 206, 104, 2, 1287, 1279, 3, 2, 2, 2, 1287, 1286, 3, 2, 2, 2, 1288, 205, 3, 2, 2, 2, 1289, 1290, 7, 12, 2, 2, 1290, 1293, 7, 87, 2, 2, 1291, 1294, 5, 244, 123, 2, 1292, 1294, 5, 94, 48, 2, 1293, 1291, 3, 2, 2, 2, 1293, 1292, 3, 2, 2, 2, 1294, 1296, 3, 2, 2, 2, 1295, 1297, 7, 133, 2, 2, 1296, 1295, 3, 2, 2, 2, 1296, 1297, 3, 2, 2, 2, 1297, 1298, 3, 2, 2, 2, 1298, 1299, 7, 88, 2, 2, 1299, 207, 3, 2, 2, 2, 1300, 1305, 5, 210, 106, 2, 1301, 1302, 7, 124, 2, 2, 1302, 1304, 5, 210, 106, 2, 1303, 1301, 3, 2, 2, 2, 1304, 1307, 3, 2, 2, 2, 1305, 1303, 3, 2, 2, 2, 1305, 1306, 3, 2, 2, 2, 1306, 1309, 3, 2, 2, 2, 1307, 1305, 3, 2, 2, 2, 1308, 1310, 7, 133, 2, 2, 1309, 1308, 3, 2, 2, 2, 1309, 1310, 3, 2, 2, 2, 1310, 209, 3, 2, 2, 2, 1311, 1312, 5, 212, 107, 2, 1312, 1313, 7, 129, 2, 2, 1313, 1315, 3, 2, 2, 2, 1314, 1311, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 1316, 3, 2, 2, 2, 1316, 1318, 7, 134, 2, 2, 1317, 1319, 5, 214, 108, 2, 1318, 1317, 3, 2, 2, 2, 1318, 1319, 3, 2, 2, 2, 1319, 211, 3, 2, 2, 2, 1320, 1321, 7, 134, 2, 2, 1321, 213, 3, 2, 2, 2, 1322, 1324, 7, 87, 2, 2, 1323, 1325, 5, 216, 109, 2, 1324, 1323, 3, 2, 2, 2, 1324, 1325, 3, 2, 2, 2, 1325, 1326, 3, 2, 2, 2, 1326, 1327, 7, 88, 2, 2, 1327, 215, 3, 2, 2, 2, 1328, 1330, 5, 218, 110, 2, 1329, 1328, 3, 2, 2, 2, 1330, 1331, 3, 2, 2, 2, 1331, 1329, 3, 2, 2, 2, 1331, 1332, 3, 2, 2, 2, 1332, 217, 3, 2, 2, 2, 1333, 1334, 7, 87, 2, 2, 1334, 1335, 5, 216, 109, 2, 1335, 1336, 7, 88, 2, 2, 1336, 1351, 3, 2, 2, 2, 1337, 1338, 7, 89, 2, 2, 1338, 1339, 5, 216, 109, 2, 1339, 1340, 7, 90, 2, 2, 1340, 1351, 3, 2, 2, 2, 1341, 1342, 7, 91, 2, 2, 1342, 1343, 5, 216, 109, 2, 1343, 1344, 7, 92, 2, 2, 1344, 1351, 3, 2, 2, 2, 1345, 1347, 10, 16, 2, 2, 1346, 1345, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 1346, 3, 2, 2, 2, 1348, 1349, 3, 2, 2, 2, 1349, 1351, 3, 2, 2, 2, 1350, 1333, 3, 2, 2, 2, 1350, 1337, 3, 2, 2, 2, 1350, 1341, 3, 2, 2, 2, 1350, 1346, 3, 2, 2, 2, 1351, 219, 3, 2, 2, 2, 1352, 1357, 5, 222, 112, 2, 1353, 1354, 7, 124, 2, 2, 1354, 1356, 5, 222, 112, 2, 1355, 1353, 3, 2, 2, 2, 1356, 1359, 3, 2, 2, 2, 1357, 1355, 3, 2, 2, 2, 1357, 1358, 3, 2, 2, 2, 1358, 221, 3, 2, 2, 2, 1359, 1357, 3, 2, 2, 2, 1360, 1362, 5, 224, 113, 2, 1361, 1363, 5, 266, 134, 2, 1362, 1361, 3, 2, 2, 2, 1362, 1363, 3, 2, 2, 2, 1363, 223, 3, 2, 2, 2, 1364, 1370, 5, 226, 114, 2, 1365, 1366, 5, 228, 115, 2, 1366, 1367, 5, 230, 116, 2, 1367, 1368, 5, 232, 117, 2, 1368, 1370, 3, 2, 2, 2, 1369, 1364, 3, 2, 2, 2, 1369, 1365, 3, 2, 2, 2, 1370, 225, 3, 2, 2, 2, 1371, 1373, 5, 234, 118, 2, 1372, 1374, 7, 24, 2, 2, 1373, 1372, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1371, 3, 2, 2, 2, 1376, 1379, 3, 2, 2, 2, 1377, 1375, 3, 2, 2, 2, 1377, 1378, 3, 2, 2, 2, 1378, 1380, 3, 2, 2, 2, 1379, 1377, 3, 2, 2, 2, 1380, 1381, 5, 228, 115, 2, 1381, 227, 3, 2, 2, 2, 1382, 1383, 8, 115, 1, 2, 1383, 1385, 5, 242, 122, 2, 1384, 1386, 5, 202, 102, 2, 1385, 1384, 3, 2, 2, 2, 1385, 1386, 3, 2, 2, 2, 1386, 1392, 3, 2, 2, 2, 1387, 1388, 7, 87, 2, 2, 1388, 1389, 5, 226, 114, 2, 1389, 1390, 7, 88, 2, 2, 1390, 1392, 3, 2, 2, 2, 1391, 1382, 3, 2, 2, 2, 1391, 1387, 3, 2, 2, 2, 1392, 1407, 3, 2, 2, 2, 1393, 1403, 12, 4, 2, 2, 1394, 1404, 5, 230, 116, 2, 1395, 1397, 7, 89, 2, 2, 1396, 1398, 5, 94, 48, 2, 1397, 1396, 3, 2, 2, 2, 1397, 1398, 3, 2, 2, 2, 1398, 1399, 3, 2, 2, 2, 1399, 1401, 7, 90, 2, 2, 1400, 1402, 5, 202, 102, 2, 1401, 1400, 3, 2, 2, 2, 1401, 1402, 3, 2, 2, 2, 1402, 1404, 3, 2, 2, 2, 1403, 1394, 3, 2, 2, 2, 1403, 1395, 3, 2, 2, 2, 1404, 1406, 3, 2, 2, 2, 1405, 1393, 3, 2, 2, 2, 1406, 1409, 3, 2, 2, 2, 1407, 1405, 3, 2, 2, 2, 1407, 1408, 3, 2, 2, 2, 1408, 229, 3, 2, 2, 2, 1409, 1407, 3, 2, 2, 2, 1410, 1412, 7, 87, 2, 2, 1411, 1413, 5, 256, 129, 2, 1412, 1411, 3, 2, 2, 2, 1412, 1413, 3, 2, 2, 2, 1413, 1414, 3, 2, 2, 2, 1414, 1416, 7, 88, 2, 2, 1415, 1417, 5, 236, 119, 2, 1416, 1415, 3, 2, 2, 2, 1416, 1417, 3, 2, 2, 2, 1417, 1419, 3, 2, 2, 2, 1418, 1420, 5, 240, 121, 2, 1419, 1418, 3, 2, 2, 2, 1419, 1420, 3, 2, 2, 2, 1420, 1422, 3, 2, 2, 2, 1421, 1423, 5, 368, 185, 2, 1422, 1421, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1425, 3, 2, 2, 2, 1424, 1426, 5, 202, 102, 2, 1425, 1424, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 231, 3, 2, 2, 2, 1427, 1428, 7, 126, 2, 2, 1428, 1430, 5, 154, 78, 2, 1429, 1431, 5, 246, 124, 2, 1430, 1429, 3, 2, 2, 2, 1430, 1431, 3, 2, 2, 2, 1431, 233, 3, 2, 2, 2, 1432, 1434, 9, 17, 2, 2, 1433, 1435, 5, 202, 102, 2, 1434, 1433, 3, 2, 2, 2, 1434, 1435, 3, 2, 2, 2, 1435, 1447, 3, 2, 2, 2, 1436, 1438, 5, 12, 7, 2, 1437, 1436, 3, 2, 2, 2, 1437, 1438, 3, 2, 2, 2, 1438, 1439, 3, 2, 2, 2, 1439, 1441, 7, 95, 2, 2, 1440, 1442, 5, 202, 102, 2, 1441, 1440, 3, 2, 2, 2, 1441, 1442, 3, 2, 2, 2, 1442, 1444, 3, 2, 2, 2, 1443, 1445, 5, 236, 119, 2, 1444, 1443, 3, 2, 2, 2, 1444, 1445, 3, 2, 2, 2, 1445, 1447, 3, 2, 2, 2, 1446, 1432, 3, 2, 2, 2, 1446, 1437, 3, 2, 2, 2, 1447, 235, 3, 2, 2, 2, 1448, 1450, 5, 238, 120, 2, 1449, 1448, 3, 2, 2, 2, 1450, 1451, 3, 2, 2, 2, 1451, 1449, 3, 2, 2, 2, 1451, 1452, 3, 2, 2, 2, 1452, 237, 3, 2, 2, 2, 1453, 1454, 9, 18, 2, 2, 1454, 239, 3, 2, 2, 2, 1455, 1456, 9, 17, 2, 2, 1456, 241, 3, 2, 2, 2, 1457, 1459, 7, 133, 2, 2, 1458, 1457, 3, 2, 2, 2, 1458, 1459, 3, 2, 2, 2, 1459, 1460, 3, 2, 2, 2, 1460, 1461, 5, 6, 4, 2, 1461, 243, 3, 2, 2, 2, 1462, 1464, 5, 152, 77, 2, 1463, 1465, 5, 246, 124, 2, 1464, 1463, 3, 2, 2, 2, 1464, 1465, 3, 2, 2, 2, 1465, 245, 3, 2, 2, 2, 1466, 1475, 5, 248, 125, 2, 1467, 1469, 5, 250, 126, 2, 1468, 1467, 3, 2, 2, 2, 1468, 1469, 3, 2, 2, 2, 1469, 1470, 3, 2, 2, 2, 1470, 1471, 5, 230, 116, 2, 1471, 1472, 5, 232, 117, 2, 1472, 1475, 3, 2, 2, 2, 1473, 1475, 5, 252, 127, 2, 1474, 1466, 3, 2, 2, 2, 1474, 1468, 3, 2, 2, 2, 1474, 1473, 3, 2, 2, 2, 1475, 247, 3, 2, 2, 2, 1476, 1486, 5, 250, 126, 2, 1477, 1479, 5, 234, 118, 2, 1478, 1477, 3, 2, 2, 2, 1479, 1480, 3, 2, 2, 2, 1480, 1478, 3, 2, 2, 2, 1480, 1481, 3, 2, 2, 2, 1481, 1483, 3, 2, 2, 2, 1482, 1484, 5, 250, 126, 2, 1483, 1482, 3, 2, 2, 2, 1483, 1484, 3, 2, 2, 2, 1484, 1486, 3, 2, 2, 2, 1485, 1476, 3, 2, 2, 2, 1485, 1478, 3, 2, 2, 2, 1486, 249, 3, 2, 2, 2, 1487, 1488, 8, 126, 1, 2, 1488, 1502, 5, 230, 116, 2, 1489, 1491, 7, 89, 2, 2, 1490, 1492, 5, 94, 48, 2, 1491, 1490, 3, 2, 2, 2, 1491, 1492, 3, 2, 2, 2, 1492, 1493, 3, 2, 2, 2, 1493, 1495, 7, 90, 2, 2, 1494, 1496, 5, 202, 102, 2, 1495, 1494, 3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 1502, 3, 2, 2, 2, 1497, 1498, 7, 87, 2, 2, 1498, 1499, 5, 248, 125, 2, 1499, 1500, 7, 88, 2, 2, 1500, 1502, 3, 2, 2, 2, 1501, 1487, 3, 2, 2, 2, 1501, 1489, 3, 2, 2, 2, 1501, 1497, 3, 2, 2, 2, 1502, 1518, 3, 2, 2, 2, 1503, 1514, 12, 6, 2, 2, 1504, 1515, 5, 230, 116, 2, 1505, 1506, 5, 250, 126, 2, 1506, 1508, 7, 89, 2, 2, 1507, 1509, 5, 94, 48, 2, 1508, 1507, 3, 2, 2, 2, 1508, 1509, 3, 2, 2, 2, 1509, 1510, 3, 2, 2, 2, 1510, 1512, 7, 90, 2, 2, 1511, 1513, 5, 202, 102, 2, 1512, 1511, 3, 2, 2, 2, 1512, 1513, 3, 2, 2, 2, 1513, 1515, 3, 2, 2, 2, 1514, 1504, 3, 2, 2, 2, 1514, 1505, 3, 2, 2, 2, 1515, 1517, 3, 2, 2, 2, 1516, 1503, 3, 2, 2, 2, 1517, 1520, 3, 2, 2, 2, 1518, 1516, 3, 2, 2, 2, 1518, 1519, 3, 2, 2, 2, 1519, 251, 3, 2, 2, 2, 1520, 1518, 3, 2, 2, 2, 1521, 1523, 5, 234, 118, 2, 1522, 1521, 3, 2, 2, 2, 1523, 1526, 3, 2, 2, 2, 1524, 1522, 3, 2, 2, 2, 1524, 1525, 3, 2, 2, 2, 1525, 1527, 3, 2, 2, 2, 1526, 1524, 3, 2, 2, 2, 1527, 1528, 5, 254, 128, 2, 1528, 253, 3, 2, 2, 2, 1529, 1530, 8, 128, 1, 2, 1530, 1531, 7, 133, 2, 2, 1531, 1546, 3, 2, 2, 2, 1532, 1542, 12, 4, 2, 2, 1533, 1543, 5, 230, 116, 2, 1534, 1536, 7, 89, 2, 2, 1535, 1537, 5, 94, 48, 2, 1536, 1535, 3, 2, 2, 2, 1536, 1537, 3, 2, 2, 2, 1537, 1538, 3, 2, 2, 2, 1538, 1540, 7, 90, 2, 2, 1539, 1541, 5, 202, 102, 2, 1540, 1539, 3, 2, 2, 2, 1540, 1541, 3, 2, 2, 2, 1541, 1543, 3, 2, 2, 2, 1542, 1533, 3, 2, 2, 2, 1542, 1534, 3, 2, 2, 2, 1543, 1545, 3, 2, 2, 2, 1544, 1532, 3, 2, 2, 2, 1545, 1548, 3, 2, 2, 2, 1546, 1544, 3, 2, 2, 2, 1546, 1547, 3, 2, 2, 2, 1547, 255, 3, 2, 2, 2, 1548, 1546, 3, 2, 2, 2, 1549, 1554, 5, 258, 130, 2, 1550, 1552, 7, 124, 2, 2, 1551, 1550, 3, 2, 2, 2, 1551, 1552, 3, 2, 2, 2, 1552, 1553, 3, 2, 2, 2, 1553, 1555, 7, 133, 2, 2, 1554, 1551, 3, 2, 2, 2, 1554, 1555, 3, 2, 2, 2, 1555, 257, 3, 2, 2, 2, 1556, 1561, 5, 260, 131, 2, 1557, 1558, 7, 124, 2, 2, 1558, 1560, 5, 260, 131, 2, 1559, 1557, 3, 2, 2, 2, 1560, 1563, 3, 2, 2, 2, 1561, 1559, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562, 259, 3, 2, 2, 2, 1563, 1561, 3, 2, 2, 2, 1564, 1566, 5, 202, 102, 2, 1565, 1564, 3, 2, 2, 2, 1565, 1566, 3, 2, 2, 2, 1566, 1567, 3, 2, 2, 2, 1567, 1572, 5, 140, 71, 2, 1568, 1573, 5, 224, 113, 2, 1569, 1571, 5, 246, 124, 2, 1570, 1569, 3, 2, 2, 2, 1570, 1571, 3, 2, 2, 2, 1571, 1573, 3, 2, 2, 2, 1572, 1568, 3, 2, 2, 2, 1572, 1570, 3, 2, 2, 2, 1573, 1576, 3, 2, 2, 2, 1574, 1575, 7, 103, 2, 2, 1575, 1577, 5, 270, 136, 2, 1576, 1574, 3, 2, 2, 2, 1576, 1577, 3, 2, 2, 2, 1577, 261, 3, 2, 2, 2, 1578, 1580, 5, 202, 102, 2, 1579, 1578, 3, 2, 2, 2, 1579, 1580, 3, 2, 2, 2, 1580, 1582, 3, 2, 2, 2, 1581, 1583, 5, 140, 71, 2, 1582, 1581, 3, 2, 2, 2, 1582, 1583, 3, 2, 2, 2, 1583, 1584, 3, 2, 2, 2, 1584, 1586, 5, 224, 113, 2, 1585, 1587, 5, 296, 149, 2, 1586, 1585, 3, 2, 2, 2, 1586, 1587, 3, 2, 2, 2, 1587, 1588, 3, 2, 2, 2, 1588, 1589, 5, 264, 133, 2, 1589, 263, 3, 2, 2, 2, 1590, 1592, 5, 320, 161, 2, 1591, 1590, 3, 2, 2, 2, 1591, 1592, 3, 2, 2, 2, 1592, 1593, 3, 2, 2, 2, 1593, 1599, 5, 102, 52, 2, 1594, 1599, 5, 358, 180, 2, 1595, 1596, 7, 103, 2, 2, 1596, 1597, 9, 19, 2, 2, 1597, 1599, 7, 130, 2, 2, 1598, 1591, 3, 2, 2, 2, 1598, 1594, 3, 2, 2, 2, 1598, 1595, 3, 2, 2, 2, 1599, 265, 3, 2, 2, 2, 1600, 1606, 5, 268, 135, 2, 1601, 1602, 7, 87, 2, 2, 1602, 1603, 5, 36, 19, 2, 1603, 1604, 7, 88, 2, 2, 1604, 1606, 3, 2, 2, 2, 1605, 1600, 3, 2, 2, 2, 1605, 1601, 3, 2, 2, 2, 1606, 267, 3, 2, 2, 2, 1607, 1608, 7, 103, 2, 2, 1608, 1611, 5, 270, 136, 2, 1609, 1611, 5, 274, 138, 2, 1610, 1607, 3, 2, 2, 2, 1610, 1609, 3, 2, 2, 2, 1611, 269, 3, 2, 2, 2, 1612, 1615, 5, 88, 45, 2, 1613, 1615, 5, 274, 138, 2, 1614, 1612, 3, 2, 2, 2, 1614, 1613, 3, 2, 2, 2, 1615, 271, 3, 2, 2, 2, 1616, 1618, 5, 270, 136, 2, 1617, 1619, 7, 133, 2, 2, 1618, 1617, 3, 2, 2, 2, 1618, 1619, 3, 2, 2, 2, 1619, 1627, 3, 2, 2, 2, 1620, 1621, 7, 124, 2, 2, 1621, 1623, 5, 270, 136, 2, 1622, 1624, 7, 133, 2, 2, 1623, 1622, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 1626, 3, 2, 2, 2, 1625, 1620, 3, 2, 2, 2, 1626, 1629, 3, 2, 2, 2, 1627, 1625, 3, 2, 2, 2, 1627, 1628, 3, 2, 2, 2, 1628, 273, 3, 2, 2, 2, 1629, 1627, 3, 2, 2, 2, 1630, 1635, 7, 91, 2, 2, 1631, 1633, 5, 272, 137, 2, 1632, 1634, 7, 124, 2, 2, 1633, 1632, 3, 2, 2, 2, 1633, 1634, 3, 2, 2, 2, 1634, 1636, 3, 2, 2, 2, 1635, 1631, 3, 2, 2, 2, 1635, 1636, 3, 2, 2, 2, 1636, 1637, 3, 2, 2, 2, 1637, 1638, 7, 92, 2, 2, 1638, 275, 3, 2, 2, 2, 1639, 1642, 7, 134, 2, 2, 1640, 1642, 5, 340, 171, 2, 1641, 1639, 3, 2, 2, 2, 1641, 1640, 3, 2, 2, 2, 1642, 277, 3, 2, 2, 2, 1643, 1644, 5, 280, 141, 2, 1644, 1646, 7, 91, 2, 2, 1645, 1647, 5, 288, 145, 2, 1646, 1645, 3, 2, 2, 2, 1646, 1647, 3, 2, 2, 2, 1647, 1648, 3, 2, 2, 2, 1648, 1649, 7, 92, 2, 2, 1649, 279, 3, 2, 2, 2, 1650, 1652, 5, 286, 144, 2, 1651, 1653, 5, 202, 102, 2, 1652, 1651, 3, 2, 2, 2, 1652, 1653, 3, 2, 2, 2, 1653, 1658, 3, 2, 2, 2, 1654, 1656, 5, 282, 142, 2, 1655, 1657, 5, 284, 143, 2, 1656, 1655, 3, 2, 2, 2, 1656, 1657, 3, 2, 2, 2, 1657, 1659, 3, 2, 2, 2, 1658, 1654, 3, 2, 2, 2, 1658, 1659, 3, 2, 2, 2, 1659, 1661, 3, 2, 2, 2, 1660, 1662, 5, 302, 152, 2, 1661, 1660, 3, 2, 2, 2, 1661, 1662, 3, 2, 2, 2, 1662, 1674, 3, 2, 2, 2, 1663, 1665, 7, 79, 2, 2, 1664, 1666, 5, 202, 102, 2, 1665, 1664, 3, 2, 2, 2, 1665, 1666, 3, 2, 2, 2, 1666, 1671, 3, 2, 2, 2, 1667, 1669, 5, 282, 142, 2, 1668, 1670, 5, 284, 143, 2, 1669, 1668, 3, 2, 2, 2, 1669, 1670, 3, 2, 2, 2, 1670, 1672, 3, 2, 2, 2, 1671, 1667, 3, 2, 2, 2, 1671, 1672, 3, 2, 2, 2, 1672, 1674, 3, 2, 2, 2, 1673, 1650, 3, 2, 2, 2, 1673, 1663, 3, 2, 2, 2, 1674, 281, 3, 2, 2, 2, 1675, 1677, 5, 12, 7, 2, 1676, 1675, 3, 2, 2, 2, 1676, 1677, 3, 2, 2, 2, 1677, 1678, 3, 2, 2, 2, 1678, 1679, 5, 276, 139, 2, 1679, 283, 3, 2, 2, 2, 1680, 1681, 7, 40, 2, 2, 1681, 285, 3, 2, 2, 2, 1682, 1683, 9, 15, 2, 2, 1683, 287, 3, 2, 2, 2, 1684, 1689, 5, 290, 146, 2, 1685, 1686, 5, 312, 157, 2, 1686, 1687, 7, 128, 2, 2, 1687, 1689, 3, 2, 2, 2, 1688, 1684, 3, 2, 2, 2, 1688, 1685, 3, 2, 2, 2, 1689, 1690, 3, 2, 2, 2, 1690, 1688, 3, 2, 2, 2, 1690, 1691, 3, 2, 2, 2, 1691, 289, 3, 2, 2, 2, 1692, 1694, 5, 202, 102, 2, 1693, 1692, 3, 2, 2, 2, 1693, 1694, 3, 2, 2, 2, 1694, 1696, 3, 2, 2, 2, 1695, 1697, 5, 140, 71, 2, 1696, 1695, 3, 2, 2, 2, 1696, 1697, 3, 2, 2, 2, 1697, 1699, 3, 2, 2, 2, 1698, 1700, 5, 292, 147, 2, 1699, 1698, 3, 2, 2, 2, 1699, 1700, 3, 2, 2, 2, 1700, 1701, 3, 2, 2, 2, 1701, 1709, 7, 130, 2, 2, 1702, 1709, 5, 262, 132, 2, 1703, 1709, 5, 194, 98, 2, 1704, 1709, 5, 132, 67, 2, 1705, 1709, 5, 332, 167, 2, 1706, 1709, 5, 128, 65, 2, 1707, 1709, 5, 134, 68, 2, 1708, 1693, 3, 2, 2, 2, 1708, 1702, 3, 2, 2, 2, 1708, 1703, 3, 2, 2, 2, 1708, 1704, 3, 2, 2, 2, 1708, 1705, 3, 2, 2, 2, 1708, 1706, 3, 2, 2, 2, 1708, 1707, 3, 2, 2, 2, 1709, 291, 3, 2, 2, 2, 1710, 1715, 5, 294, 148, 2, 1711, 1712, 7, 124, 2, 2, 1712, 1714, 5, 294, 148, 2, 1713, 1711, 3, 2, 2, 2, 1714, 1717, 3, 2, 2, 2, 1715, 1713, 3, 2, 2, 2, 1715, 1716, 3, 2, 2, 2, 1716, 293, 3, 2, 2, 2, 1717, 1715, 3, 2, 2, 2, 1718, 1728, 5, 224, 113, 2, 1719, 1721, 5, 296, 149, 2, 1720, 1719, 3, 2, 2, 2, 1720, 1721, 3, 2, 2, 2, 1721, 1723, 3, 2, 2, 2, 1722, 1724, 5, 300, 151, 2, 1723, 1722, 3, 2, 2, 2, 1723, 1724, 3, 2, 2, 2, 1724, 1729, 3, 2, 2, 2, 1725, 1727, 5, 268, 135, 2, 1726, 1725, 3, 2, 2, 2, 1726, 1727, 3, 2, 2, 2, 1727, 1729, 3, 2, 2, 2, 1728, 1720, 3, 2, 2, 2, 1728, 1726, 3, 2, 2, 2, 1729, 1739, 3, 2, 2, 2, 1730, 1732, 7, 134, 2, 2, 1731, 1730, 3, 2, 2, 2, 1731, 1732, 3, 2, 2, 2, 1732, 1734, 3, 2, 2, 2, 1733, 1735, 5, 202, 102, 2, 1734, 1733, 3, 2, 2, 2, 1734, 1735, 3, 2, 2, 2, 1735, 1736, 3, 2, 2, 2, 1736, 1737, 7, 128, 2, 2, 1737, 1739, 5, 94, 48, 2, 1738, 1718, 3, 2, 2, 2, 1738, 1731, 3, 2, 2, 2, 1739, 295, 3, 2, 2, 2, 1740, 1742, 5, 298, 150, 2, 1741, 1740, 3, 2, 2, 2, 1742, 1743, 3, 2, 2, 2, 1743, 1741, 3, 2, 2, 2, 1743, 1744, 3, 2, 2, 2, 1744, 297, 3, 2, 2, 2, 1745, 1746, 9, 20, 2, 2, 1746, 299, 3, 2, 2, 2, 1747, 1748, 7, 103, 2, 2, 1748, 1749, 7, 136, 2, 2, 1749, 1750, 8, 151, 1, 2, 1750, 301, 3, 2, 2, 2, 1751, 1752, 7, 128, 2, 2, 1752, 1753, 5, 304, 153, 2, 1753, 303, 3, 2, 2, 2, 1754, 1756, 5, 306, 154, 2, 1755, 1757, 7, 133, 2, 2, 1756, 1755, 3, 2, 2, 2, 1756, 1757, 3, 2, 2, 2, 1757, 1765, 3, 2, 2, 2, 1758, 1759, 7, 124, 2, 2, 1759, 1761, 5, 306, 154, 2, 1760, 1762, 7, 133, 2, 2, 1761, 1760, 3, 2, 2, 2, 1761, 1762, 3, 2, 2, 2, 1762, 1764, 3, 2, 2, 2, 1763, 1758, 3, 2, 2, 2, 1764, 1767, 3, 2, 2, 2, 1765, 1763, 3, 2, 2, 2, 1765, 1766, 3, 2, 2, 2, 1766, 305, 3, 2, 2, 2, 1767, 1765, 3, 2, 2, 2, 1768, 1770, 5, 202, 102, 2, 1769, 1768, 3, 2, 2, 2, 1769, 1770, 3, 2, 2, 2, 1770, 1783, 3, 2, 2, 2, 1771, 1784, 5, 310, 156, 2, 1772, 1774, 7, 82, 2, 2, 1773, 1775, 5, 312, 157, 2, 1774, 1773, 3, 2, 2, 2, 1774, 1775, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 1784, 5, 310, 156, 2, 1777, 1779, 5, 312, 157, 2, 1778, 1780, 7, 82, 2, 2, 1779, 1778, 3, 2, 2, 2, 1779, 1780, 3, 2, 2, 2, 1780, 1781, 3, 2, 2, 2, 1781, 1782, 5, 310, 156, 2, 1782, 1784, 3, 2, 2, 2, 1783, 1771, 3, 2, 2, 2, 1783, 1772, 3, 2, 2, 2, 1783, 1777, 3, 2, 2, 2, 1784, 307, 3, 2, 2, 2, 1785, 1787, 5, 12, 7, 2, 1786, 1785, 3, 2, 2, 2, 1786, 1787, 3, 2, 2, 2, 1787, 1788, 3, 2, 2, 2, 1788, 1791, 5, 276, 139, 2, 1789, 1791, 5, 160, 81, 2, 1790, 1786, 3, 2, 2, 2, 1790, 1789, 3, 2, 2, 2, 1791, 309, 3, 2, 2, 2, 1792, 1793, 5, 308, 155, 2, 1793, 311, 3, 2, 2, 2, 1794, 1795, 9, 21, 2, 2, 1795, 313, 3, 2, 2, 2, 1796, 1797, 7, 54, 2, 2, 1797, 1798, 5, 316, 159, 2, 1798, 315, 3, 2, 2, 2, 1799, 1801, 5, 152, 77, 2, 1800, 1802, 5, 318, 160, 2, 1801, 1800, 3, 2, 2, 2, 1801, 1802, 3, 2, 2, 2, 1802, 317, 3, 2, 2, 2, 1803, 1805, 5, 234, 118, 2, 1804, 1806, 5, 318, 160, 2, 1805, 1804, 3, 2, 2, 2, 1805, 1806, 3, 2, 2, 2, 1806, 319, 3, 2, 2, 2, 1807, 1808, 7, 128, 2, 2, 1808, 1809, 5, 322, 162, 2, 1809, 321, 3, 2, 2, 2, 1810, 1812, 5, 324, 163, 2, 1811, 1813, 7, 133, 2, 2, 1812, 1811, 3, 2, 2, 2, 1812, 1813, 3, 2, 2, 2, 1813, 1821, 3, 2, 2, 2, 1814, 1815, 7, 124, 2, 2, 1815, 1817, 5, 324, 163, 2, 1816, 1818, 7, 133, 2, 2, 1817, 1816, 3, 2, 2, 2, 1817, 1818, 3, 2, 2, 2, 1818, 1820, 3, 2, 2, 2, 1819, 1814, 3, 2, 2, 2, 1820, 1823, 3, 2, 2, 2, 1821, 1819, 3, 2, 2, 2, 1821, 1822, 3, 2, 2, 2, 1822, 323, 3, 2, 2, 2, 1823, 1821, 3, 2, 2, 2, 1824, 1831, 5, 326, 164, 2, 1825, 1827, 7, 87, 2, 2, 1826, 1828, 5, 36, 19, 2, 1827, 1826, 3, 2, 2, 2, 1827, 1828, 3, 2, 2, 2, 1828, 1829, 3, 2, 2, 2, 1829, 1832, 7, 88, 2, 2, 1830, 1832, 5, 274, 138, 2, 1831, 1825, 3, 2, 2, 2, 1831, 1830, 3, 2, 2, 2, 1832, 325, 3, 2, 2, 2, 1833, 1836, 5, 308, 155, 2, 1834, 1836, 7, 134, 2, 2, 1835, 1833, 3, 2, 2, 2, 1835, 1834, 3, 2, 2, 2, 1836, 327, 3, 2, 2, 2, 1837, 1838, 7, 54, 2, 2, 1838, 1839, 5, 376, 189, 2, 1839, 329, 3, 2, 2, 2, 1840, 1844, 7, 54, 2, 2, 1841, 1842, 7, 6, 2, 2, 1842, 1845, 7, 134, 2, 2, 1843, 1845, 7, 142, 2, 2, 1844, 1841, 3, 2, 2, 2, 1844, 1843, 3, 2, 2, 2, 1845, 331, 3, 2, 2, 2, 1846, 1847, 7, 70, 2, 2, 1847, 1848, 7, 104, 2, 2, 1848, 1849, 5, 334, 168, 2, 1849, 1850, 7, 105, 2, 2, 1850, 1851, 5, 124, 63, 2, 1851, 333, 3, 2, 2, 2, 1852, 1857, 5, 336, 169, 2, 1853, 1854, 7, 124, 2, 2, 1854, 1856, 5, 336, 169, 2, 1855, 1853, 3, 2, 2, 2, 1856, 1859, 3, 2, 2, 2, 1857, 1855, 3, 2, 2, 2, 1857, 1858, 3, 2, 2, 2, 1858, 335, 3, 2, 2, 2, 1859, 1857, 3, 2, 2, 2, 1860, 1863, 5, 338, 170, 2, 1861, 1863, 5, 260, 131, 2, 1862, 1860, 3, 2, 2, 2, 1862, 1861, 3, 2, 2, 2, 1863, 337, 3, 2, 2, 2, 1864, 1865, 7, 70, 2, 2, 1865, 1866, 7, 104, 2, 2, 1866, 1867, 5, 334, 168, 2, 1867, 1868, 7, 105, 2, 2, 1868, 1870, 3, 2, 2, 2, 1869, 1864, 3, 2, 2, 2, 1869, 1870, 3, 2, 2, 2, 1870, 1871, 3, 2, 2, 2, 1871, 1874, 7, 23, 2, 2, 1872, 1874, 7, 78, 2, 2, 1873, 1869, 3, 2, 2, 2, 1873, 1872, 3, 2, 2, 2, 1874, 1886, 3, 2, 2, 2, 1875, 1877, 7, 133, 2, 2, 1876, 1875, 3, 2, 2, 2, 1876, 1877, 3, 2, 2, 2, 1877, 1879, 3, 2, 2, 2, 1878, 1880, 7, 134, 2, 2, 1879, 1878, 3, 2, 2, 2, 1879, 1880, 3, 2, 2, 2, 1880, 1887, 3, 2, 2, 2, 1881, 1883, 7, 134, 2, 2, 1882, 1881, 3, 2, 2, 2, 1882, 1883, 3, 2, 2, 2, 1883, 1884, 3, 2, 2, 2, 1884, 1885, 7, 103, 2, 2, 1885, 1887, 5, 244, 123, 2, 1886, 1876, 3, 2, 2, 2, 1886, 1882, 3, 2, 2, 2, 1887, 339, 3, 2, 2, 2, 1888, 1889, 5, 344, 173, 2, 1889, 1891, 7, 104, 2, 2, 1890, 1892, 5, 346, 174, 2, 1891, 1890, 3, 2, 2, 2, 1891, 1892, 3, 2, 2, 2, 1892, 1893, 3, 2, 2, 2, 1893, 1894, 7, 105, 2, 2, 1894, 341, 3, 2, 2, 2, 1895, 1907, 5, 340, 171, 2, 1896, 1899, 5, 328, 165, 2, 1897, 1899, 5, 330, 166, 2, 1898, 1896, 3, 2, 2, 2, 1898, 1897, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1902, 7, 104, 2, 2, 1901, 1903, 5, 346, 174, 2, 1902, 1901, 3, 2, 2, 2, 1902, 1903, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1905, 7, 105, 2, 2, 1905, 1907, 3, 2, 2, 2, 1906, 1895, 3, 2, 2, 2, 1906, 1898, 3, 2, 2, 2, 1907, 343, 3, 2, 2, 2, 1908, 1909, 7, 134, 2, 2, 1909, 345, 3, 2, 2, 2, 1910, 1912, 5, 348, 175, 2, 1911, 1913, 7, 133, 2, 2, 1912, 1911, 3, 2, 2, 2, 1912, 1913, 3, 2, 2, 2, 1913, 1921, 3, 2, 2, 2, 1914, 1915, 7, 124, 2, 2, 1915, 1917, 5, 348, 175, 2, 1916, 1918, 7, 133, 2, 2, 1917, 1916, 3, 2, 2, 2, 1917, 1918, 3, 2, 2, 2, 1918, 1920, 3, 2, 2, 2, 1919, 1914, 3, 2, 2, 2, 1920, 1923, 3, 2, 2, 2, 1921, 1919, 3, 2, 2, 2, 1921, 1922, 3, 2, 2, 2, 1922, 347, 3, 2, 2, 2, 1923, 1921, 3, 2, 2, 2, 1924, 1928, 5, 244, 123, 2, 1925, 1928, 5, 94, 48, 2, 1926, 1928, 5, 6, 4, 2, 1927, 1924, 3, 2, 2, 2, 1927, 1925, 3, 2, 2, 2, 1927, 1926, 3, 2, 2, 2, 1928, 349, 3, 2, 2, 2, 1929, 1930, 7, 78, 2, 2, 1930, 1936, 5, 12, 7, 2, 1931, 1937, 7, 134, 2, 2, 1932, 1934, 7, 70, 2, 2, 1933, 1932, 3, 2, 2, 2, 1933, 1934, 3, 2, 2, 2, 1934, 1935, 3, 2, 2, 2, 1935, 1937, 5, 340, 171, 2, 1936, 1931, 3, 2, 2, 2, 1936, 1933, 3, 2, 2, 2, 1937, 351, 3, 2, 2, 2, 1938, 1940, 7, 38, 2, 2, 1939, 1938, 3, 2, 2, 2, 1939, 1940, 3, 2, 2, 2, 1940, 1941, 3, 2, 2, 2, 1941, 1942, 7, 70, 2, 2, 1942, 1943, 5, 124, 63, 2, 1943, 353, 3, 2, 2, 2, 1944, 1945, 7, 70, 2, 2, 1945, 1946, 7, 104, 2, 2, 1946, 1947, 7, 105, 2, 2, 1947, 1948, 5, 124, 63, 2, 1948, 355, 3, 2, 2, 2, 1949, 1950, 7, 75, 2, 2, 1950, 1951, 5, 102, 52, 2, 1951, 1952, 5, 360, 181, 2, 1952, 357, 3, 2, 2, 2, 1953, 1955, 7, 75, 2, 2, 1954, 1956, 5, 320, 161, 2, 1955, 1954, 3, 2, 2, 2, 1955, 1956, 3, 2, 2, 2, 1956, 1957, 3, 2, 2, 2, 1957, 1958, 5, 102, 52, 2, 1958, 1959, 5, 360, 181, 2, 1959, 359, 3, 2, 2, 2, 1960, 1962, 5, 362, 182, 2, 1961, 1960, 3, 2, 2, 2, 1962, 1963, 3, 2, 2, 2, 1963, 1961, 3, 2, 2, 2, 1963, 1964, 3, 2, 2, 2, 1964, 361, 3, 2, 2, 2, 1965, 1966, 7, 19, 2, 2, 1966, 1967, 7, 87, 2, 2, 1967, 1968, 5, 364, 183, 2, 1968, 1969, 7, 88, 2, 2, 1969, 1970, 5, 102, 52, 2, 1970, 363, 3, 2, 2, 2, 1971, 1973, 5, 202, 102, 2, 1972, 1971, 3, 2, 2, 2, 1972, 1973, 3, 2, 2, 2, 1973, 1974, 3, 2, 2, 2, 1974, 1977, 5, 152, 77, 2, 1975, 1978, 5, 224, 113, 2, 1976, 1978, 5, 246, 124, 2, 1977, 1975, 3, 2, 2, 2, 1977, 1976, 3, 2, 2, 2, 1977, 1978, 3, 2, 2, 2, 1978, 1981, 3, 2, 2, 2, 1979, 1981, 7, 133, 2, 2, 1980, 1972, 3, 2, 2, 2, 1980, 1979, 3, 2, 2, 2, 1981, 365, 3, 2, 2, 2, 1982, 1984, 7, 73, 2, 2, 1983, 1985, 5, 88, 45, 2, 1984, 1983, 3, 2, 2, 2, 1984, 1985, 3, 2, 2, 2, 1985, 367, 3, 2, 2, 2, 1986, 1989, 5, 370, 186, 2, 1987, 1989, 5, 374, 188, 2, 1988, 1986, 3, 2, 2, 2, 1988, 1987, 3, 2, 2, 2, 1989, 369, 3, 2, 2, 2, 1990, 1991, 7, 73, 2, 2, 1991, 1993, 7, 87, 2, 2, 1992, 1994, 5, 372, 187, 2, 1993, 1992, 3, 2, 2, 2, 1993, 1994, 3, 2, 2, 2, 1994, 1995, 3, 2, 2, 2, 1995, 1996, 7, 88, 2, 2, 1996, 371, 3, 2, 2, 2, 1997, 1999, 5, 244, 123, 2, 1998, 2000, 7, 133, 2, 2, 1999, 1998, 3, 2, 2, 2, 1999, 2000, 3, 2, 2, 2, 2000, 2008, 3, 2, 2, 2, 2001, 2002, 7, 124, 2, 2, 2002, 2004, 5, 244, 123, 2, 2003, 2005, 7, 133, 2, 2, 2004, 2003, 3, 2, 2, 2, 2004, 2005, 3, 2, 2, 2, 2005, 2007, 3, 2, 2, 2, 2006, 2001, 3, 2, 2, 2, 2007, 2010, 3, 2, 2, 2, 2008, 2006, 3, 2, 2, 2, 2008, 2009, 3, 2, 2, 2, 2009, 373, 3, 2, 2, 2, 2010, 2008, 3, 2, 2, 2, 2011, 2012, 7, 52, 2, 2, 2012, 2013, 7, 87, 2, 2, 2013, 2014, 5, 94, 48, 2, 2014, 2015, 7, 88, 2, 2, 2015, 2018, 3, 2, 2, 2, 2016, 2018, 7, 52, 2, 2, 2017, 2011, 3, 2, 2, 2, 2017, 2016, 3, 2, 2, 2, 2018, 375, 3, 2, 2, 2, 2019, 2022, 7, 51, 2, 2, 2020, 2021, 7, 89, 2, 2, 2021, 2023, 7, 90, 2, 2, 2022, 2020, 3, 2, 2, 2, 2022, 2023, 3, 2, 2, 2, 2023, 2073, 3, 2, 2, 2, 2024, 2027, 7, 30, 2, 2, 2025, 2026, 7, 89, 2, 2, 2026, 2028, 7, 90, 2, 2, 2027, 2025, 3, 2, 2, 2, 2027, 2028, 3, 2, 2, 2, 2028, 2073, 3, 2, 2, 2, 2029, 2073, 7, 93, 2, 2, 2030, 2073, 7, 94, 2, 2, 2031, 2073, 7, 95, 2, 2, 2032, 2073, 7, 96, 2, 2, 2033, 2073, 7, 97, 2, 2, 2034, 2073, 7, 98, 2, 2, 2035, 2073, 7, 99, 2, 2, 2036, 2073, 7, 100, 2, 2, 2037, 2073, 7, 101, 2, 2, 2038, 2073, 7, 102, 2, 2, 2039, 2073, 7, 103, 2, 2, 2040, 2073, 7, 105, 2, 2, 2041, 2073, 7, 104, 2, 2, 2042, 2073, 7, 119, 2, 2, 2043, 2073, 7, 106, 2, 2, 2044, 2073, 7, 107, 2, 2, 2045, 2073, 7, 108, 2, 2, 2046, 2073, 7, 103, 2, 2, 2047, 2073, 7, 110, 2, 2, 2048, 2073, 7, 111, 2, 2, 2049, 2073, 7, 112, 2, 2, 2050, 2073, 7, 113, 2, 2, 2051, 2052, 7, 104, 2, 2, 2052, 2073, 7, 104, 2, 2, 2053, 2054, 7, 105, 2, 2, 2054, 2073, 7, 105, 2, 2, 2055, 2073, 7, 115, 2, 2, 2056, 2073, 7, 114, 2, 2, 2057, 2073, 7, 116, 2, 2, 2058, 2073, 7, 117, 2, 2, 2059, 2073, 7, 118, 2, 2, 2060, 2073, 7, 119, 2, 2, 2061, 2073, 7, 120, 2, 2, 2062, 2073, 7, 121, 2, 2, 2063, 2073, 7, 122, 2, 2, 2064, 2073, 7, 123, 2, 2, 2065, 2073, 7, 124, 2, 2, 2066, 2073, 7, 125, 2, 2, 2067, 2073, 7, 126, 2, 2, 2068, 2069, 7, 87, 2, 2, 2069, 2073, 7, 88, 2, 2, 2070, 2071, 7, 89, 2, 2, 2071, 2073, 7, 90, 2, 2, 2072, 2019, 3, 2, 2, 2, 2072, 2024, 3, 2, 2, 2, 2072, 2029, 3, 2, 2, 2, 2072, 2030, 3, 2, 2, 2, 2072, 2031, 3, 2, 2, 2, 2072, 2032, 3, 2, 2, 2, 2072, 2033, 3, 2, 2, 2, 2072, 2034, 3, 2, 2, 2, 2072, 2035, 3, 2, 2, 2, 2072, 2036, 3, 2, 2, 2, 2072, 2037, 3, 2, 2, 2, 2072, 2038, 3, 2, 2, 2, 2072, 2039, 3, 2, 2, 2, 2072, 2040, 3, 2, 2, 2, 2072, 2041, 3, 2, 2, 2, 2072, 2042, 3, 2, 2, 2, 2072, 2043, 3, 2, 2, 2, 2072, 2044, 3, 2, 2, 2, 2072, 2045, 3, 2, 2, 2, 2072, 2046, 3, 2, 2, 2, 2072, 2047, 3, 2, 2, 2, 2072, 2048, 3, 2, 2, 2, 2072, 2049, 3, 2, 2, 2, 2072, 2050, 3, 2, 2, 2, 2072, 2051, 3, 2, 2, 2, 2072, 2053, 3, 2, 2, 2, 2072, 2055, 3, 2, 2, 2, 2072, 2056, 3, 2, 2, 2, 2072, 2057, 3, 2, 2, 2, 2072, 2058, 3, 2, 2, 2, 2072, 2059, 3, 2, 2, 2, 2072, 2060, 3, 2, 2, 2, 2072, 2061, 3, 2, 2, 2, 2072, 2062, 3, 2, 2, 2, 2072, 2063, 3, 2, 2, 2, 2072, 2064, 3, 2, 2, 2, 2072, 2065, 3, 2, 2, 2, 2072, 2066, 3, 2, 2, 2, 2072, 2067, 3, 2, 2, 2, 2072, 2068, 3, 2, 2, 2, 2072, 2070, 3, 2, 2, 2, 2073, 377, 3, 2, 2, 2, 2074, 2075, 9, 22, 2, 2, 2075, 379, 3, 2, 2, 2, 299, 381, 388, 397, 401, 410, 413, 417, 425, 432, 435, 440, 445, 451, 459, 461, 470, 474, 478, 481, 485, 488, 495, 499, 502, 505, 508, 514, 518, 522, 536, 540, 546, 553, 559, 563, 567, 569, 577, 582, 595, 602, 614, 624, 629, 633, 640, 643, 651, 655, 658, 665, 672, 676, 681, 685, 688, 693, 708, 715, 723, 731, 740, 747, 754, 762, 770, 778, 786, 794, 802, 811, 819, 828, 835, 843, 846, 849, 855, 861, 867, 874, 883, 891, 895, 902, 904, 924, 928, 934, 939, 943, 946, 953, 960, 964, 973, 984, 994, 999, 1006, 1009, 1014, 1019, 1040, 1045, 1048, 1059, 1065, 1070, 1073, 1078, 1081, 1084, 1106, 1112, 1118, 1124, 1127, 1133, 1137, 1141, 1144, 1152, 1154, 1160, 1163, 1166, 1169, 1173, 1177, 1183, 1193, 1199, 1205, 1210, 1215, 1219, 1232, 1238, 1242, 1248, 1253, 1268, 1272, 1277, 1282, 1287, 1293, 1296, 1305, 1309, 1314, 1318, 1324, 1331, 1348, 1350, 1357, 1362, 1369, 1373, 1377, 1385, 1391, 1397, 1401, 1403, 1407, 1412, 1416, 1419, 1422, 1425, 1430, 1434, 1437, 1441, 1444, 1446, 1451, 1458, 1464, 1468, 1474, 1480, 1483, 1485, 1491, 1495, 1501, 1508, 1512, 1514, 1518, 1524, 1536, 1540, 1542, 1546, 1551, 1554, 1561, 1565, 1570, 1572, 1576, 1579, 1582, 1586, 1591, 1598, 1605, 1610, 1614, 1618, 1623, 1627, 1633, 1635, 1641, 1646, 1652, 1656, 1658, 1661, 1665, 1669, 1671, 1673, 1676, 1688, 1690, 1693, 1696, 1699, 1708, 1715, 1720, 1723, 1726, 1728, 1731, 1734, 1738, 1743, 1756, 1761, 1765, 1769, 1774, 1779, 1783, 1786, 1790, 1801, 1805, 1812, 1817, 1821, 1827, 1831, 1835, 1844, 1857, 1862, 1869, 1873, 1876, 1879, 1882, 1886, 1891, 1898, 1902, 1906, 1912, 1917, 1921, 1927, 1933, 1936, 1939, 1955, 1963, 1972, 1977, 1980, 1984, 1988, 1993, 1999, 2004, 2008, 2017, 2022, 2027, 2072] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.interp deleted file mode 100644 index 91a28a7..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.interp +++ /dev/null @@ -1,665 +0,0 @@ -token literal names: -null -'\u00EF\u00BB\u00BF' -null -'/***/' -null -null -null -null -'#' -'abstract' -'add' -'alias' -'__arglist' -'as' -'ascending' -'async' -'await' -'base' -'bool' -'break' -'by' -'byte' -'case' -'catch' -'char' -'checked' -'class' -'const' -'continue' -'decimal' -'default' -'delegate' -'descending' -'do' -'double' -'dynamic' -'else' -'enum' -'equals' -'event' -'explicit' -'extern' -'false' -'finally' -'fixed' -'float' -'for' -'foreach' -'from' -'get' -'goto' -'group' -'if' -'implicit' -'in' -'int' -'interface' -'internal' -'into' -'is' -'join' -'let' -'lock' -'long' -'nameof' -'namespace' -'new' -'null' -'object' -'on' -'operator' -'orderby' -'out' -'override' -'params' -'partial' -'private' -'protected' -'public' -'readonly' -'ref' -'remove' -'return' -'sbyte' -'sealed' -'select' -'set' -'short' -'sizeof' -'stackalloc' -'static' -'string' -'struct' -'switch' -'this' -'throw' -'true' -'try' -'typeof' -'uint' -'ulong' -'unchecked' -'unmanaged' -'unsafe' -'ushort' -'using' -'var' -'virtual' -'void' -'volatile' -'when' -'where' -'while' -'yield' -null -null -null -null -null -null -null -null -null -null -null -'{' -'}' -'[' -']' -'(' -')' -'.' -',' -':' -';' -'+' -'-' -'*' -'/' -'%' -'&' -'|' -'^' -'!' -'~' -'=' -'<' -'>' -'?' -'::' -'??' -'++' -'--' -'&&' -'||' -'->' -'==' -'!=' -'<=' -'>=' -'+=' -'-=' -'*=' -'/=' -'%=' -'&=' -'|=' -'^=' -'<<' -'<<=' -'??=' -'..' -'{{' -null -null -null -null -null -null -null -null -null -null -'define' -'undef' -'elif' -'endif' -'line' -null -null -null -null -null -null -'hidden' -null -null -null -'}}' - -token symbolic names: -null -BYTE_ORDER_MARK -SINGLE_LINE_DOC_COMMENT -EMPTY_DELIMITED_DOC_COMMENT -DELIMITED_DOC_COMMENT -SINGLE_LINE_COMMENT -DELIMITED_COMMENT -WHITESPACES -SHARP -ABSTRACT -ADD -ALIAS -ARGLIST -AS -ASCENDING -ASYNC -AWAIT -BASE -BOOL -BREAK -BY -BYTE -CASE -CATCH -CHAR -CHECKED -CLASS -CONST -CONTINUE -DECIMAL -DEFAULT -DELEGATE -DESCENDING -DO -DOUBLE -DYNAMIC -ELSE -ENUM -EQUALS -EVENT -EXPLICIT -EXTERN -FALSE -FINALLY -FIXED -FLOAT -FOR -FOREACH -FROM -GET -GOTO -GROUP -IF -IMPLICIT -IN -INT -INTERFACE -INTERNAL -INTO -IS -JOIN -LET -LOCK -LONG -NAMEOF -NAMESPACE -NEW -NULL -OBJECT -ON -OPERATOR -ORDERBY -OUT -OVERRIDE -PARAMS -PARTIAL -PRIVATE -PROTECTED -PUBLIC -READONLY -REF -REMOVE -RETURN -SBYTE -SEALED -SELECT -SET -SHORT -SIZEOF -STACKALLOC -STATIC -STRING -STRUCT -SWITCH -THIS -THROW -TRUE -TRY -TYPEOF -UINT -ULONG -UNCHECKED -UNMANAGED -UNSAFE -USHORT -USING -VAR -VIRTUAL -VOID -VOLATILE -WHEN -WHERE -WHILE -YIELD -IDENTIFIER -LITERAL_ACCESS -INTEGER_LITERAL -HEX_INTEGER_LITERAL -BIN_INTEGER_LITERAL -REAL_LITERAL -CHARACTER_LITERAL -REGULAR_STRING -VERBATIUM_STRING -INTERPOLATED_REGULAR_STRING_START -INTERPOLATED_VERBATIUM_STRING_START -OPEN_BRACE -CLOSE_BRACE -OPEN_BRACKET -CLOSE_BRACKET -OPEN_PARENS -CLOSE_PARENS -DOT -COMMA -COLON -SEMICOLON -PLUS -MINUS -STAR -DIV -PERCENT -AMP -BITWISE_OR -CARET -BANG -TILDE -ASSIGNMENT -LT -GT -INTERR -DOUBLE_COLON -OP_COALESCING -OP_INC -OP_DEC -OP_AND -OP_OR -OP_PTR -OP_EQ -OP_NE -OP_LE -OP_GE -OP_ADD_ASSIGNMENT -OP_SUB_ASSIGNMENT -OP_MULT_ASSIGNMENT -OP_DIV_ASSIGNMENT -OP_MOD_ASSIGNMENT -OP_AND_ASSIGNMENT -OP_OR_ASSIGNMENT -OP_XOR_ASSIGNMENT -OP_LEFT_SHIFT -OP_LEFT_SHIFT_ASSIGNMENT -OP_COALESCING_ASSIGNMENT -OP_RANGE -DOUBLE_CURLY_INSIDE -OPEN_BRACE_INSIDE -REGULAR_CHAR_INSIDE -VERBATIUM_DOUBLE_QUOTE_INSIDE -DOUBLE_QUOTE_INSIDE -REGULAR_STRING_INSIDE -VERBATIUM_INSIDE_STRING -CLOSE_BRACE_INSIDE -FORMAT_STRING -DIRECTIVE_WHITESPACES -DIGITS -DEFINE -UNDEF -ELIF -ENDIF -LINE -ERROR -WARNING -REGION -ENDREGION -PRAGMA -NULLABLE -DIRECTIVE_HIDDEN -CONDITIONAL_SYMBOL -DIRECTIVE_NEW_LINE -TEXT -DOUBLE_CURLY_CLOSE_INSIDE - -rule names: -BYTE_ORDER_MARK -SINGLE_LINE_DOC_COMMENT -EMPTY_DELIMITED_DOC_COMMENT -DELIMITED_DOC_COMMENT -SINGLE_LINE_COMMENT -DELIMITED_COMMENT -WHITESPACES -SHARP -ABSTRACT -ADD -ALIAS -ARGLIST -AS -ASCENDING -ASYNC -AWAIT -BASE -BOOL -BREAK -BY -BYTE -CASE -CATCH -CHAR -CHECKED -CLASS -CONST -CONTINUE -DECIMAL -DEFAULT -DELEGATE -DESCENDING -DO -DOUBLE -DYNAMIC -ELSE -ENUM -EQUALS -EVENT -EXPLICIT -EXTERN -FALSE -FINALLY -FIXED -FLOAT -FOR -FOREACH -FROM -GET -GOTO -GROUP -IF -IMPLICIT -IN -INT -INTERFACE -INTERNAL -INTO -IS -JOIN -LET -LOCK -LONG -NAMEOF -NAMESPACE -NEW -NULL -OBJECT -ON -OPERATOR -ORDERBY -OUT -OVERRIDE -PARAMS -PARTIAL -PRIVATE -PROTECTED -PUBLIC -READONLY -REF -REMOVE -RETURN -SBYTE -SEALED -SELECT -SET -SHORT -SIZEOF -STACKALLOC -STATIC -STRING -STRUCT -SWITCH -THIS -THROW -TRUE -TRY -TYPEOF -UINT -ULONG -UNCHECKED -UNMANAGED -UNSAFE -USHORT -USING -VAR -VIRTUAL -VOID -VOLATILE -WHEN -WHERE -WHILE -YIELD -IDENTIFIER -LITERAL_ACCESS -INTEGER_LITERAL -HEX_INTEGER_LITERAL -BIN_INTEGER_LITERAL -REAL_LITERAL -CHARACTER_LITERAL -REGULAR_STRING -VERBATIUM_STRING -INTERPOLATED_REGULAR_STRING_START -INTERPOLATED_VERBATIUM_STRING_START -OPEN_BRACE -CLOSE_BRACE -OPEN_BRACKET -CLOSE_BRACKET -OPEN_PARENS -CLOSE_PARENS -DOT -COMMA -COLON -SEMICOLON -PLUS -MINUS -STAR -DIV -PERCENT -AMP -BITWISE_OR -CARET -BANG -TILDE -ASSIGNMENT -LT -GT -INTERR -DOUBLE_COLON -OP_COALESCING -OP_INC -OP_DEC -OP_AND -OP_OR -OP_PTR -OP_EQ -OP_NE -OP_LE -OP_GE -OP_ADD_ASSIGNMENT -OP_SUB_ASSIGNMENT -OP_MULT_ASSIGNMENT -OP_DIV_ASSIGNMENT -OP_MOD_ASSIGNMENT -OP_AND_ASSIGNMENT -OP_OR_ASSIGNMENT -OP_XOR_ASSIGNMENT -OP_LEFT_SHIFT -OP_LEFT_SHIFT_ASSIGNMENT -OP_COALESCING_ASSIGNMENT -OP_RANGE -DOUBLE_CURLY_INSIDE -OPEN_BRACE_INSIDE -REGULAR_CHAR_INSIDE -VERBATIUM_DOUBLE_QUOTE_INSIDE -DOUBLE_QUOTE_INSIDE -REGULAR_STRING_INSIDE -VERBATIUM_INSIDE_STRING -DOUBLE_CURLY_CLOSE_INSIDE -CLOSE_BRACE_INSIDE -FORMAT_STRING -DIRECTIVE_WHITESPACES -DIGITS -DIRECTIVE_TRUE -DIRECTIVE_FALSE -DEFINE -UNDEF -DIRECTIVE_IF -ELIF -DIRECTIVE_ELSE -ENDIF -LINE -ERROR -WARNING -REGION -ENDREGION -PRAGMA -NULLABLE -DIRECTIVE_DEFAULT -DIRECTIVE_HIDDEN -DIRECTIVE_OPEN_PARENS -DIRECTIVE_CLOSE_PARENS -DIRECTIVE_BANG -DIRECTIVE_OP_EQ -DIRECTIVE_OP_NE -DIRECTIVE_OP_AND -DIRECTIVE_OP_OR -DIRECTIVE_STRING -CONDITIONAL_SYMBOL -DIRECTIVE_SINGLE_LINE_COMMENT -DIRECTIVE_NEW_LINE -TEXT -TEXT_NEW_LINE -InputCharacter -NewLineCharacter -IntegerTypeSuffix -ExponentPart -CommonCharacter -SimpleEscapeSequence -HexEscapeSequence -NewLine -Whitespace -UnicodeClassZS -IdentifierOrKeyword -IdentifierStartCharacter -IdentifierPartCharacter -LetterCharacter -DecimalDigitCharacter -ConnectingCharacter -CombiningCharacter -FormattingCharacter -UnicodeEscapeSequence -HexDigit -UnicodeClassLU -UnicodeClassLL -UnicodeClassLT -UnicodeClassLM -UnicodeClassLO -UnicodeClassNL -UnicodeClassMN -UnicodeClassMC -UnicodeClassCF -UnicodeClassPC -UnicodeClassND - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN -null -null -COMMENTS_CHANNEL -DIRECTIVE - -mode names: -DEFAULT_MODE -INTERPOLATION_STRING -INTERPOLATION_FORMAT -DIRECTIVE_MODE -DIRECTIVE_TEXT - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 200, 2070, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223, 4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228, 9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232, 4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237, 9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241, 4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 505, 10, 3, 12, 3, 14, 3, 508, 11, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 7, 5, 526, 10, 5, 12, 5, 14, 5, 529, 11, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 7, 6, 540, 10, 6, 12, 6, 14, 6, 543, 11, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 7, 7, 551, 10, 7, 12, 7, 14, 7, 554, 11, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 6, 8, 563, 10, 8, 13, 8, 14, 8, 564, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 5, 115, 1249, 10, 115, 3, 115, 3, 115, 3, 116, 3, 116, 7, 116, 1255, 10, 116, 12, 116, 14, 116, 1258, 11, 116, 3, 116, 7, 116, 1261, 10, 116, 12, 116, 14, 116, 1264, 11, 116, 3, 116, 5, 116, 1267, 10, 116, 3, 116, 3, 116, 5, 116, 1271, 10, 116, 3, 116, 3, 116, 3, 117, 3, 117, 7, 117, 1277, 10, 117, 12, 117, 14, 117, 1280, 11, 117, 3, 117, 7, 117, 1283, 10, 117, 12, 117, 14, 117, 1286, 11, 117, 3, 117, 5, 117, 1289, 10, 117, 3, 118, 3, 118, 3, 118, 7, 118, 1294, 10, 118, 12, 118, 14, 118, 1297, 11, 118, 3, 118, 6, 118, 1300, 10, 118, 13, 118, 14, 118, 1301, 3, 118, 5, 118, 1305, 10, 118, 3, 119, 3, 119, 3, 119, 7, 119, 1310, 10, 119, 12, 119, 14, 119, 1313, 11, 119, 3, 119, 6, 119, 1316, 10, 119, 13, 119, 14, 119, 1317, 3, 119, 5, 119, 1321, 10, 119, 3, 120, 3, 120, 7, 120, 1325, 10, 120, 12, 120, 14, 120, 1328, 11, 120, 3, 120, 7, 120, 1331, 10, 120, 12, 120, 14, 120, 1334, 11, 120, 5, 120, 1336, 10, 120, 3, 120, 3, 120, 3, 120, 7, 120, 1341, 10, 120, 12, 120, 14, 120, 1344, 11, 120, 3, 120, 7, 120, 1347, 10, 120, 12, 120, 14, 120, 1350, 11, 120, 3, 120, 5, 120, 1353, 10, 120, 3, 120, 5, 120, 1356, 10, 120, 3, 120, 3, 120, 7, 120, 1360, 10, 120, 12, 120, 14, 120, 1363, 11, 120, 3, 120, 7, 120, 1366, 10, 120, 12, 120, 14, 120, 1369, 11, 120, 3, 120, 3, 120, 3, 120, 5, 120, 1374, 10, 120, 5, 120, 1376, 10, 120, 5, 120, 1378, 10, 120, 3, 121, 3, 121, 3, 121, 5, 121, 1383, 10, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 7, 122, 1390, 10, 122, 12, 122, 14, 122, 1393, 11, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 7, 123, 1403, 10, 123, 12, 123, 14, 123, 1406, 11, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 132, 3, 132, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 3, 140, 3, 140, 3, 141, 3, 141, 3, 142, 3, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 3, 153, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 6, 178, 1570, 10, 178, 13, 178, 14, 178, 1571, 3, 179, 3, 179, 6, 179, 1576, 10, 179, 13, 179, 14, 179, 1577, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 182, 6, 182, 1592, 10, 182, 13, 182, 14, 182, 1593, 3, 183, 6, 183, 1597, 10, 183, 13, 183, 14, 183, 1598, 3, 183, 3, 183, 3, 184, 6, 184, 1604, 10, 184, 13, 184, 14, 184, 1605, 3, 184, 3, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 6, 194, 1687, 10, 194, 13, 194, 14, 194, 1688, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 6, 195, 1703, 10, 195, 13, 195, 14, 195, 1704, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 7, 196, 1718, 10, 196, 12, 196, 14, 196, 1721, 11, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 7, 197, 1737, 10, 197, 12, 197, 14, 197, 1740, 11, 197, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 6, 198, 1753, 10, 198, 13, 198, 14, 198, 1754, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 6, 199, 1770, 10, 199, 13, 199, 14, 199, 1771, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 209, 3, 209, 7, 209, 1838, 10, 209, 12, 209, 14, 209, 1841, 11, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 211, 3, 211, 7, 211, 1856, 10, 211, 12, 211, 14, 211, 1859, 11, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 213, 6, 213, 1870, 10, 213, 13, 213, 14, 213, 1871, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 216, 3, 216, 3, 217, 5, 217, 1887, 10, 217, 3, 217, 3, 217, 5, 217, 1891, 10, 217, 3, 217, 5, 217, 1894, 10, 217, 3, 218, 3, 218, 5, 218, 1898, 10, 218, 3, 218, 3, 218, 7, 218, 1902, 10, 218, 12, 218, 14, 218, 1905, 11, 218, 3, 218, 7, 218, 1908, 10, 218, 12, 218, 14, 218, 1911, 11, 218, 3, 219, 3, 219, 3, 219, 5, 219, 1916, 10, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 5, 220, 1940, 10, 220, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 5, 221, 1967, 10, 221, 3, 222, 3, 222, 3, 222, 5, 222, 1972, 10, 222, 3, 223, 3, 223, 5, 223, 1976, 10, 223, 3, 224, 3, 224, 3, 225, 3, 225, 7, 225, 1982, 10, 225, 12, 225, 14, 225, 1985, 11, 225, 3, 226, 3, 226, 5, 226, 1989, 10, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 5, 227, 1996, 10, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 5, 228, 2005, 10, 228, 3, 229, 3, 229, 5, 229, 2009, 10, 229, 3, 230, 3, 230, 5, 230, 2013, 10, 230, 3, 231, 3, 231, 3, 231, 5, 231, 2018, 10, 231, 3, 232, 3, 232, 5, 232, 2022, 10, 232, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 5, 233, 2044, 10, 233, 3, 234, 5, 234, 2047, 10, 234, 3, 235, 3, 235, 3, 236, 3, 236, 3, 237, 3, 237, 3, 238, 3, 238, 3, 239, 3, 239, 3, 240, 3, 240, 3, 241, 3, 241, 3, 242, 3, 242, 3, 243, 3, 243, 3, 244, 3, 244, 3, 245, 3, 245, 4, 527, 552, 2, 246, 7, 3, 9, 4, 11, 5, 13, 6, 15, 7, 17, 8, 19, 9, 21, 10, 23, 11, 25, 12, 27, 13, 29, 14, 31, 15, 33, 16, 35, 17, 37, 18, 39, 19, 41, 20, 43, 21, 45, 22, 47, 23, 49, 24, 51, 25, 53, 26, 55, 27, 57, 28, 59, 29, 61, 30, 63, 31, 65, 32, 67, 33, 69, 34, 71, 35, 73, 36, 75, 37, 77, 38, 79, 39, 81, 40, 83, 41, 85, 42, 87, 43, 89, 44, 91, 45, 93, 46, 95, 47, 97, 48, 99, 49, 101, 50, 103, 51, 105, 52, 107, 53, 109, 54, 111, 55, 113, 56, 115, 57, 117, 58, 119, 59, 121, 60, 123, 61, 125, 62, 127, 63, 129, 64, 131, 65, 133, 66, 135, 67, 137, 68, 139, 69, 141, 70, 143, 71, 145, 72, 147, 73, 149, 74, 151, 75, 153, 76, 155, 77, 157, 78, 159, 79, 161, 80, 163, 81, 165, 82, 167, 83, 169, 84, 171, 85, 173, 86, 175, 87, 177, 88, 179, 89, 181, 90, 183, 91, 185, 92, 187, 93, 189, 94, 191, 95, 193, 96, 195, 97, 197, 98, 199, 99, 201, 100, 203, 101, 205, 102, 207, 103, 209, 104, 211, 105, 213, 106, 215, 107, 217, 108, 219, 109, 221, 110, 223, 111, 225, 112, 227, 113, 229, 114, 231, 115, 233, 116, 235, 117, 237, 118, 239, 119, 241, 120, 243, 121, 245, 122, 247, 123, 249, 124, 251, 125, 253, 126, 255, 127, 257, 128, 259, 129, 261, 130, 263, 131, 265, 132, 267, 133, 269, 134, 271, 135, 273, 136, 275, 137, 277, 138, 279, 139, 281, 140, 283, 141, 285, 142, 287, 143, 289, 144, 291, 145, 293, 146, 295, 147, 297, 148, 299, 149, 301, 150, 303, 151, 305, 152, 307, 153, 309, 154, 311, 155, 313, 156, 315, 157, 317, 158, 319, 159, 321, 160, 323, 161, 325, 162, 327, 163, 329, 164, 331, 165, 333, 166, 335, 167, 337, 168, 339, 169, 341, 170, 343, 171, 345, 172, 347, 173, 349, 174, 351, 175, 353, 176, 355, 177, 357, 178, 359, 179, 361, 180, 363, 200, 365, 181, 367, 182, 369, 183, 371, 184, 373, 2, 375, 2, 377, 185, 379, 186, 381, 2, 383, 187, 385, 2, 387, 188, 389, 189, 391, 190, 393, 191, 395, 192, 397, 193, 399, 194, 401, 195, 403, 2, 405, 196, 407, 2, 409, 2, 411, 2, 413, 2, 415, 2, 417, 2, 419, 2, 421, 2, 423, 197, 425, 2, 427, 198, 429, 199, 431, 2, 433, 2, 435, 2, 437, 2, 439, 2, 441, 2, 443, 2, 445, 2, 447, 2, 449, 2, 451, 2, 453, 2, 455, 2, 457, 2, 459, 2, 461, 2, 463, 2, 465, 2, 467, 2, 469, 2, 471, 2, 473, 2, 475, 2, 477, 2, 479, 2, 481, 2, 483, 2, 485, 2, 487, 2, 489, 2, 491, 2, 493, 2, 7, 2, 3, 4, 5, 6, 33, 3, 2, 49, 49, 3, 2, 50, 59, 4, 2, 90, 90, 122, 122, 4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 8, 2, 70, 70, 72, 72, 79, 79, 102, 102, 104, 104, 111, 111, 8, 2, 12, 12, 15, 15, 41, 41, 94, 94, 135, 135, 8234, 8235, 8, 2, 12, 12, 15, 15, 36, 36, 94, 94, 135, 135, 8234, 8235, 3, 2, 36, 36, 5, 2, 36, 36, 94, 94, 125, 125, 4, 2, 36, 36, 125, 125, 3, 2, 127, 127, 7, 2, 12, 12, 15, 15, 36, 36, 135, 135, 8234, 8235, 6, 2, 12, 12, 15, 15, 135, 135, 8234, 8235, 4, 2, 78, 78, 110, 110, 4, 2, 87, 87, 119, 119, 4, 2, 71, 71, 103, 103, 4, 2, 45, 45, 47, 47, 4, 2, 11, 11, 13, 14, 11, 2, 34, 34, 162, 162, 5762, 5762, 6160, 6160, 8194, 8200, 8202, 8204, 8241, 8241, 8289, 8289, 12290, 12290, 5, 2, 50, 59, 67, 72, 99, 104, 84, 2, 67, 92, 194, 216, 218, 224, 258, 312, 315, 329, 332, 383, 387, 388, 390, 397, 400, 403, 405, 406, 408, 410, 414, 415, 417, 418, 420, 427, 430, 437, 439, 446, 454, 463, 465, 477, 480, 496, 499, 502, 504, 506, 508, 564, 572, 573, 575, 576, 579, 584, 586, 592, 882, 884, 888, 897, 904, 908, 910, 931, 933, 941, 977, 982, 986, 1008, 1014, 1017, 1019, 1020, 1023, 1073, 1122, 1154, 1164, 1231, 1234, 1328, 1331, 1368, 4258, 4295, 4297, 4303, 7682, 7830, 7840, 7936, 7946, 7953, 7962, 7967, 7978, 7985, 7994, 8001, 8010, 8015, 8027, 8033, 8042, 8049, 8122, 8125, 8138, 8141, 8154, 8157, 8170, 8174, 8186, 8189, 8452, 8457, 8461, 8463, 8466, 8468, 8471, 8479, 8486, 8495, 8498, 8501, 8512, 8513, 8519, 8581, 11266, 11312, 11362, 11366, 11369, 11378, 11380, 11383, 11392, 11394, 11396, 11492, 11501, 11503, 11508, 42562, 42564, 42606, 42626, 42652, 42788, 42800, 42804, 42864, 42875, 42888, 42893, 42895, 42898, 42900, 42904, 42927, 42930, 42931, 65315, 65340, 83, 2, 99, 124, 183, 248, 250, 257, 259, 377, 380, 386, 389, 391, 394, 404, 407, 413, 416, 419, 421, 423, 426, 431, 434, 438, 440, 449, 456, 462, 464, 501, 503, 507, 509, 571, 574, 580, 585, 661, 663, 689, 883, 885, 889, 895, 914, 976, 978, 979, 983, 985, 987, 1013, 1015, 1121, 1123, 1155, 1165, 1217, 1220, 1329, 1379, 1417, 7426, 7469, 7533, 7545, 7547, 7580, 7683, 7839, 7841, 7945, 7954, 7959, 7970, 7977, 7986, 7993, 8002, 8007, 8018, 8025, 8034, 8041, 8050, 8063, 8066, 8073, 8082, 8089, 8098, 8105, 8114, 8118, 8120, 8121, 8128, 8134, 8136, 8137, 8146, 8149, 8152, 8153, 8162, 8169, 8180, 8182, 8184, 8185, 8460, 8469, 8497, 8507, 8510, 8511, 8520, 8523, 8528, 8582, 11314, 11360, 11363, 11374, 11379, 11389, 11395, 11502, 11504, 11509, 11522, 11559, 11561, 11567, 42563, 42607, 42627, 42653, 42789, 42803, 42805, 42874, 42876, 42878, 42881, 42889, 42894, 42896, 42899, 42903, 42905, 42923, 43004, 43868, 43878, 43879, 64258, 64264, 64277, 64281, 65347, 65372, 8, 2, 455, 461, 500, 8081, 8090, 8097, 8106, 8113, 8126, 8142, 8190, 8190, 35, 2, 690, 707, 712, 723, 738, 742, 750, 752, 886, 892, 1371, 1602, 1767, 1768, 2038, 2039, 2044, 2076, 2086, 2090, 2419, 3656, 3784, 4350, 6105, 6213, 6825, 7295, 7470, 7532, 7546, 7617, 8307, 8321, 8338, 8350, 11390, 11391, 11633, 11825, 12295, 12343, 12349, 12544, 40983, 42239, 42510, 42625, 42654, 42655, 42777, 42785, 42866, 42890, 43002, 43003, 43473, 43496, 43634, 43743, 43765, 43766, 43870, 43873, 65394, 65441, 236, 2, 172, 188, 445, 453, 662, 1516, 1522, 1524, 1570, 1601, 1603, 1612, 1648, 1649, 1651, 1749, 1751, 1790, 1793, 1810, 1812, 1841, 1871, 1959, 1971, 2028, 2050, 2071, 2114, 2138, 2210, 2228, 2310, 2363, 2367, 2386, 2394, 2403, 2420, 2434, 2439, 2446, 2449, 2450, 2453, 2474, 2476, 2482, 2484, 2491, 2495, 2512, 2526, 2527, 2529, 2531, 2546, 2547, 2567, 2572, 2577, 2578, 2581, 2602, 2604, 2610, 2612, 2613, 2615, 2616, 2618, 2619, 2651, 2654, 2656, 2678, 2695, 2703, 2705, 2707, 2709, 2730, 2732, 2738, 2740, 2741, 2743, 2747, 2751, 2770, 2786, 2787, 2823, 2830, 2833, 2834, 2837, 2858, 2860, 2866, 2868, 2869, 2871, 2875, 2879, 2915, 2931, 2949, 2951, 2956, 2960, 2962, 2964, 2967, 2971, 2972, 2974, 2988, 2992, 3003, 3026, 3086, 3088, 3090, 3092, 3114, 3116, 3131, 3135, 3214, 3216, 3218, 3220, 3242, 3244, 3253, 3255, 3259, 3263, 3296, 3298, 3299, 3315, 3316, 3335, 3342, 3344, 3346, 3348, 3388, 3391, 3408, 3426, 3427, 3452, 3457, 3463, 3480, 3484, 3507, 3509, 3517, 3519, 3528, 3587, 3634, 3636, 3637, 3650, 3655, 3715, 3716, 3718, 3724, 3727, 3737, 3739, 3745, 3747, 3749, 3751, 3753, 3756, 3757, 3759, 3762, 3764, 3765, 3775, 3782, 3806, 3809, 3842, 3913, 3915, 3950, 3978, 3982, 4098, 4140, 4161, 4183, 4188, 4191, 4195, 4210, 4215, 4227, 4240, 4348, 4351, 4682, 4684, 4687, 4690, 4696, 4698, 4703, 4706, 4746, 4748, 4751, 4754, 4786, 4788, 4791, 4794, 4800, 4802, 4807, 4810, 4824, 4826, 4882, 4884, 4887, 4890, 4956, 4994, 5009, 5026, 5110, 5123, 5742, 5745, 5761, 5763, 5788, 5794, 5868, 5875, 5882, 5890, 5902, 5904, 5907, 5922, 5939, 5954, 5971, 5986, 5998, 6000, 6002, 6018, 6069, 6110, 6212, 6214, 6265, 6274, 6314, 6316, 6391, 6402, 6432, 6482, 6511, 6514, 6518, 6530, 6573, 6595, 6601, 6658, 6680, 6690, 6742, 6919, 6965, 6983, 6989, 7045, 7074, 7088, 7089, 7100, 7143, 7170, 7205, 7247, 7249, 7260, 7289, 7403, 7406, 7408, 7411, 7415, 7416, 8503, 8506, 11570, 11625, 11650, 11672, 11682, 11688, 11690, 11696, 11698, 11704, 11706, 11712, 11714, 11720, 11722, 11728, 11730, 11736, 11738, 11744, 12296, 12350, 12355, 12440, 12449, 12540, 12545, 12591, 12595, 12688, 12706, 12732, 12786, 12801, 13314, 19895, 19970, 40910, 40962, 40982, 40984, 42126, 42194, 42233, 42242, 42509, 42514, 42529, 42540, 42541, 42608, 42727, 43001, 43011, 43013, 43015, 43017, 43020, 43022, 43044, 43074, 43125, 43140, 43189, 43252, 43257, 43261, 43303, 43314, 43336, 43362, 43390, 43398, 43444, 43490, 43494, 43497, 43505, 43516, 43520, 43522, 43562, 43586, 43588, 43590, 43597, 43618, 43633, 43635, 43640, 43644, 43697, 43699, 43711, 43714, 43716, 43741, 43742, 43746, 43756, 43764, 43784, 43787, 43792, 43795, 43800, 43810, 43816, 43818, 43824, 43970, 44004, 44034, 55205, 55218, 55240, 55245, 55293, 63746, 64111, 64114, 64219, 64287, 64298, 64300, 64312, 64314, 64318, 64320, 64435, 64469, 64831, 64850, 64913, 64916, 64969, 65010, 65021, 65138, 65142, 65144, 65278, 65384, 65393, 65395, 65439, 65442, 65472, 65476, 65481, 65484, 65489, 65492, 65497, 65500, 65502, 4, 2, 5872, 5874, 8546, 8561, 5, 2, 2309, 2309, 2368, 2370, 2379, 2382, 5, 2, 175, 175, 1538, 1541, 1759, 1759, 8, 2, 97, 97, 8257, 8258, 8278, 8278, 65077, 65078, 65103, 65105, 65345, 65345, 39, 2, 50, 59, 1634, 1643, 1778, 1787, 1986, 1995, 2408, 2417, 2536, 2545, 2664, 2673, 2792, 2801, 2920, 2929, 3048, 3057, 3176, 3185, 3304, 3313, 3432, 3441, 3560, 3569, 3666, 3675, 3794, 3803, 3874, 3883, 4162, 4171, 4242, 4251, 6114, 6123, 6162, 6171, 6472, 6481, 6610, 6619, 6786, 6795, 6802, 6811, 6994, 7003, 7090, 7099, 7234, 7243, 7250, 7259, 42530, 42539, 43218, 43227, 43266, 43275, 43474, 43483, 43506, 43515, 43602, 43611, 44018, 44027, 65298, 65307, 2, 2126, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 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, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 265, 3, 2, 2, 2, 2, 267, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 271, 3, 2, 2, 2, 2, 273, 3, 2, 2, 2, 2, 275, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 2, 281, 3, 2, 2, 2, 2, 283, 3, 2, 2, 2, 2, 285, 3, 2, 2, 2, 2, 287, 3, 2, 2, 2, 2, 289, 3, 2, 2, 2, 2, 291, 3, 2, 2, 2, 2, 293, 3, 2, 2, 2, 2, 295, 3, 2, 2, 2, 2, 297, 3, 2, 2, 2, 2, 299, 3, 2, 2, 2, 2, 301, 3, 2, 2, 2, 2, 303, 3, 2, 2, 2, 2, 305, 3, 2, 2, 2, 2, 307, 3, 2, 2, 2, 2, 309, 3, 2, 2, 2, 2, 311, 3, 2, 2, 2, 2, 313, 3, 2, 2, 2, 2, 315, 3, 2, 2, 2, 2, 317, 3, 2, 2, 2, 2, 319, 3, 2, 2, 2, 2, 321, 3, 2, 2, 2, 2, 323, 3, 2, 2, 2, 2, 325, 3, 2, 2, 2, 2, 327, 3, 2, 2, 2, 2, 329, 3, 2, 2, 2, 2, 331, 3, 2, 2, 2, 2, 333, 3, 2, 2, 2, 2, 335, 3, 2, 2, 2, 2, 337, 3, 2, 2, 2, 2, 339, 3, 2, 2, 2, 2, 341, 3, 2, 2, 2, 2, 343, 3, 2, 2, 2, 2, 345, 3, 2, 2, 2, 2, 347, 3, 2, 2, 2, 3, 349, 3, 2, 2, 2, 3, 351, 3, 2, 2, 2, 3, 353, 3, 2, 2, 2, 3, 355, 3, 2, 2, 2, 3, 357, 3, 2, 2, 2, 3, 359, 3, 2, 2, 2, 3, 361, 3, 2, 2, 2, 4, 363, 3, 2, 2, 2, 4, 365, 3, 2, 2, 2, 4, 367, 3, 2, 2, 2, 5, 369, 3, 2, 2, 2, 5, 371, 3, 2, 2, 2, 5, 373, 3, 2, 2, 2, 5, 375, 3, 2, 2, 2, 5, 377, 3, 2, 2, 2, 5, 379, 3, 2, 2, 2, 5, 381, 3, 2, 2, 2, 5, 383, 3, 2, 2, 2, 5, 385, 3, 2, 2, 2, 5, 387, 3, 2, 2, 2, 5, 389, 3, 2, 2, 2, 5, 391, 3, 2, 2, 2, 5, 393, 3, 2, 2, 2, 5, 395, 3, 2, 2, 2, 5, 397, 3, 2, 2, 2, 5, 399, 3, 2, 2, 2, 5, 401, 3, 2, 2, 2, 5, 403, 3, 2, 2, 2, 5, 405, 3, 2, 2, 2, 5, 407, 3, 2, 2, 2, 5, 409, 3, 2, 2, 2, 5, 411, 3, 2, 2, 2, 5, 413, 3, 2, 2, 2, 5, 415, 3, 2, 2, 2, 5, 417, 3, 2, 2, 2, 5, 419, 3, 2, 2, 2, 5, 421, 3, 2, 2, 2, 5, 423, 3, 2, 2, 2, 5, 425, 3, 2, 2, 2, 5, 427, 3, 2, 2, 2, 6, 429, 3, 2, 2, 2, 6, 431, 3, 2, 2, 2, 7, 495, 3, 2, 2, 2, 9, 499, 3, 2, 2, 2, 11, 511, 3, 2, 2, 2, 13, 519, 3, 2, 2, 2, 15, 535, 3, 2, 2, 2, 17, 546, 3, 2, 2, 2, 19, 562, 3, 2, 2, 2, 21, 568, 3, 2, 2, 2, 23, 572, 3, 2, 2, 2, 25, 581, 3, 2, 2, 2, 27, 585, 3, 2, 2, 2, 29, 591, 3, 2, 2, 2, 31, 601, 3, 2, 2, 2, 33, 604, 3, 2, 2, 2, 35, 614, 3, 2, 2, 2, 37, 620, 3, 2, 2, 2, 39, 626, 3, 2, 2, 2, 41, 631, 3, 2, 2, 2, 43, 636, 3, 2, 2, 2, 45, 642, 3, 2, 2, 2, 47, 645, 3, 2, 2, 2, 49, 650, 3, 2, 2, 2, 51, 655, 3, 2, 2, 2, 53, 661, 3, 2, 2, 2, 55, 666, 3, 2, 2, 2, 57, 674, 3, 2, 2, 2, 59, 680, 3, 2, 2, 2, 61, 686, 3, 2, 2, 2, 63, 695, 3, 2, 2, 2, 65, 703, 3, 2, 2, 2, 67, 711, 3, 2, 2, 2, 69, 720, 3, 2, 2, 2, 71, 731, 3, 2, 2, 2, 73, 734, 3, 2, 2, 2, 75, 741, 3, 2, 2, 2, 77, 749, 3, 2, 2, 2, 79, 754, 3, 2, 2, 2, 81, 759, 3, 2, 2, 2, 83, 766, 3, 2, 2, 2, 85, 772, 3, 2, 2, 2, 87, 781, 3, 2, 2, 2, 89, 788, 3, 2, 2, 2, 91, 794, 3, 2, 2, 2, 93, 802, 3, 2, 2, 2, 95, 808, 3, 2, 2, 2, 97, 814, 3, 2, 2, 2, 99, 818, 3, 2, 2, 2, 101, 826, 3, 2, 2, 2, 103, 831, 3, 2, 2, 2, 105, 835, 3, 2, 2, 2, 107, 840, 3, 2, 2, 2, 109, 846, 3, 2, 2, 2, 111, 849, 3, 2, 2, 2, 113, 858, 3, 2, 2, 2, 115, 861, 3, 2, 2, 2, 117, 865, 3, 2, 2, 2, 119, 875, 3, 2, 2, 2, 121, 884, 3, 2, 2, 2, 123, 889, 3, 2, 2, 2, 125, 892, 3, 2, 2, 2, 127, 897, 3, 2, 2, 2, 129, 901, 3, 2, 2, 2, 131, 906, 3, 2, 2, 2, 133, 911, 3, 2, 2, 2, 135, 918, 3, 2, 2, 2, 137, 928, 3, 2, 2, 2, 139, 932, 3, 2, 2, 2, 141, 937, 3, 2, 2, 2, 143, 944, 3, 2, 2, 2, 145, 947, 3, 2, 2, 2, 147, 956, 3, 2, 2, 2, 149, 964, 3, 2, 2, 2, 151, 968, 3, 2, 2, 2, 153, 977, 3, 2, 2, 2, 155, 984, 3, 2, 2, 2, 157, 992, 3, 2, 2, 2, 159, 1000, 3, 2, 2, 2, 161, 1010, 3, 2, 2, 2, 163, 1017, 3, 2, 2, 2, 165, 1026, 3, 2, 2, 2, 167, 1030, 3, 2, 2, 2, 169, 1037, 3, 2, 2, 2, 171, 1044, 3, 2, 2, 2, 173, 1050, 3, 2, 2, 2, 175, 1057, 3, 2, 2, 2, 177, 1064, 3, 2, 2, 2, 179, 1068, 3, 2, 2, 2, 181, 1074, 3, 2, 2, 2, 183, 1081, 3, 2, 2, 2, 185, 1092, 3, 2, 2, 2, 187, 1099, 3, 2, 2, 2, 189, 1106, 3, 2, 2, 2, 191, 1113, 3, 2, 2, 2, 193, 1120, 3, 2, 2, 2, 195, 1125, 3, 2, 2, 2, 197, 1131, 3, 2, 2, 2, 199, 1136, 3, 2, 2, 2, 201, 1140, 3, 2, 2, 2, 203, 1147, 3, 2, 2, 2, 205, 1152, 3, 2, 2, 2, 207, 1158, 3, 2, 2, 2, 209, 1168, 3, 2, 2, 2, 211, 1178, 3, 2, 2, 2, 213, 1185, 3, 2, 2, 2, 215, 1192, 3, 2, 2, 2, 217, 1198, 3, 2, 2, 2, 219, 1202, 3, 2, 2, 2, 221, 1210, 3, 2, 2, 2, 223, 1215, 3, 2, 2, 2, 225, 1224, 3, 2, 2, 2, 227, 1229, 3, 2, 2, 2, 229, 1235, 3, 2, 2, 2, 231, 1241, 3, 2, 2, 2, 233, 1248, 3, 2, 2, 2, 235, 1252, 3, 2, 2, 2, 237, 1274, 3, 2, 2, 2, 239, 1290, 3, 2, 2, 2, 241, 1306, 3, 2, 2, 2, 243, 1377, 3, 2, 2, 2, 245, 1379, 3, 2, 2, 2, 247, 1386, 3, 2, 2, 2, 249, 1396, 3, 2, 2, 2, 251, 1409, 3, 2, 2, 2, 253, 1416, 3, 2, 2, 2, 255, 1424, 3, 2, 2, 2, 257, 1427, 3, 2, 2, 2, 259, 1430, 3, 2, 2, 2, 261, 1432, 3, 2, 2, 2, 263, 1434, 3, 2, 2, 2, 265, 1436, 3, 2, 2, 2, 267, 1438, 3, 2, 2, 2, 269, 1440, 3, 2, 2, 2, 271, 1442, 3, 2, 2, 2, 273, 1445, 3, 2, 2, 2, 275, 1447, 3, 2, 2, 2, 277, 1449, 3, 2, 2, 2, 279, 1451, 3, 2, 2, 2, 281, 1453, 3, 2, 2, 2, 283, 1455, 3, 2, 2, 2, 285, 1457, 3, 2, 2, 2, 287, 1459, 3, 2, 2, 2, 289, 1461, 3, 2, 2, 2, 291, 1463, 3, 2, 2, 2, 293, 1465, 3, 2, 2, 2, 295, 1467, 3, 2, 2, 2, 297, 1469, 3, 2, 2, 2, 299, 1471, 3, 2, 2, 2, 301, 1473, 3, 2, 2, 2, 303, 1475, 3, 2, 2, 2, 305, 1478, 3, 2, 2, 2, 307, 1481, 3, 2, 2, 2, 309, 1484, 3, 2, 2, 2, 311, 1487, 3, 2, 2, 2, 313, 1490, 3, 2, 2, 2, 315, 1493, 3, 2, 2, 2, 317, 1496, 3, 2, 2, 2, 319, 1499, 3, 2, 2, 2, 321, 1502, 3, 2, 2, 2, 323, 1505, 3, 2, 2, 2, 325, 1508, 3, 2, 2, 2, 327, 1511, 3, 2, 2, 2, 329, 1514, 3, 2, 2, 2, 331, 1517, 3, 2, 2, 2, 333, 1520, 3, 2, 2, 2, 335, 1523, 3, 2, 2, 2, 337, 1526, 3, 2, 2, 2, 339, 1529, 3, 2, 2, 2, 341, 1532, 3, 2, 2, 2, 343, 1535, 3, 2, 2, 2, 345, 1539, 3, 2, 2, 2, 347, 1543, 3, 2, 2, 2, 349, 1546, 3, 2, 2, 2, 351, 1549, 3, 2, 2, 2, 353, 1555, 3, 2, 2, 2, 355, 1558, 3, 2, 2, 2, 357, 1562, 3, 2, 2, 2, 359, 1567, 3, 2, 2, 2, 361, 1573, 3, 2, 2, 2, 363, 1579, 3, 2, 2, 2, 365, 1584, 3, 2, 2, 2, 367, 1591, 3, 2, 2, 2, 369, 1596, 3, 2, 2, 2, 371, 1603, 3, 2, 2, 2, 373, 1609, 3, 2, 2, 2, 375, 1617, 3, 2, 2, 2, 377, 1626, 3, 2, 2, 2, 379, 1635, 3, 2, 2, 2, 381, 1643, 3, 2, 2, 2, 383, 1649, 3, 2, 2, 2, 385, 1656, 3, 2, 2, 2, 387, 1664, 3, 2, 2, 2, 389, 1672, 3, 2, 2, 2, 391, 1679, 3, 2, 2, 2, 393, 1693, 3, 2, 2, 2, 395, 1709, 3, 2, 2, 2, 397, 1725, 3, 2, 2, 2, 399, 1744, 3, 2, 2, 2, 401, 1759, 3, 2, 2, 2, 403, 1776, 3, 2, 2, 2, 405, 1787, 3, 2, 2, 2, 407, 1796, 3, 2, 2, 2, 409, 1801, 3, 2, 2, 2, 411, 1806, 3, 2, 2, 2, 413, 1811, 3, 2, 2, 2, 415, 1817, 3, 2, 2, 2, 417, 1823, 3, 2, 2, 2, 419, 1829, 3, 2, 2, 2, 421, 1835, 3, 2, 2, 2, 423, 1847, 3, 2, 2, 2, 425, 1851, 3, 2, 2, 2, 427, 1863, 3, 2, 2, 2, 429, 1869, 3, 2, 2, 2, 431, 1875, 3, 2, 2, 2, 433, 1881, 3, 2, 2, 2, 435, 1883, 3, 2, 2, 2, 437, 1893, 3, 2, 2, 2, 439, 1895, 3, 2, 2, 2, 441, 1915, 3, 2, 2, 2, 443, 1939, 3, 2, 2, 2, 445, 1966, 3, 2, 2, 2, 447, 1971, 3, 2, 2, 2, 449, 1975, 3, 2, 2, 2, 451, 1977, 3, 2, 2, 2, 453, 1979, 3, 2, 2, 2, 455, 1988, 3, 2, 2, 2, 457, 1995, 3, 2, 2, 2, 459, 2004, 3, 2, 2, 2, 461, 2008, 3, 2, 2, 2, 463, 2012, 3, 2, 2, 2, 465, 2017, 3, 2, 2, 2, 467, 2021, 3, 2, 2, 2, 469, 2043, 3, 2, 2, 2, 471, 2046, 3, 2, 2, 2, 473, 2048, 3, 2, 2, 2, 475, 2050, 3, 2, 2, 2, 477, 2052, 3, 2, 2, 2, 479, 2054, 3, 2, 2, 2, 481, 2056, 3, 2, 2, 2, 483, 2058, 3, 2, 2, 2, 485, 2060, 3, 2, 2, 2, 487, 2062, 3, 2, 2, 2, 489, 2064, 3, 2, 2, 2, 491, 2066, 3, 2, 2, 2, 493, 2068, 3, 2, 2, 2, 495, 496, 7, 241, 2, 2, 496, 497, 7, 189, 2, 2, 497, 498, 7, 193, 2, 2, 498, 8, 3, 2, 2, 2, 499, 500, 7, 49, 2, 2, 500, 501, 7, 49, 2, 2, 501, 502, 7, 49, 2, 2, 502, 506, 3, 2, 2, 2, 503, 505, 5, 433, 215, 2, 504, 503, 3, 2, 2, 2, 505, 508, 3, 2, 2, 2, 506, 504, 3, 2, 2, 2, 506, 507, 3, 2, 2, 2, 507, 509, 3, 2, 2, 2, 508, 506, 3, 2, 2, 2, 509, 510, 8, 3, 2, 2, 510, 10, 3, 2, 2, 2, 511, 512, 7, 49, 2, 2, 512, 513, 7, 44, 2, 2, 513, 514, 7, 44, 2, 2, 514, 515, 7, 44, 2, 2, 515, 516, 7, 49, 2, 2, 516, 517, 3, 2, 2, 2, 517, 518, 8, 4, 2, 2, 518, 12, 3, 2, 2, 2, 519, 520, 7, 49, 2, 2, 520, 521, 7, 44, 2, 2, 521, 522, 7, 44, 2, 2, 522, 523, 3, 2, 2, 2, 523, 527, 10, 2, 2, 2, 524, 526, 11, 2, 2, 2, 525, 524, 3, 2, 2, 2, 526, 529, 3, 2, 2, 2, 527, 528, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 528, 530, 3, 2, 2, 2, 529, 527, 3, 2, 2, 2, 530, 531, 7, 44, 2, 2, 531, 532, 7, 49, 2, 2, 532, 533, 3, 2, 2, 2, 533, 534, 8, 5, 2, 2, 534, 14, 3, 2, 2, 2, 535, 536, 7, 49, 2, 2, 536, 537, 7, 49, 2, 2, 537, 541, 3, 2, 2, 2, 538, 540, 5, 433, 215, 2, 539, 538, 3, 2, 2, 2, 540, 543, 3, 2, 2, 2, 541, 539, 3, 2, 2, 2, 541, 542, 3, 2, 2, 2, 542, 544, 3, 2, 2, 2, 543, 541, 3, 2, 2, 2, 544, 545, 8, 6, 2, 2, 545, 16, 3, 2, 2, 2, 546, 547, 7, 49, 2, 2, 547, 548, 7, 44, 2, 2, 548, 552, 3, 2, 2, 2, 549, 551, 11, 2, 2, 2, 550, 549, 3, 2, 2, 2, 551, 554, 3, 2, 2, 2, 552, 553, 3, 2, 2, 2, 552, 550, 3, 2, 2, 2, 553, 555, 3, 2, 2, 2, 554, 552, 3, 2, 2, 2, 555, 556, 7, 44, 2, 2, 556, 557, 7, 49, 2, 2, 557, 558, 3, 2, 2, 2, 558, 559, 8, 7, 2, 2, 559, 18, 3, 2, 2, 2, 560, 563, 5, 449, 223, 2, 561, 563, 5, 447, 222, 2, 562, 560, 3, 2, 2, 2, 562, 561, 3, 2, 2, 2, 563, 564, 3, 2, 2, 2, 564, 562, 3, 2, 2, 2, 564, 565, 3, 2, 2, 2, 565, 566, 3, 2, 2, 2, 566, 567, 8, 8, 3, 2, 567, 20, 3, 2, 2, 2, 568, 569, 7, 37, 2, 2, 569, 570, 3, 2, 2, 2, 570, 571, 8, 9, 4, 2, 571, 22, 3, 2, 2, 2, 572, 573, 7, 99, 2, 2, 573, 574, 7, 100, 2, 2, 574, 575, 7, 117, 2, 2, 575, 576, 7, 118, 2, 2, 576, 577, 7, 116, 2, 2, 577, 578, 7, 99, 2, 2, 578, 579, 7, 101, 2, 2, 579, 580, 7, 118, 2, 2, 580, 24, 3, 2, 2, 2, 581, 582, 7, 99, 2, 2, 582, 583, 7, 102, 2, 2, 583, 584, 7, 102, 2, 2, 584, 26, 3, 2, 2, 2, 585, 586, 7, 99, 2, 2, 586, 587, 7, 110, 2, 2, 587, 588, 7, 107, 2, 2, 588, 589, 7, 99, 2, 2, 589, 590, 7, 117, 2, 2, 590, 28, 3, 2, 2, 2, 591, 592, 7, 97, 2, 2, 592, 593, 7, 97, 2, 2, 593, 594, 7, 99, 2, 2, 594, 595, 7, 116, 2, 2, 595, 596, 7, 105, 2, 2, 596, 597, 7, 110, 2, 2, 597, 598, 7, 107, 2, 2, 598, 599, 7, 117, 2, 2, 599, 600, 7, 118, 2, 2, 600, 30, 3, 2, 2, 2, 601, 602, 7, 99, 2, 2, 602, 603, 7, 117, 2, 2, 603, 32, 3, 2, 2, 2, 604, 605, 7, 99, 2, 2, 605, 606, 7, 117, 2, 2, 606, 607, 7, 101, 2, 2, 607, 608, 7, 103, 2, 2, 608, 609, 7, 112, 2, 2, 609, 610, 7, 102, 2, 2, 610, 611, 7, 107, 2, 2, 611, 612, 7, 112, 2, 2, 612, 613, 7, 105, 2, 2, 613, 34, 3, 2, 2, 2, 614, 615, 7, 99, 2, 2, 615, 616, 7, 117, 2, 2, 616, 617, 7, 123, 2, 2, 617, 618, 7, 112, 2, 2, 618, 619, 7, 101, 2, 2, 619, 36, 3, 2, 2, 2, 620, 621, 7, 99, 2, 2, 621, 622, 7, 121, 2, 2, 622, 623, 7, 99, 2, 2, 623, 624, 7, 107, 2, 2, 624, 625, 7, 118, 2, 2, 625, 38, 3, 2, 2, 2, 626, 627, 7, 100, 2, 2, 627, 628, 7, 99, 2, 2, 628, 629, 7, 117, 2, 2, 629, 630, 7, 103, 2, 2, 630, 40, 3, 2, 2, 2, 631, 632, 7, 100, 2, 2, 632, 633, 7, 113, 2, 2, 633, 634, 7, 113, 2, 2, 634, 635, 7, 110, 2, 2, 635, 42, 3, 2, 2, 2, 636, 637, 7, 100, 2, 2, 637, 638, 7, 116, 2, 2, 638, 639, 7, 103, 2, 2, 639, 640, 7, 99, 2, 2, 640, 641, 7, 109, 2, 2, 641, 44, 3, 2, 2, 2, 642, 643, 7, 100, 2, 2, 643, 644, 7, 123, 2, 2, 644, 46, 3, 2, 2, 2, 645, 646, 7, 100, 2, 2, 646, 647, 7, 123, 2, 2, 647, 648, 7, 118, 2, 2, 648, 649, 7, 103, 2, 2, 649, 48, 3, 2, 2, 2, 650, 651, 7, 101, 2, 2, 651, 652, 7, 99, 2, 2, 652, 653, 7, 117, 2, 2, 653, 654, 7, 103, 2, 2, 654, 50, 3, 2, 2, 2, 655, 656, 7, 101, 2, 2, 656, 657, 7, 99, 2, 2, 657, 658, 7, 118, 2, 2, 658, 659, 7, 101, 2, 2, 659, 660, 7, 106, 2, 2, 660, 52, 3, 2, 2, 2, 661, 662, 7, 101, 2, 2, 662, 663, 7, 106, 2, 2, 663, 664, 7, 99, 2, 2, 664, 665, 7, 116, 2, 2, 665, 54, 3, 2, 2, 2, 666, 667, 7, 101, 2, 2, 667, 668, 7, 106, 2, 2, 668, 669, 7, 103, 2, 2, 669, 670, 7, 101, 2, 2, 670, 671, 7, 109, 2, 2, 671, 672, 7, 103, 2, 2, 672, 673, 7, 102, 2, 2, 673, 56, 3, 2, 2, 2, 674, 675, 7, 101, 2, 2, 675, 676, 7, 110, 2, 2, 676, 677, 7, 99, 2, 2, 677, 678, 7, 117, 2, 2, 678, 679, 7, 117, 2, 2, 679, 58, 3, 2, 2, 2, 680, 681, 7, 101, 2, 2, 681, 682, 7, 113, 2, 2, 682, 683, 7, 112, 2, 2, 683, 684, 7, 117, 2, 2, 684, 685, 7, 118, 2, 2, 685, 60, 3, 2, 2, 2, 686, 687, 7, 101, 2, 2, 687, 688, 7, 113, 2, 2, 688, 689, 7, 112, 2, 2, 689, 690, 7, 118, 2, 2, 690, 691, 7, 107, 2, 2, 691, 692, 7, 112, 2, 2, 692, 693, 7, 119, 2, 2, 693, 694, 7, 103, 2, 2, 694, 62, 3, 2, 2, 2, 695, 696, 7, 102, 2, 2, 696, 697, 7, 103, 2, 2, 697, 698, 7, 101, 2, 2, 698, 699, 7, 107, 2, 2, 699, 700, 7, 111, 2, 2, 700, 701, 7, 99, 2, 2, 701, 702, 7, 110, 2, 2, 702, 64, 3, 2, 2, 2, 703, 704, 7, 102, 2, 2, 704, 705, 7, 103, 2, 2, 705, 706, 7, 104, 2, 2, 706, 707, 7, 99, 2, 2, 707, 708, 7, 119, 2, 2, 708, 709, 7, 110, 2, 2, 709, 710, 7, 118, 2, 2, 710, 66, 3, 2, 2, 2, 711, 712, 7, 102, 2, 2, 712, 713, 7, 103, 2, 2, 713, 714, 7, 110, 2, 2, 714, 715, 7, 103, 2, 2, 715, 716, 7, 105, 2, 2, 716, 717, 7, 99, 2, 2, 717, 718, 7, 118, 2, 2, 718, 719, 7, 103, 2, 2, 719, 68, 3, 2, 2, 2, 720, 721, 7, 102, 2, 2, 721, 722, 7, 103, 2, 2, 722, 723, 7, 117, 2, 2, 723, 724, 7, 101, 2, 2, 724, 725, 7, 103, 2, 2, 725, 726, 7, 112, 2, 2, 726, 727, 7, 102, 2, 2, 727, 728, 7, 107, 2, 2, 728, 729, 7, 112, 2, 2, 729, 730, 7, 105, 2, 2, 730, 70, 3, 2, 2, 2, 731, 732, 7, 102, 2, 2, 732, 733, 7, 113, 2, 2, 733, 72, 3, 2, 2, 2, 734, 735, 7, 102, 2, 2, 735, 736, 7, 113, 2, 2, 736, 737, 7, 119, 2, 2, 737, 738, 7, 100, 2, 2, 738, 739, 7, 110, 2, 2, 739, 740, 7, 103, 2, 2, 740, 74, 3, 2, 2, 2, 741, 742, 7, 102, 2, 2, 742, 743, 7, 123, 2, 2, 743, 744, 7, 112, 2, 2, 744, 745, 7, 99, 2, 2, 745, 746, 7, 111, 2, 2, 746, 747, 7, 107, 2, 2, 747, 748, 7, 101, 2, 2, 748, 76, 3, 2, 2, 2, 749, 750, 7, 103, 2, 2, 750, 751, 7, 110, 2, 2, 751, 752, 7, 117, 2, 2, 752, 753, 7, 103, 2, 2, 753, 78, 3, 2, 2, 2, 754, 755, 7, 103, 2, 2, 755, 756, 7, 112, 2, 2, 756, 757, 7, 119, 2, 2, 757, 758, 7, 111, 2, 2, 758, 80, 3, 2, 2, 2, 759, 760, 7, 103, 2, 2, 760, 761, 7, 115, 2, 2, 761, 762, 7, 119, 2, 2, 762, 763, 7, 99, 2, 2, 763, 764, 7, 110, 2, 2, 764, 765, 7, 117, 2, 2, 765, 82, 3, 2, 2, 2, 766, 767, 7, 103, 2, 2, 767, 768, 7, 120, 2, 2, 768, 769, 7, 103, 2, 2, 769, 770, 7, 112, 2, 2, 770, 771, 7, 118, 2, 2, 771, 84, 3, 2, 2, 2, 772, 773, 7, 103, 2, 2, 773, 774, 7, 122, 2, 2, 774, 775, 7, 114, 2, 2, 775, 776, 7, 110, 2, 2, 776, 777, 7, 107, 2, 2, 777, 778, 7, 101, 2, 2, 778, 779, 7, 107, 2, 2, 779, 780, 7, 118, 2, 2, 780, 86, 3, 2, 2, 2, 781, 782, 7, 103, 2, 2, 782, 783, 7, 122, 2, 2, 783, 784, 7, 118, 2, 2, 784, 785, 7, 103, 2, 2, 785, 786, 7, 116, 2, 2, 786, 787, 7, 112, 2, 2, 787, 88, 3, 2, 2, 2, 788, 789, 7, 104, 2, 2, 789, 790, 7, 99, 2, 2, 790, 791, 7, 110, 2, 2, 791, 792, 7, 117, 2, 2, 792, 793, 7, 103, 2, 2, 793, 90, 3, 2, 2, 2, 794, 795, 7, 104, 2, 2, 795, 796, 7, 107, 2, 2, 796, 797, 7, 112, 2, 2, 797, 798, 7, 99, 2, 2, 798, 799, 7, 110, 2, 2, 799, 800, 7, 110, 2, 2, 800, 801, 7, 123, 2, 2, 801, 92, 3, 2, 2, 2, 802, 803, 7, 104, 2, 2, 803, 804, 7, 107, 2, 2, 804, 805, 7, 122, 2, 2, 805, 806, 7, 103, 2, 2, 806, 807, 7, 102, 2, 2, 807, 94, 3, 2, 2, 2, 808, 809, 7, 104, 2, 2, 809, 810, 7, 110, 2, 2, 810, 811, 7, 113, 2, 2, 811, 812, 7, 99, 2, 2, 812, 813, 7, 118, 2, 2, 813, 96, 3, 2, 2, 2, 814, 815, 7, 104, 2, 2, 815, 816, 7, 113, 2, 2, 816, 817, 7, 116, 2, 2, 817, 98, 3, 2, 2, 2, 818, 819, 7, 104, 2, 2, 819, 820, 7, 113, 2, 2, 820, 821, 7, 116, 2, 2, 821, 822, 7, 103, 2, 2, 822, 823, 7, 99, 2, 2, 823, 824, 7, 101, 2, 2, 824, 825, 7, 106, 2, 2, 825, 100, 3, 2, 2, 2, 826, 827, 7, 104, 2, 2, 827, 828, 7, 116, 2, 2, 828, 829, 7, 113, 2, 2, 829, 830, 7, 111, 2, 2, 830, 102, 3, 2, 2, 2, 831, 832, 7, 105, 2, 2, 832, 833, 7, 103, 2, 2, 833, 834, 7, 118, 2, 2, 834, 104, 3, 2, 2, 2, 835, 836, 7, 105, 2, 2, 836, 837, 7, 113, 2, 2, 837, 838, 7, 118, 2, 2, 838, 839, 7, 113, 2, 2, 839, 106, 3, 2, 2, 2, 840, 841, 7, 105, 2, 2, 841, 842, 7, 116, 2, 2, 842, 843, 7, 113, 2, 2, 843, 844, 7, 119, 2, 2, 844, 845, 7, 114, 2, 2, 845, 108, 3, 2, 2, 2, 846, 847, 7, 107, 2, 2, 847, 848, 7, 104, 2, 2, 848, 110, 3, 2, 2, 2, 849, 850, 7, 107, 2, 2, 850, 851, 7, 111, 2, 2, 851, 852, 7, 114, 2, 2, 852, 853, 7, 110, 2, 2, 853, 854, 7, 107, 2, 2, 854, 855, 7, 101, 2, 2, 855, 856, 7, 107, 2, 2, 856, 857, 7, 118, 2, 2, 857, 112, 3, 2, 2, 2, 858, 859, 7, 107, 2, 2, 859, 860, 7, 112, 2, 2, 860, 114, 3, 2, 2, 2, 861, 862, 7, 107, 2, 2, 862, 863, 7, 112, 2, 2, 863, 864, 7, 118, 2, 2, 864, 116, 3, 2, 2, 2, 865, 866, 7, 107, 2, 2, 866, 867, 7, 112, 2, 2, 867, 868, 7, 118, 2, 2, 868, 869, 7, 103, 2, 2, 869, 870, 7, 116, 2, 2, 870, 871, 7, 104, 2, 2, 871, 872, 7, 99, 2, 2, 872, 873, 7, 101, 2, 2, 873, 874, 7, 103, 2, 2, 874, 118, 3, 2, 2, 2, 875, 876, 7, 107, 2, 2, 876, 877, 7, 112, 2, 2, 877, 878, 7, 118, 2, 2, 878, 879, 7, 103, 2, 2, 879, 880, 7, 116, 2, 2, 880, 881, 7, 112, 2, 2, 881, 882, 7, 99, 2, 2, 882, 883, 7, 110, 2, 2, 883, 120, 3, 2, 2, 2, 884, 885, 7, 107, 2, 2, 885, 886, 7, 112, 2, 2, 886, 887, 7, 118, 2, 2, 887, 888, 7, 113, 2, 2, 888, 122, 3, 2, 2, 2, 889, 890, 7, 107, 2, 2, 890, 891, 7, 117, 2, 2, 891, 124, 3, 2, 2, 2, 892, 893, 7, 108, 2, 2, 893, 894, 7, 113, 2, 2, 894, 895, 7, 107, 2, 2, 895, 896, 7, 112, 2, 2, 896, 126, 3, 2, 2, 2, 897, 898, 7, 110, 2, 2, 898, 899, 7, 103, 2, 2, 899, 900, 7, 118, 2, 2, 900, 128, 3, 2, 2, 2, 901, 902, 7, 110, 2, 2, 902, 903, 7, 113, 2, 2, 903, 904, 7, 101, 2, 2, 904, 905, 7, 109, 2, 2, 905, 130, 3, 2, 2, 2, 906, 907, 7, 110, 2, 2, 907, 908, 7, 113, 2, 2, 908, 909, 7, 112, 2, 2, 909, 910, 7, 105, 2, 2, 910, 132, 3, 2, 2, 2, 911, 912, 7, 112, 2, 2, 912, 913, 7, 99, 2, 2, 913, 914, 7, 111, 2, 2, 914, 915, 7, 103, 2, 2, 915, 916, 7, 113, 2, 2, 916, 917, 7, 104, 2, 2, 917, 134, 3, 2, 2, 2, 918, 919, 7, 112, 2, 2, 919, 920, 7, 99, 2, 2, 920, 921, 7, 111, 2, 2, 921, 922, 7, 103, 2, 2, 922, 923, 7, 117, 2, 2, 923, 924, 7, 114, 2, 2, 924, 925, 7, 99, 2, 2, 925, 926, 7, 101, 2, 2, 926, 927, 7, 103, 2, 2, 927, 136, 3, 2, 2, 2, 928, 929, 7, 112, 2, 2, 929, 930, 7, 103, 2, 2, 930, 931, 7, 121, 2, 2, 931, 138, 3, 2, 2, 2, 932, 933, 7, 112, 2, 2, 933, 934, 7, 119, 2, 2, 934, 935, 7, 110, 2, 2, 935, 936, 7, 110, 2, 2, 936, 140, 3, 2, 2, 2, 937, 938, 7, 113, 2, 2, 938, 939, 7, 100, 2, 2, 939, 940, 7, 108, 2, 2, 940, 941, 7, 103, 2, 2, 941, 942, 7, 101, 2, 2, 942, 943, 7, 118, 2, 2, 943, 142, 3, 2, 2, 2, 944, 945, 7, 113, 2, 2, 945, 946, 7, 112, 2, 2, 946, 144, 3, 2, 2, 2, 947, 948, 7, 113, 2, 2, 948, 949, 7, 114, 2, 2, 949, 950, 7, 103, 2, 2, 950, 951, 7, 116, 2, 2, 951, 952, 7, 99, 2, 2, 952, 953, 7, 118, 2, 2, 953, 954, 7, 113, 2, 2, 954, 955, 7, 116, 2, 2, 955, 146, 3, 2, 2, 2, 956, 957, 7, 113, 2, 2, 957, 958, 7, 116, 2, 2, 958, 959, 7, 102, 2, 2, 959, 960, 7, 103, 2, 2, 960, 961, 7, 116, 2, 2, 961, 962, 7, 100, 2, 2, 962, 963, 7, 123, 2, 2, 963, 148, 3, 2, 2, 2, 964, 965, 7, 113, 2, 2, 965, 966, 7, 119, 2, 2, 966, 967, 7, 118, 2, 2, 967, 150, 3, 2, 2, 2, 968, 969, 7, 113, 2, 2, 969, 970, 7, 120, 2, 2, 970, 971, 7, 103, 2, 2, 971, 972, 7, 116, 2, 2, 972, 973, 7, 116, 2, 2, 973, 974, 7, 107, 2, 2, 974, 975, 7, 102, 2, 2, 975, 976, 7, 103, 2, 2, 976, 152, 3, 2, 2, 2, 977, 978, 7, 114, 2, 2, 978, 979, 7, 99, 2, 2, 979, 980, 7, 116, 2, 2, 980, 981, 7, 99, 2, 2, 981, 982, 7, 111, 2, 2, 982, 983, 7, 117, 2, 2, 983, 154, 3, 2, 2, 2, 984, 985, 7, 114, 2, 2, 985, 986, 7, 99, 2, 2, 986, 987, 7, 116, 2, 2, 987, 988, 7, 118, 2, 2, 988, 989, 7, 107, 2, 2, 989, 990, 7, 99, 2, 2, 990, 991, 7, 110, 2, 2, 991, 156, 3, 2, 2, 2, 992, 993, 7, 114, 2, 2, 993, 994, 7, 116, 2, 2, 994, 995, 7, 107, 2, 2, 995, 996, 7, 120, 2, 2, 996, 997, 7, 99, 2, 2, 997, 998, 7, 118, 2, 2, 998, 999, 7, 103, 2, 2, 999, 158, 3, 2, 2, 2, 1000, 1001, 7, 114, 2, 2, 1001, 1002, 7, 116, 2, 2, 1002, 1003, 7, 113, 2, 2, 1003, 1004, 7, 118, 2, 2, 1004, 1005, 7, 103, 2, 2, 1005, 1006, 7, 101, 2, 2, 1006, 1007, 7, 118, 2, 2, 1007, 1008, 7, 103, 2, 2, 1008, 1009, 7, 102, 2, 2, 1009, 160, 3, 2, 2, 2, 1010, 1011, 7, 114, 2, 2, 1011, 1012, 7, 119, 2, 2, 1012, 1013, 7, 100, 2, 2, 1013, 1014, 7, 110, 2, 2, 1014, 1015, 7, 107, 2, 2, 1015, 1016, 7, 101, 2, 2, 1016, 162, 3, 2, 2, 2, 1017, 1018, 7, 116, 2, 2, 1018, 1019, 7, 103, 2, 2, 1019, 1020, 7, 99, 2, 2, 1020, 1021, 7, 102, 2, 2, 1021, 1022, 7, 113, 2, 2, 1022, 1023, 7, 112, 2, 2, 1023, 1024, 7, 110, 2, 2, 1024, 1025, 7, 123, 2, 2, 1025, 164, 3, 2, 2, 2, 1026, 1027, 7, 116, 2, 2, 1027, 1028, 7, 103, 2, 2, 1028, 1029, 7, 104, 2, 2, 1029, 166, 3, 2, 2, 2, 1030, 1031, 7, 116, 2, 2, 1031, 1032, 7, 103, 2, 2, 1032, 1033, 7, 111, 2, 2, 1033, 1034, 7, 113, 2, 2, 1034, 1035, 7, 120, 2, 2, 1035, 1036, 7, 103, 2, 2, 1036, 168, 3, 2, 2, 2, 1037, 1038, 7, 116, 2, 2, 1038, 1039, 7, 103, 2, 2, 1039, 1040, 7, 118, 2, 2, 1040, 1041, 7, 119, 2, 2, 1041, 1042, 7, 116, 2, 2, 1042, 1043, 7, 112, 2, 2, 1043, 170, 3, 2, 2, 2, 1044, 1045, 7, 117, 2, 2, 1045, 1046, 7, 100, 2, 2, 1046, 1047, 7, 123, 2, 2, 1047, 1048, 7, 118, 2, 2, 1048, 1049, 7, 103, 2, 2, 1049, 172, 3, 2, 2, 2, 1050, 1051, 7, 117, 2, 2, 1051, 1052, 7, 103, 2, 2, 1052, 1053, 7, 99, 2, 2, 1053, 1054, 7, 110, 2, 2, 1054, 1055, 7, 103, 2, 2, 1055, 1056, 7, 102, 2, 2, 1056, 174, 3, 2, 2, 2, 1057, 1058, 7, 117, 2, 2, 1058, 1059, 7, 103, 2, 2, 1059, 1060, 7, 110, 2, 2, 1060, 1061, 7, 103, 2, 2, 1061, 1062, 7, 101, 2, 2, 1062, 1063, 7, 118, 2, 2, 1063, 176, 3, 2, 2, 2, 1064, 1065, 7, 117, 2, 2, 1065, 1066, 7, 103, 2, 2, 1066, 1067, 7, 118, 2, 2, 1067, 178, 3, 2, 2, 2, 1068, 1069, 7, 117, 2, 2, 1069, 1070, 7, 106, 2, 2, 1070, 1071, 7, 113, 2, 2, 1071, 1072, 7, 116, 2, 2, 1072, 1073, 7, 118, 2, 2, 1073, 180, 3, 2, 2, 2, 1074, 1075, 7, 117, 2, 2, 1075, 1076, 7, 107, 2, 2, 1076, 1077, 7, 124, 2, 2, 1077, 1078, 7, 103, 2, 2, 1078, 1079, 7, 113, 2, 2, 1079, 1080, 7, 104, 2, 2, 1080, 182, 3, 2, 2, 2, 1081, 1082, 7, 117, 2, 2, 1082, 1083, 7, 118, 2, 2, 1083, 1084, 7, 99, 2, 2, 1084, 1085, 7, 101, 2, 2, 1085, 1086, 7, 109, 2, 2, 1086, 1087, 7, 99, 2, 2, 1087, 1088, 7, 110, 2, 2, 1088, 1089, 7, 110, 2, 2, 1089, 1090, 7, 113, 2, 2, 1090, 1091, 7, 101, 2, 2, 1091, 184, 3, 2, 2, 2, 1092, 1093, 7, 117, 2, 2, 1093, 1094, 7, 118, 2, 2, 1094, 1095, 7, 99, 2, 2, 1095, 1096, 7, 118, 2, 2, 1096, 1097, 7, 107, 2, 2, 1097, 1098, 7, 101, 2, 2, 1098, 186, 3, 2, 2, 2, 1099, 1100, 7, 117, 2, 2, 1100, 1101, 7, 118, 2, 2, 1101, 1102, 7, 116, 2, 2, 1102, 1103, 7, 107, 2, 2, 1103, 1104, 7, 112, 2, 2, 1104, 1105, 7, 105, 2, 2, 1105, 188, 3, 2, 2, 2, 1106, 1107, 7, 117, 2, 2, 1107, 1108, 7, 118, 2, 2, 1108, 1109, 7, 116, 2, 2, 1109, 1110, 7, 119, 2, 2, 1110, 1111, 7, 101, 2, 2, 1111, 1112, 7, 118, 2, 2, 1112, 190, 3, 2, 2, 2, 1113, 1114, 7, 117, 2, 2, 1114, 1115, 7, 121, 2, 2, 1115, 1116, 7, 107, 2, 2, 1116, 1117, 7, 118, 2, 2, 1117, 1118, 7, 101, 2, 2, 1118, 1119, 7, 106, 2, 2, 1119, 192, 3, 2, 2, 2, 1120, 1121, 7, 118, 2, 2, 1121, 1122, 7, 106, 2, 2, 1122, 1123, 7, 107, 2, 2, 1123, 1124, 7, 117, 2, 2, 1124, 194, 3, 2, 2, 2, 1125, 1126, 7, 118, 2, 2, 1126, 1127, 7, 106, 2, 2, 1127, 1128, 7, 116, 2, 2, 1128, 1129, 7, 113, 2, 2, 1129, 1130, 7, 121, 2, 2, 1130, 196, 3, 2, 2, 2, 1131, 1132, 7, 118, 2, 2, 1132, 1133, 7, 116, 2, 2, 1133, 1134, 7, 119, 2, 2, 1134, 1135, 7, 103, 2, 2, 1135, 198, 3, 2, 2, 2, 1136, 1137, 7, 118, 2, 2, 1137, 1138, 7, 116, 2, 2, 1138, 1139, 7, 123, 2, 2, 1139, 200, 3, 2, 2, 2, 1140, 1141, 7, 118, 2, 2, 1141, 1142, 7, 123, 2, 2, 1142, 1143, 7, 114, 2, 2, 1143, 1144, 7, 103, 2, 2, 1144, 1145, 7, 113, 2, 2, 1145, 1146, 7, 104, 2, 2, 1146, 202, 3, 2, 2, 2, 1147, 1148, 7, 119, 2, 2, 1148, 1149, 7, 107, 2, 2, 1149, 1150, 7, 112, 2, 2, 1150, 1151, 7, 118, 2, 2, 1151, 204, 3, 2, 2, 2, 1152, 1153, 7, 119, 2, 2, 1153, 1154, 7, 110, 2, 2, 1154, 1155, 7, 113, 2, 2, 1155, 1156, 7, 112, 2, 2, 1156, 1157, 7, 105, 2, 2, 1157, 206, 3, 2, 2, 2, 1158, 1159, 7, 119, 2, 2, 1159, 1160, 7, 112, 2, 2, 1160, 1161, 7, 101, 2, 2, 1161, 1162, 7, 106, 2, 2, 1162, 1163, 7, 103, 2, 2, 1163, 1164, 7, 101, 2, 2, 1164, 1165, 7, 109, 2, 2, 1165, 1166, 7, 103, 2, 2, 1166, 1167, 7, 102, 2, 2, 1167, 208, 3, 2, 2, 2, 1168, 1169, 7, 119, 2, 2, 1169, 1170, 7, 112, 2, 2, 1170, 1171, 7, 111, 2, 2, 1171, 1172, 7, 99, 2, 2, 1172, 1173, 7, 112, 2, 2, 1173, 1174, 7, 99, 2, 2, 1174, 1175, 7, 105, 2, 2, 1175, 1176, 7, 103, 2, 2, 1176, 1177, 7, 102, 2, 2, 1177, 210, 3, 2, 2, 2, 1178, 1179, 7, 119, 2, 2, 1179, 1180, 7, 112, 2, 2, 1180, 1181, 7, 117, 2, 2, 1181, 1182, 7, 99, 2, 2, 1182, 1183, 7, 104, 2, 2, 1183, 1184, 7, 103, 2, 2, 1184, 212, 3, 2, 2, 2, 1185, 1186, 7, 119, 2, 2, 1186, 1187, 7, 117, 2, 2, 1187, 1188, 7, 106, 2, 2, 1188, 1189, 7, 113, 2, 2, 1189, 1190, 7, 116, 2, 2, 1190, 1191, 7, 118, 2, 2, 1191, 214, 3, 2, 2, 2, 1192, 1193, 7, 119, 2, 2, 1193, 1194, 7, 117, 2, 2, 1194, 1195, 7, 107, 2, 2, 1195, 1196, 7, 112, 2, 2, 1196, 1197, 7, 105, 2, 2, 1197, 216, 3, 2, 2, 2, 1198, 1199, 7, 120, 2, 2, 1199, 1200, 7, 99, 2, 2, 1200, 1201, 7, 116, 2, 2, 1201, 218, 3, 2, 2, 2, 1202, 1203, 7, 120, 2, 2, 1203, 1204, 7, 107, 2, 2, 1204, 1205, 7, 116, 2, 2, 1205, 1206, 7, 118, 2, 2, 1206, 1207, 7, 119, 2, 2, 1207, 1208, 7, 99, 2, 2, 1208, 1209, 7, 110, 2, 2, 1209, 220, 3, 2, 2, 2, 1210, 1211, 7, 120, 2, 2, 1211, 1212, 7, 113, 2, 2, 1212, 1213, 7, 107, 2, 2, 1213, 1214, 7, 102, 2, 2, 1214, 222, 3, 2, 2, 2, 1215, 1216, 7, 120, 2, 2, 1216, 1217, 7, 113, 2, 2, 1217, 1218, 7, 110, 2, 2, 1218, 1219, 7, 99, 2, 2, 1219, 1220, 7, 118, 2, 2, 1220, 1221, 7, 107, 2, 2, 1221, 1222, 7, 110, 2, 2, 1222, 1223, 7, 103, 2, 2, 1223, 224, 3, 2, 2, 2, 1224, 1225, 7, 121, 2, 2, 1225, 1226, 7, 106, 2, 2, 1226, 1227, 7, 103, 2, 2, 1227, 1228, 7, 112, 2, 2, 1228, 226, 3, 2, 2, 2, 1229, 1230, 7, 121, 2, 2, 1230, 1231, 7, 106, 2, 2, 1231, 1232, 7, 103, 2, 2, 1232, 1233, 7, 116, 2, 2, 1233, 1234, 7, 103, 2, 2, 1234, 228, 3, 2, 2, 2, 1235, 1236, 7, 121, 2, 2, 1236, 1237, 7, 106, 2, 2, 1237, 1238, 7, 107, 2, 2, 1238, 1239, 7, 110, 2, 2, 1239, 1240, 7, 103, 2, 2, 1240, 230, 3, 2, 2, 2, 1241, 1242, 7, 123, 2, 2, 1242, 1243, 7, 107, 2, 2, 1243, 1244, 7, 103, 2, 2, 1244, 1245, 7, 110, 2, 2, 1245, 1246, 7, 102, 2, 2, 1246, 232, 3, 2, 2, 2, 1247, 1249, 7, 66, 2, 2, 1248, 1247, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1251, 5, 453, 225, 2, 1251, 234, 3, 2, 2, 2, 1252, 1262, 9, 3, 2, 2, 1253, 1255, 7, 97, 2, 2, 1254, 1253, 3, 2, 2, 2, 1255, 1258, 3, 2, 2, 2, 1256, 1254, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1259, 3, 2, 2, 2, 1258, 1256, 3, 2, 2, 2, 1259, 1261, 9, 3, 2, 2, 1260, 1256, 3, 2, 2, 2, 1261, 1264, 3, 2, 2, 2, 1262, 1260, 3, 2, 2, 2, 1262, 1263, 3, 2, 2, 2, 1263, 1266, 3, 2, 2, 2, 1264, 1262, 3, 2, 2, 2, 1265, 1267, 5, 437, 217, 2, 1266, 1265, 3, 2, 2, 2, 1266, 1267, 3, 2, 2, 2, 1267, 1268, 3, 2, 2, 2, 1268, 1270, 7, 48, 2, 2, 1269, 1271, 7, 66, 2, 2, 1270, 1269, 3, 2, 2, 2, 1270, 1271, 3, 2, 2, 2, 1271, 1272, 3, 2, 2, 2, 1272, 1273, 5, 453, 225, 2, 1273, 236, 3, 2, 2, 2, 1274, 1284, 9, 3, 2, 2, 1275, 1277, 7, 97, 2, 2, 1276, 1275, 3, 2, 2, 2, 1277, 1280, 3, 2, 2, 2, 1278, 1276, 3, 2, 2, 2, 1278, 1279, 3, 2, 2, 2, 1279, 1281, 3, 2, 2, 2, 1280, 1278, 3, 2, 2, 2, 1281, 1283, 9, 3, 2, 2, 1282, 1278, 3, 2, 2, 2, 1283, 1286, 3, 2, 2, 2, 1284, 1282, 3, 2, 2, 2, 1284, 1285, 3, 2, 2, 2, 1285, 1288, 3, 2, 2, 2, 1286, 1284, 3, 2, 2, 2, 1287, 1289, 5, 437, 217, 2, 1288, 1287, 3, 2, 2, 2, 1288, 1289, 3, 2, 2, 2, 1289, 238, 3, 2, 2, 2, 1290, 1291, 7, 50, 2, 2, 1291, 1299, 9, 4, 2, 2, 1292, 1294, 7, 97, 2, 2, 1293, 1292, 3, 2, 2, 2, 1294, 1297, 3, 2, 2, 2, 1295, 1293, 3, 2, 2, 2, 1295, 1296, 3, 2, 2, 2, 1296, 1298, 3, 2, 2, 2, 1297, 1295, 3, 2, 2, 2, 1298, 1300, 5, 471, 234, 2, 1299, 1295, 3, 2, 2, 2, 1300, 1301, 3, 2, 2, 2, 1301, 1299, 3, 2, 2, 2, 1301, 1302, 3, 2, 2, 2, 1302, 1304, 3, 2, 2, 2, 1303, 1305, 5, 437, 217, 2, 1304, 1303, 3, 2, 2, 2, 1304, 1305, 3, 2, 2, 2, 1305, 240, 3, 2, 2, 2, 1306, 1307, 7, 50, 2, 2, 1307, 1315, 9, 5, 2, 2, 1308, 1310, 7, 97, 2, 2, 1309, 1308, 3, 2, 2, 2, 1310, 1313, 3, 2, 2, 2, 1311, 1309, 3, 2, 2, 2, 1311, 1312, 3, 2, 2, 2, 1312, 1314, 3, 2, 2, 2, 1313, 1311, 3, 2, 2, 2, 1314, 1316, 9, 6, 2, 2, 1315, 1311, 3, 2, 2, 2, 1316, 1317, 3, 2, 2, 2, 1317, 1315, 3, 2, 2, 2, 1317, 1318, 3, 2, 2, 2, 1318, 1320, 3, 2, 2, 2, 1319, 1321, 5, 437, 217, 2, 1320, 1319, 3, 2, 2, 2, 1320, 1321, 3, 2, 2, 2, 1321, 242, 3, 2, 2, 2, 1322, 1332, 9, 3, 2, 2, 1323, 1325, 7, 97, 2, 2, 1324, 1323, 3, 2, 2, 2, 1325, 1328, 3, 2, 2, 2, 1326, 1324, 3, 2, 2, 2, 1326, 1327, 3, 2, 2, 2, 1327, 1329, 3, 2, 2, 2, 1328, 1326, 3, 2, 2, 2, 1329, 1331, 9, 3, 2, 2, 1330, 1326, 3, 2, 2, 2, 1331, 1334, 3, 2, 2, 2, 1332, 1330, 3, 2, 2, 2, 1332, 1333, 3, 2, 2, 2, 1333, 1336, 3, 2, 2, 2, 1334, 1332, 3, 2, 2, 2, 1335, 1322, 3, 2, 2, 2, 1335, 1336, 3, 2, 2, 2, 1336, 1337, 3, 2, 2, 2, 1337, 1338, 7, 48, 2, 2, 1338, 1348, 9, 3, 2, 2, 1339, 1341, 7, 97, 2, 2, 1340, 1339, 3, 2, 2, 2, 1341, 1344, 3, 2, 2, 2, 1342, 1340, 3, 2, 2, 2, 1342, 1343, 3, 2, 2, 2, 1343, 1345, 3, 2, 2, 2, 1344, 1342, 3, 2, 2, 2, 1345, 1347, 9, 3, 2, 2, 1346, 1342, 3, 2, 2, 2, 1347, 1350, 3, 2, 2, 2, 1348, 1346, 3, 2, 2, 2, 1348, 1349, 3, 2, 2, 2, 1349, 1352, 3, 2, 2, 2, 1350, 1348, 3, 2, 2, 2, 1351, 1353, 5, 439, 218, 2, 1352, 1351, 3, 2, 2, 2, 1352, 1353, 3, 2, 2, 2, 1353, 1355, 3, 2, 2, 2, 1354, 1356, 9, 7, 2, 2, 1355, 1354, 3, 2, 2, 2, 1355, 1356, 3, 2, 2, 2, 1356, 1378, 3, 2, 2, 2, 1357, 1367, 9, 3, 2, 2, 1358, 1360, 7, 97, 2, 2, 1359, 1358, 3, 2, 2, 2, 1360, 1363, 3, 2, 2, 2, 1361, 1359, 3, 2, 2, 2, 1361, 1362, 3, 2, 2, 2, 1362, 1364, 3, 2, 2, 2, 1363, 1361, 3, 2, 2, 2, 1364, 1366, 9, 3, 2, 2, 1365, 1361, 3, 2, 2, 2, 1366, 1369, 3, 2, 2, 2, 1367, 1365, 3, 2, 2, 2, 1367, 1368, 3, 2, 2, 2, 1368, 1375, 3, 2, 2, 2, 1369, 1367, 3, 2, 2, 2, 1370, 1376, 9, 7, 2, 2, 1371, 1373, 5, 439, 218, 2, 1372, 1374, 9, 7, 2, 2, 1373, 1372, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1370, 3, 2, 2, 2, 1375, 1371, 3, 2, 2, 2, 1376, 1378, 3, 2, 2, 2, 1377, 1335, 3, 2, 2, 2, 1377, 1357, 3, 2, 2, 2, 1378, 244, 3, 2, 2, 2, 1379, 1382, 7, 41, 2, 2, 1380, 1383, 10, 8, 2, 2, 1381, 1383, 5, 441, 219, 2, 1382, 1380, 3, 2, 2, 2, 1382, 1381, 3, 2, 2, 2, 1383, 1384, 3, 2, 2, 2, 1384, 1385, 7, 41, 2, 2, 1385, 246, 3, 2, 2, 2, 1386, 1391, 7, 36, 2, 2, 1387, 1390, 10, 9, 2, 2, 1388, 1390, 5, 441, 219, 2, 1389, 1387, 3, 2, 2, 2, 1389, 1388, 3, 2, 2, 2, 1390, 1393, 3, 2, 2, 2, 1391, 1389, 3, 2, 2, 2, 1391, 1392, 3, 2, 2, 2, 1392, 1394, 3, 2, 2, 2, 1393, 1391, 3, 2, 2, 2, 1394, 1395, 7, 36, 2, 2, 1395, 248, 3, 2, 2, 2, 1396, 1397, 7, 66, 2, 2, 1397, 1398, 7, 36, 2, 2, 1398, 1404, 3, 2, 2, 2, 1399, 1403, 10, 10, 2, 2, 1400, 1401, 7, 36, 2, 2, 1401, 1403, 7, 36, 2, 2, 1402, 1399, 3, 2, 2, 2, 1402, 1400, 3, 2, 2, 2, 1403, 1406, 3, 2, 2, 2, 1404, 1402, 3, 2, 2, 2, 1404, 1405, 3, 2, 2, 2, 1405, 1407, 3, 2, 2, 2, 1406, 1404, 3, 2, 2, 2, 1407, 1408, 7, 36, 2, 2, 1408, 250, 3, 2, 2, 2, 1409, 1410, 7, 38, 2, 2, 1410, 1411, 7, 36, 2, 2, 1411, 1412, 3, 2, 2, 2, 1412, 1413, 8, 124, 5, 2, 1413, 1414, 3, 2, 2, 2, 1414, 1415, 8, 124, 6, 2, 1415, 252, 3, 2, 2, 2, 1416, 1417, 7, 38, 2, 2, 1417, 1418, 7, 66, 2, 2, 1418, 1419, 7, 36, 2, 2, 1419, 1420, 3, 2, 2, 2, 1420, 1421, 8, 125, 7, 2, 1421, 1422, 3, 2, 2, 2, 1422, 1423, 8, 125, 6, 2, 1423, 254, 3, 2, 2, 2, 1424, 1425, 7, 125, 2, 2, 1425, 1426, 8, 126, 8, 2, 1426, 256, 3, 2, 2, 2, 1427, 1428, 7, 127, 2, 2, 1428, 1429, 8, 127, 9, 2, 1429, 258, 3, 2, 2, 2, 1430, 1431, 7, 93, 2, 2, 1431, 260, 3, 2, 2, 2, 1432, 1433, 7, 95, 2, 2, 1433, 262, 3, 2, 2, 2, 1434, 1435, 7, 42, 2, 2, 1435, 264, 3, 2, 2, 2, 1436, 1437, 7, 43, 2, 2, 1437, 266, 3, 2, 2, 2, 1438, 1439, 7, 48, 2, 2, 1439, 268, 3, 2, 2, 2, 1440, 1441, 7, 46, 2, 2, 1441, 270, 3, 2, 2, 2, 1442, 1443, 7, 60, 2, 2, 1443, 1444, 8, 134, 10, 2, 1444, 272, 3, 2, 2, 2, 1445, 1446, 7, 61, 2, 2, 1446, 274, 3, 2, 2, 2, 1447, 1448, 7, 45, 2, 2, 1448, 276, 3, 2, 2, 2, 1449, 1450, 7, 47, 2, 2, 1450, 278, 3, 2, 2, 2, 1451, 1452, 7, 44, 2, 2, 1452, 280, 3, 2, 2, 2, 1453, 1454, 7, 49, 2, 2, 1454, 282, 3, 2, 2, 2, 1455, 1456, 7, 39, 2, 2, 1456, 284, 3, 2, 2, 2, 1457, 1458, 7, 40, 2, 2, 1458, 286, 3, 2, 2, 2, 1459, 1460, 7, 126, 2, 2, 1460, 288, 3, 2, 2, 2, 1461, 1462, 7, 96, 2, 2, 1462, 290, 3, 2, 2, 2, 1463, 1464, 7, 35, 2, 2, 1464, 292, 3, 2, 2, 2, 1465, 1466, 7, 128, 2, 2, 1466, 294, 3, 2, 2, 2, 1467, 1468, 7, 63, 2, 2, 1468, 296, 3, 2, 2, 2, 1469, 1470, 7, 62, 2, 2, 1470, 298, 3, 2, 2, 2, 1471, 1472, 7, 64, 2, 2, 1472, 300, 3, 2, 2, 2, 1473, 1474, 7, 65, 2, 2, 1474, 302, 3, 2, 2, 2, 1475, 1476, 7, 60, 2, 2, 1476, 1477, 7, 60, 2, 2, 1477, 304, 3, 2, 2, 2, 1478, 1479, 7, 65, 2, 2, 1479, 1480, 7, 65, 2, 2, 1480, 306, 3, 2, 2, 2, 1481, 1482, 7, 45, 2, 2, 1482, 1483, 7, 45, 2, 2, 1483, 308, 3, 2, 2, 2, 1484, 1485, 7, 47, 2, 2, 1485, 1486, 7, 47, 2, 2, 1486, 310, 3, 2, 2, 2, 1487, 1488, 7, 40, 2, 2, 1488, 1489, 7, 40, 2, 2, 1489, 312, 3, 2, 2, 2, 1490, 1491, 7, 126, 2, 2, 1491, 1492, 7, 126, 2, 2, 1492, 314, 3, 2, 2, 2, 1493, 1494, 7, 47, 2, 2, 1494, 1495, 7, 64, 2, 2, 1495, 316, 3, 2, 2, 2, 1496, 1497, 7, 63, 2, 2, 1497, 1498, 7, 63, 2, 2, 1498, 318, 3, 2, 2, 2, 1499, 1500, 7, 35, 2, 2, 1500, 1501, 7, 63, 2, 2, 1501, 320, 3, 2, 2, 2, 1502, 1503, 7, 62, 2, 2, 1503, 1504, 7, 63, 2, 2, 1504, 322, 3, 2, 2, 2, 1505, 1506, 7, 64, 2, 2, 1506, 1507, 7, 63, 2, 2, 1507, 324, 3, 2, 2, 2, 1508, 1509, 7, 45, 2, 2, 1509, 1510, 7, 63, 2, 2, 1510, 326, 3, 2, 2, 2, 1511, 1512, 7, 47, 2, 2, 1512, 1513, 7, 63, 2, 2, 1513, 328, 3, 2, 2, 2, 1514, 1515, 7, 44, 2, 2, 1515, 1516, 7, 63, 2, 2, 1516, 330, 3, 2, 2, 2, 1517, 1518, 7, 49, 2, 2, 1518, 1519, 7, 63, 2, 2, 1519, 332, 3, 2, 2, 2, 1520, 1521, 7, 39, 2, 2, 1521, 1522, 7, 63, 2, 2, 1522, 334, 3, 2, 2, 2, 1523, 1524, 7, 40, 2, 2, 1524, 1525, 7, 63, 2, 2, 1525, 336, 3, 2, 2, 2, 1526, 1527, 7, 126, 2, 2, 1527, 1528, 7, 63, 2, 2, 1528, 338, 3, 2, 2, 2, 1529, 1530, 7, 96, 2, 2, 1530, 1531, 7, 63, 2, 2, 1531, 340, 3, 2, 2, 2, 1532, 1533, 7, 62, 2, 2, 1533, 1534, 7, 62, 2, 2, 1534, 342, 3, 2, 2, 2, 1535, 1536, 7, 62, 2, 2, 1536, 1537, 7, 62, 2, 2, 1537, 1538, 7, 63, 2, 2, 1538, 344, 3, 2, 2, 2, 1539, 1540, 7, 65, 2, 2, 1540, 1541, 7, 65, 2, 2, 1541, 1542, 7, 63, 2, 2, 1542, 346, 3, 2, 2, 2, 1543, 1544, 7, 48, 2, 2, 1544, 1545, 7, 48, 2, 2, 1545, 348, 3, 2, 2, 2, 1546, 1547, 7, 125, 2, 2, 1547, 1548, 7, 125, 2, 2, 1548, 350, 3, 2, 2, 2, 1549, 1550, 7, 125, 2, 2, 1550, 1551, 8, 174, 11, 2, 1551, 1552, 3, 2, 2, 2, 1552, 1553, 8, 174, 12, 2, 1553, 1554, 8, 174, 13, 2, 1554, 352, 3, 2, 2, 2, 1555, 1556, 6, 175, 2, 2, 1556, 1557, 5, 443, 220, 2, 1557, 354, 3, 2, 2, 2, 1558, 1559, 6, 176, 3, 2, 1559, 1560, 7, 36, 2, 2, 1560, 1561, 7, 36, 2, 2, 1561, 356, 3, 2, 2, 2, 1562, 1563, 7, 36, 2, 2, 1563, 1564, 8, 177, 14, 2, 1564, 1565, 3, 2, 2, 2, 1565, 1566, 8, 177, 15, 2, 1566, 358, 3, 2, 2, 2, 1567, 1569, 6, 178, 4, 2, 1568, 1570, 10, 11, 2, 2, 1569, 1568, 3, 2, 2, 2, 1570, 1571, 3, 2, 2, 2, 1571, 1569, 3, 2, 2, 2, 1571, 1572, 3, 2, 2, 2, 1572, 360, 3, 2, 2, 2, 1573, 1575, 6, 179, 5, 2, 1574, 1576, 10, 12, 2, 2, 1575, 1574, 3, 2, 2, 2, 1576, 1577, 3, 2, 2, 2, 1577, 1575, 3, 2, 2, 2, 1577, 1578, 3, 2, 2, 2, 1578, 362, 3, 2, 2, 2, 1579, 1580, 7, 127, 2, 2, 1580, 1581, 7, 127, 2, 2, 1581, 1582, 3, 2, 2, 2, 1582, 1583, 8, 180, 16, 2, 1583, 364, 3, 2, 2, 2, 1584, 1585, 7, 127, 2, 2, 1585, 1586, 8, 181, 17, 2, 1586, 1587, 3, 2, 2, 2, 1587, 1588, 8, 181, 12, 2, 1588, 1589, 8, 181, 15, 2, 1589, 366, 3, 2, 2, 2, 1590, 1592, 10, 13, 2, 2, 1591, 1590, 3, 2, 2, 2, 1592, 1593, 3, 2, 2, 2, 1593, 1591, 3, 2, 2, 2, 1593, 1594, 3, 2, 2, 2, 1594, 368, 3, 2, 2, 2, 1595, 1597, 5, 449, 223, 2, 1596, 1595, 3, 2, 2, 2, 1597, 1598, 3, 2, 2, 2, 1598, 1596, 3, 2, 2, 2, 1598, 1599, 3, 2, 2, 2, 1599, 1600, 3, 2, 2, 2, 1600, 1601, 8, 183, 3, 2, 1601, 370, 3, 2, 2, 2, 1602, 1604, 9, 3, 2, 2, 1603, 1602, 3, 2, 2, 2, 1604, 1605, 3, 2, 2, 2, 1605, 1603, 3, 2, 2, 2, 1605, 1606, 3, 2, 2, 2, 1606, 1607, 3, 2, 2, 2, 1607, 1608, 8, 184, 18, 2, 1608, 372, 3, 2, 2, 2, 1609, 1610, 7, 118, 2, 2, 1610, 1611, 7, 116, 2, 2, 1611, 1612, 7, 119, 2, 2, 1612, 1613, 7, 103, 2, 2, 1613, 1614, 3, 2, 2, 2, 1614, 1615, 8, 185, 18, 2, 1615, 1616, 8, 185, 19, 2, 1616, 374, 3, 2, 2, 2, 1617, 1618, 7, 104, 2, 2, 1618, 1619, 7, 99, 2, 2, 1619, 1620, 7, 110, 2, 2, 1620, 1621, 7, 117, 2, 2, 1621, 1622, 7, 103, 2, 2, 1622, 1623, 3, 2, 2, 2, 1623, 1624, 8, 186, 18, 2, 1624, 1625, 8, 186, 20, 2, 1625, 376, 3, 2, 2, 2, 1626, 1627, 7, 102, 2, 2, 1627, 1628, 7, 103, 2, 2, 1628, 1629, 7, 104, 2, 2, 1629, 1630, 7, 107, 2, 2, 1630, 1631, 7, 112, 2, 2, 1631, 1632, 7, 103, 2, 2, 1632, 1633, 3, 2, 2, 2, 1633, 1634, 8, 187, 18, 2, 1634, 378, 3, 2, 2, 2, 1635, 1636, 7, 119, 2, 2, 1636, 1637, 7, 112, 2, 2, 1637, 1638, 7, 102, 2, 2, 1638, 1639, 7, 103, 2, 2, 1639, 1640, 7, 104, 2, 2, 1640, 1641, 3, 2, 2, 2, 1641, 1642, 8, 188, 18, 2, 1642, 380, 3, 2, 2, 2, 1643, 1644, 7, 107, 2, 2, 1644, 1645, 7, 104, 2, 2, 1645, 1646, 3, 2, 2, 2, 1646, 1647, 8, 189, 18, 2, 1647, 1648, 8, 189, 21, 2, 1648, 382, 3, 2, 2, 2, 1649, 1650, 7, 103, 2, 2, 1650, 1651, 7, 110, 2, 2, 1651, 1652, 7, 107, 2, 2, 1652, 1653, 7, 104, 2, 2, 1653, 1654, 3, 2, 2, 2, 1654, 1655, 8, 190, 18, 2, 1655, 384, 3, 2, 2, 2, 1656, 1657, 7, 103, 2, 2, 1657, 1658, 7, 110, 2, 2, 1658, 1659, 7, 117, 2, 2, 1659, 1660, 7, 103, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1662, 8, 191, 18, 2, 1662, 1663, 8, 191, 22, 2, 1663, 386, 3, 2, 2, 2, 1664, 1665, 7, 103, 2, 2, 1665, 1666, 7, 112, 2, 2, 1666, 1667, 7, 102, 2, 2, 1667, 1668, 7, 107, 2, 2, 1668, 1669, 7, 104, 2, 2, 1669, 1670, 3, 2, 2, 2, 1670, 1671, 8, 192, 18, 2, 1671, 388, 3, 2, 2, 2, 1672, 1673, 7, 110, 2, 2, 1673, 1674, 7, 107, 2, 2, 1674, 1675, 7, 112, 2, 2, 1675, 1676, 7, 103, 2, 2, 1676, 1677, 3, 2, 2, 2, 1677, 1678, 8, 193, 18, 2, 1678, 390, 3, 2, 2, 2, 1679, 1680, 7, 103, 2, 2, 1680, 1681, 7, 116, 2, 2, 1681, 1682, 7, 116, 2, 2, 1682, 1683, 7, 113, 2, 2, 1683, 1684, 7, 116, 2, 2, 1684, 1686, 3, 2, 2, 2, 1685, 1687, 5, 449, 223, 2, 1686, 1685, 3, 2, 2, 2, 1687, 1688, 3, 2, 2, 2, 1688, 1686, 3, 2, 2, 2, 1688, 1689, 3, 2, 2, 2, 1689, 1690, 3, 2, 2, 2, 1690, 1691, 8, 194, 18, 2, 1691, 1692, 8, 194, 23, 2, 1692, 392, 3, 2, 2, 2, 1693, 1694, 7, 121, 2, 2, 1694, 1695, 7, 99, 2, 2, 1695, 1696, 7, 116, 2, 2, 1696, 1697, 7, 112, 2, 2, 1697, 1698, 7, 107, 2, 2, 1698, 1699, 7, 112, 2, 2, 1699, 1700, 7, 105, 2, 2, 1700, 1702, 3, 2, 2, 2, 1701, 1703, 5, 449, 223, 2, 1702, 1701, 3, 2, 2, 2, 1703, 1704, 3, 2, 2, 2, 1704, 1702, 3, 2, 2, 2, 1704, 1705, 3, 2, 2, 2, 1705, 1706, 3, 2, 2, 2, 1706, 1707, 8, 195, 18, 2, 1707, 1708, 8, 195, 23, 2, 1708, 394, 3, 2, 2, 2, 1709, 1710, 7, 116, 2, 2, 1710, 1711, 7, 103, 2, 2, 1711, 1712, 7, 105, 2, 2, 1712, 1713, 7, 107, 2, 2, 1713, 1714, 7, 113, 2, 2, 1714, 1715, 7, 112, 2, 2, 1715, 1719, 3, 2, 2, 2, 1716, 1718, 5, 449, 223, 2, 1717, 1716, 3, 2, 2, 2, 1718, 1721, 3, 2, 2, 2, 1719, 1717, 3, 2, 2, 2, 1719, 1720, 3, 2, 2, 2, 1720, 1722, 3, 2, 2, 2, 1721, 1719, 3, 2, 2, 2, 1722, 1723, 8, 196, 18, 2, 1723, 1724, 8, 196, 23, 2, 1724, 396, 3, 2, 2, 2, 1725, 1726, 7, 103, 2, 2, 1726, 1727, 7, 112, 2, 2, 1727, 1728, 7, 102, 2, 2, 1728, 1729, 7, 116, 2, 2, 1729, 1730, 7, 103, 2, 2, 1730, 1731, 7, 105, 2, 2, 1731, 1732, 7, 107, 2, 2, 1732, 1733, 7, 113, 2, 2, 1733, 1734, 7, 112, 2, 2, 1734, 1738, 3, 2, 2, 2, 1735, 1737, 5, 449, 223, 2, 1736, 1735, 3, 2, 2, 2, 1737, 1740, 3, 2, 2, 2, 1738, 1736, 3, 2, 2, 2, 1738, 1739, 3, 2, 2, 2, 1739, 1741, 3, 2, 2, 2, 1740, 1738, 3, 2, 2, 2, 1741, 1742, 8, 197, 18, 2, 1742, 1743, 8, 197, 23, 2, 1743, 398, 3, 2, 2, 2, 1744, 1745, 7, 114, 2, 2, 1745, 1746, 7, 116, 2, 2, 1746, 1747, 7, 99, 2, 2, 1747, 1748, 7, 105, 2, 2, 1748, 1749, 7, 111, 2, 2, 1749, 1750, 7, 99, 2, 2, 1750, 1752, 3, 2, 2, 2, 1751, 1753, 5, 449, 223, 2, 1752, 1751, 3, 2, 2, 2, 1753, 1754, 3, 2, 2, 2, 1754, 1752, 3, 2, 2, 2, 1754, 1755, 3, 2, 2, 2, 1755, 1756, 3, 2, 2, 2, 1756, 1757, 8, 198, 18, 2, 1757, 1758, 8, 198, 23, 2, 1758, 400, 3, 2, 2, 2, 1759, 1760, 7, 112, 2, 2, 1760, 1761, 7, 119, 2, 2, 1761, 1762, 7, 110, 2, 2, 1762, 1763, 7, 110, 2, 2, 1763, 1764, 7, 99, 2, 2, 1764, 1765, 7, 100, 2, 2, 1765, 1766, 7, 110, 2, 2, 1766, 1767, 7, 103, 2, 2, 1767, 1769, 3, 2, 2, 2, 1768, 1770, 5, 449, 223, 2, 1769, 1768, 3, 2, 2, 2, 1770, 1771, 3, 2, 2, 2, 1771, 1769, 3, 2, 2, 2, 1771, 1772, 3, 2, 2, 2, 1772, 1773, 3, 2, 2, 2, 1773, 1774, 8, 199, 18, 2, 1774, 1775, 8, 199, 23, 2, 1775, 402, 3, 2, 2, 2, 1776, 1777, 7, 102, 2, 2, 1777, 1778, 7, 103, 2, 2, 1778, 1779, 7, 104, 2, 2, 1779, 1780, 7, 99, 2, 2, 1780, 1781, 7, 119, 2, 2, 1781, 1782, 7, 110, 2, 2, 1782, 1783, 7, 118, 2, 2, 1783, 1784, 3, 2, 2, 2, 1784, 1785, 8, 200, 18, 2, 1785, 1786, 8, 200, 24, 2, 1786, 404, 3, 2, 2, 2, 1787, 1788, 7, 106, 2, 2, 1788, 1789, 7, 107, 2, 2, 1789, 1790, 7, 102, 2, 2, 1790, 1791, 7, 102, 2, 2, 1791, 1792, 7, 103, 2, 2, 1792, 1793, 7, 112, 2, 2, 1793, 1794, 3, 2, 2, 2, 1794, 1795, 8, 201, 18, 2, 1795, 406, 3, 2, 2, 2, 1796, 1797, 7, 42, 2, 2, 1797, 1798, 3, 2, 2, 2, 1798, 1799, 8, 202, 18, 2, 1799, 1800, 8, 202, 25, 2, 1800, 408, 3, 2, 2, 2, 1801, 1802, 7, 43, 2, 2, 1802, 1803, 3, 2, 2, 2, 1803, 1804, 8, 203, 18, 2, 1804, 1805, 8, 203, 26, 2, 1805, 410, 3, 2, 2, 2, 1806, 1807, 7, 35, 2, 2, 1807, 1808, 3, 2, 2, 2, 1808, 1809, 8, 204, 18, 2, 1809, 1810, 8, 204, 27, 2, 1810, 412, 3, 2, 2, 2, 1811, 1812, 7, 63, 2, 2, 1812, 1813, 7, 63, 2, 2, 1813, 1814, 3, 2, 2, 2, 1814, 1815, 8, 205, 18, 2, 1815, 1816, 8, 205, 28, 2, 1816, 414, 3, 2, 2, 2, 1817, 1818, 7, 35, 2, 2, 1818, 1819, 7, 63, 2, 2, 1819, 1820, 3, 2, 2, 2, 1820, 1821, 8, 206, 18, 2, 1821, 1822, 8, 206, 29, 2, 1822, 416, 3, 2, 2, 2, 1823, 1824, 7, 40, 2, 2, 1824, 1825, 7, 40, 2, 2, 1825, 1826, 3, 2, 2, 2, 1826, 1827, 8, 207, 18, 2, 1827, 1828, 8, 207, 30, 2, 1828, 418, 3, 2, 2, 2, 1829, 1830, 7, 126, 2, 2, 1830, 1831, 7, 126, 2, 2, 1831, 1832, 3, 2, 2, 2, 1832, 1833, 8, 208, 18, 2, 1833, 1834, 8, 208, 31, 2, 1834, 420, 3, 2, 2, 2, 1835, 1839, 7, 36, 2, 2, 1836, 1838, 10, 14, 2, 2, 1837, 1836, 3, 2, 2, 2, 1838, 1841, 3, 2, 2, 2, 1839, 1837, 3, 2, 2, 2, 1839, 1840, 3, 2, 2, 2, 1840, 1842, 3, 2, 2, 2, 1841, 1839, 3, 2, 2, 2, 1842, 1843, 7, 36, 2, 2, 1843, 1844, 3, 2, 2, 2, 1844, 1845, 8, 209, 18, 2, 1845, 1846, 8, 209, 32, 2, 1846, 422, 3, 2, 2, 2, 1847, 1848, 5, 453, 225, 2, 1848, 1849, 3, 2, 2, 2, 1849, 1850, 8, 210, 18, 2, 1850, 424, 3, 2, 2, 2, 1851, 1852, 7, 49, 2, 2, 1852, 1853, 7, 49, 2, 2, 1853, 1857, 3, 2, 2, 2, 1854, 1856, 10, 15, 2, 2, 1855, 1854, 3, 2, 2, 2, 1856, 1859, 3, 2, 2, 2, 1857, 1855, 3, 2, 2, 2, 1857, 1858, 3, 2, 2, 2, 1858, 1860, 3, 2, 2, 2, 1859, 1857, 3, 2, 2, 2, 1860, 1861, 8, 211, 2, 2, 1861, 1862, 8, 211, 33, 2, 1862, 426, 3, 2, 2, 2, 1863, 1864, 5, 447, 222, 2, 1864, 1865, 3, 2, 2, 2, 1865, 1866, 8, 212, 18, 2, 1866, 1867, 8, 212, 34, 2, 1867, 428, 3, 2, 2, 2, 1868, 1870, 10, 15, 2, 2, 1869, 1868, 3, 2, 2, 2, 1870, 1871, 3, 2, 2, 2, 1871, 1869, 3, 2, 2, 2, 1871, 1872, 3, 2, 2, 2, 1872, 1873, 3, 2, 2, 2, 1873, 1874, 8, 213, 18, 2, 1874, 430, 3, 2, 2, 2, 1875, 1876, 5, 447, 222, 2, 1876, 1877, 3, 2, 2, 2, 1877, 1878, 8, 214, 18, 2, 1878, 1879, 8, 214, 35, 2, 1879, 1880, 8, 214, 34, 2, 1880, 432, 3, 2, 2, 2, 1881, 1882, 10, 15, 2, 2, 1882, 434, 3, 2, 2, 2, 1883, 1884, 9, 15, 2, 2, 1884, 436, 3, 2, 2, 2, 1885, 1887, 9, 16, 2, 2, 1886, 1885, 3, 2, 2, 2, 1886, 1887, 3, 2, 2, 2, 1887, 1888, 3, 2, 2, 2, 1888, 1894, 9, 17, 2, 2, 1889, 1891, 9, 17, 2, 2, 1890, 1889, 3, 2, 2, 2, 1890, 1891, 3, 2, 2, 2, 1891, 1892, 3, 2, 2, 2, 1892, 1894, 9, 16, 2, 2, 1893, 1886, 3, 2, 2, 2, 1893, 1890, 3, 2, 2, 2, 1894, 438, 3, 2, 2, 2, 1895, 1897, 9, 18, 2, 2, 1896, 1898, 9, 19, 2, 2, 1897, 1896, 3, 2, 2, 2, 1897, 1898, 3, 2, 2, 2, 1898, 1899, 3, 2, 2, 2, 1899, 1909, 9, 3, 2, 2, 1900, 1902, 7, 97, 2, 2, 1901, 1900, 3, 2, 2, 2, 1902, 1905, 3, 2, 2, 2, 1903, 1901, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1906, 3, 2, 2, 2, 1905, 1903, 3, 2, 2, 2, 1906, 1908, 9, 3, 2, 2, 1907, 1903, 3, 2, 2, 2, 1908, 1911, 3, 2, 2, 2, 1909, 1907, 3, 2, 2, 2, 1909, 1910, 3, 2, 2, 2, 1910, 440, 3, 2, 2, 2, 1911, 1909, 3, 2, 2, 2, 1912, 1916, 5, 443, 220, 2, 1913, 1916, 5, 445, 221, 2, 1914, 1916, 5, 469, 233, 2, 1915, 1912, 3, 2, 2, 2, 1915, 1913, 3, 2, 2, 2, 1915, 1914, 3, 2, 2, 2, 1916, 442, 3, 2, 2, 2, 1917, 1918, 7, 94, 2, 2, 1918, 1940, 7, 41, 2, 2, 1919, 1920, 7, 94, 2, 2, 1920, 1940, 7, 36, 2, 2, 1921, 1922, 7, 94, 2, 2, 1922, 1940, 7, 94, 2, 2, 1923, 1924, 7, 94, 2, 2, 1924, 1940, 7, 50, 2, 2, 1925, 1926, 7, 94, 2, 2, 1926, 1940, 7, 99, 2, 2, 1927, 1928, 7, 94, 2, 2, 1928, 1940, 7, 100, 2, 2, 1929, 1930, 7, 94, 2, 2, 1930, 1940, 7, 104, 2, 2, 1931, 1932, 7, 94, 2, 2, 1932, 1940, 7, 112, 2, 2, 1933, 1934, 7, 94, 2, 2, 1934, 1940, 7, 116, 2, 2, 1935, 1936, 7, 94, 2, 2, 1936, 1940, 7, 118, 2, 2, 1937, 1938, 7, 94, 2, 2, 1938, 1940, 7, 120, 2, 2, 1939, 1917, 3, 2, 2, 2, 1939, 1919, 3, 2, 2, 2, 1939, 1921, 3, 2, 2, 2, 1939, 1923, 3, 2, 2, 2, 1939, 1925, 3, 2, 2, 2, 1939, 1927, 3, 2, 2, 2, 1939, 1929, 3, 2, 2, 2, 1939, 1931, 3, 2, 2, 2, 1939, 1933, 3, 2, 2, 2, 1939, 1935, 3, 2, 2, 2, 1939, 1937, 3, 2, 2, 2, 1940, 444, 3, 2, 2, 2, 1941, 1942, 7, 94, 2, 2, 1942, 1943, 7, 122, 2, 2, 1943, 1944, 3, 2, 2, 2, 1944, 1967, 5, 471, 234, 2, 1945, 1946, 7, 94, 2, 2, 1946, 1947, 7, 122, 2, 2, 1947, 1948, 3, 2, 2, 2, 1948, 1949, 5, 471, 234, 2, 1949, 1950, 5, 471, 234, 2, 1950, 1967, 3, 2, 2, 2, 1951, 1952, 7, 94, 2, 2, 1952, 1953, 7, 122, 2, 2, 1953, 1954, 3, 2, 2, 2, 1954, 1955, 5, 471, 234, 2, 1955, 1956, 5, 471, 234, 2, 1956, 1957, 5, 471, 234, 2, 1957, 1967, 3, 2, 2, 2, 1958, 1959, 7, 94, 2, 2, 1959, 1960, 7, 122, 2, 2, 1960, 1961, 3, 2, 2, 2, 1961, 1962, 5, 471, 234, 2, 1962, 1963, 5, 471, 234, 2, 1963, 1964, 5, 471, 234, 2, 1964, 1965, 5, 471, 234, 2, 1965, 1967, 3, 2, 2, 2, 1966, 1941, 3, 2, 2, 2, 1966, 1945, 3, 2, 2, 2, 1966, 1951, 3, 2, 2, 2, 1966, 1958, 3, 2, 2, 2, 1967, 446, 3, 2, 2, 2, 1968, 1969, 7, 15, 2, 2, 1969, 1972, 7, 12, 2, 2, 1970, 1972, 9, 15, 2, 2, 1971, 1968, 3, 2, 2, 2, 1971, 1970, 3, 2, 2, 2, 1972, 448, 3, 2, 2, 2, 1973, 1976, 5, 451, 224, 2, 1974, 1976, 9, 20, 2, 2, 1975, 1973, 3, 2, 2, 2, 1975, 1974, 3, 2, 2, 2, 1976, 450, 3, 2, 2, 2, 1977, 1978, 9, 21, 2, 2, 1978, 452, 3, 2, 2, 2, 1979, 1983, 5, 455, 226, 2, 1980, 1982, 5, 457, 227, 2, 1981, 1980, 3, 2, 2, 2, 1982, 1985, 3, 2, 2, 2, 1983, 1981, 3, 2, 2, 2, 1983, 1984, 3, 2, 2, 2, 1984, 454, 3, 2, 2, 2, 1985, 1983, 3, 2, 2, 2, 1986, 1989, 5, 459, 228, 2, 1987, 1989, 7, 97, 2, 2, 1988, 1986, 3, 2, 2, 2, 1988, 1987, 3, 2, 2, 2, 1989, 456, 3, 2, 2, 2, 1990, 1996, 5, 459, 228, 2, 1991, 1996, 5, 461, 229, 2, 1992, 1996, 5, 463, 230, 2, 1993, 1996, 5, 465, 231, 2, 1994, 1996, 5, 467, 232, 2, 1995, 1990, 3, 2, 2, 2, 1995, 1991, 3, 2, 2, 2, 1995, 1992, 3, 2, 2, 2, 1995, 1993, 3, 2, 2, 2, 1995, 1994, 3, 2, 2, 2, 1996, 458, 3, 2, 2, 2, 1997, 2005, 5, 473, 235, 2, 1998, 2005, 5, 475, 236, 2, 1999, 2005, 5, 477, 237, 2, 2000, 2005, 5, 479, 238, 2, 2001, 2005, 5, 481, 239, 2, 2002, 2005, 5, 483, 240, 2, 2003, 2005, 5, 469, 233, 2, 2004, 1997, 3, 2, 2, 2, 2004, 1998, 3, 2, 2, 2, 2004, 1999, 3, 2, 2, 2, 2004, 2000, 3, 2, 2, 2, 2004, 2001, 3, 2, 2, 2, 2004, 2002, 3, 2, 2, 2, 2004, 2003, 3, 2, 2, 2, 2005, 460, 3, 2, 2, 2, 2006, 2009, 5, 493, 245, 2, 2007, 2009, 5, 469, 233, 2, 2008, 2006, 3, 2, 2, 2, 2008, 2007, 3, 2, 2, 2, 2009, 462, 3, 2, 2, 2, 2010, 2013, 5, 491, 244, 2, 2011, 2013, 5, 469, 233, 2, 2012, 2010, 3, 2, 2, 2, 2012, 2011, 3, 2, 2, 2, 2013, 464, 3, 2, 2, 2, 2014, 2018, 5, 485, 241, 2, 2015, 2018, 5, 487, 242, 2, 2016, 2018, 5, 469, 233, 2, 2017, 2014, 3, 2, 2, 2, 2017, 2015, 3, 2, 2, 2, 2017, 2016, 3, 2, 2, 2, 2018, 466, 3, 2, 2, 2, 2019, 2022, 5, 489, 243, 2, 2020, 2022, 5, 469, 233, 2, 2021, 2019, 3, 2, 2, 2, 2021, 2020, 3, 2, 2, 2, 2022, 468, 3, 2, 2, 2, 2023, 2024, 7, 94, 2, 2, 2024, 2025, 7, 119, 2, 2, 2025, 2026, 3, 2, 2, 2, 2026, 2027, 5, 471, 234, 2, 2027, 2028, 5, 471, 234, 2, 2028, 2029, 5, 471, 234, 2, 2029, 2030, 5, 471, 234, 2, 2030, 2044, 3, 2, 2, 2, 2031, 2032, 7, 94, 2, 2, 2032, 2033, 7, 87, 2, 2, 2033, 2034, 3, 2, 2, 2, 2034, 2035, 5, 471, 234, 2, 2035, 2036, 5, 471, 234, 2, 2036, 2037, 5, 471, 234, 2, 2037, 2038, 5, 471, 234, 2, 2038, 2039, 5, 471, 234, 2, 2039, 2040, 5, 471, 234, 2, 2040, 2041, 5, 471, 234, 2, 2041, 2042, 5, 471, 234, 2, 2042, 2044, 3, 2, 2, 2, 2043, 2023, 3, 2, 2, 2, 2043, 2031, 3, 2, 2, 2, 2044, 470, 3, 2, 2, 2, 2045, 2047, 9, 22, 2, 2, 2046, 2045, 3, 2, 2, 2, 2047, 472, 3, 2, 2, 2, 2048, 2049, 9, 23, 2, 2, 2049, 474, 3, 2, 2, 2, 2050, 2051, 9, 24, 2, 2, 2051, 476, 3, 2, 2, 2, 2052, 2053, 9, 25, 2, 2, 2053, 478, 3, 2, 2, 2, 2054, 2055, 9, 26, 2, 2, 2055, 480, 3, 2, 2, 2, 2056, 2057, 9, 27, 2, 2, 2057, 482, 3, 2, 2, 2, 2058, 2059, 9, 28, 2, 2, 2059, 484, 3, 2, 2, 2, 2060, 2061, 4, 770, 786, 2, 2061, 486, 3, 2, 2, 2, 2062, 2063, 9, 29, 2, 2, 2063, 488, 3, 2, 2, 2, 2064, 2065, 9, 30, 2, 2, 2065, 490, 3, 2, 2, 2, 2066, 2067, 9, 31, 2, 2, 2067, 492, 3, 2, 2, 2, 2068, 2069, 9, 32, 2, 2, 2069, 494, 3, 2, 2, 2, 79, 2, 3, 4, 5, 6, 506, 527, 541, 552, 562, 564, 1248, 1256, 1262, 1266, 1270, 1278, 1284, 1288, 1295, 1301, 1304, 1311, 1317, 1320, 1326, 1332, 1335, 1342, 1348, 1352, 1355, 1361, 1367, 1373, 1375, 1377, 1382, 1389, 1391, 1402, 1404, 1571, 1577, 1593, 1598, 1605, 1688, 1704, 1719, 1738, 1754, 1771, 1839, 1857, 1871, 1886, 1890, 1893, 1897, 1903, 1909, 1915, 1939, 1966, 1971, 1975, 1983, 1988, 1995, 2004, 2008, 2012, 2017, 2021, 2043, 2046, 36, 2, 4, 2, 2, 3, 2, 4, 5, 2, 3, 124, 2, 7, 3, 2, 3, 125, 3, 3, 126, 4, 3, 127, 5, 3, 134, 6, 3, 174, 7, 8, 2, 2, 7, 2, 2, 3, 177, 8, 6, 2, 2, 9, 182, 2, 3, 181, 9, 2, 5, 2, 9, 98, 2, 9, 44, 2, 9, 54, 2, 9, 38, 2, 4, 6, 2, 9, 32, 2, 9, 131, 2, 9, 132, 2, 9, 145, 2, 9, 158, 2, 9, 159, 2, 9, 155, 2, 9, 156, 2, 9, 93, 2, 9, 7, 2, 4, 2, 2, 9, 198, 2] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.java deleted file mode 100644 index 06ab0b6..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpLexer.java +++ /dev/null @@ -1,1332 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.cs;// Generated from CSharpLexer.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.LexerATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; - -import java.util.Stack; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class CSharpLexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - BYTE_ORDER_MARK = 1, SINGLE_LINE_DOC_COMMENT = 2, EMPTY_DELIMITED_DOC_COMMENT = 3, - DELIMITED_DOC_COMMENT = 4, SINGLE_LINE_COMMENT = 5, DELIMITED_COMMENT = 6, WHITESPACES = 7, - SHARP = 8, ABSTRACT = 9, ADD = 10, ALIAS = 11, ARGLIST = 12, AS = 13, ASCENDING = 14, - ASYNC = 15, AWAIT = 16, BASE = 17, BOOL = 18, BREAK = 19, BY = 20, BYTE = 21, CASE = 22, - CATCH = 23, CHAR = 24, CHECKED = 25, CLASS = 26, CONST = 27, CONTINUE = 28, DECIMAL = 29, - DEFAULT = 30, DELEGATE = 31, DESCENDING = 32, DO = 33, DOUBLE = 34, DYNAMIC = 35, - ELSE = 36, ENUM = 37, EQUALS = 38, EVENT = 39, EXPLICIT = 40, EXTERN = 41, FALSE = 42, - FINALLY = 43, FIXED = 44, FLOAT = 45, FOR = 46, FOREACH = 47, FROM = 48, GET = 49, GOTO = 50, - GROUP = 51, IF = 52, IMPLICIT = 53, IN = 54, INT = 55, INTERFACE = 56, INTERNAL = 57, - INTO = 58, IS = 59, JOIN = 60, LET = 61, LOCK = 62, LONG = 63, NAMEOF = 64, NAMESPACE = 65, - NEW = 66, NULL = 67, OBJECT = 68, ON = 69, OPERATOR = 70, ORDERBY = 71, OUT = 72, OVERRIDE = 73, - PARAMS = 74, PARTIAL = 75, PRIVATE = 76, PROTECTED = 77, PUBLIC = 78, READONLY = 79, - REF = 80, REMOVE = 81, RETURN = 82, SBYTE = 83, SEALED = 84, SELECT = 85, SET = 86, - SHORT = 87, SIZEOF = 88, STACKALLOC = 89, STATIC = 90, STRING = 91, STRUCT = 92, SWITCH = 93, - THIS = 94, THROW = 95, TRUE = 96, TRY = 97, TYPEOF = 98, UINT = 99, ULONG = 100, UNCHECKED = 101, - UNMANAGED = 102, UNSAFE = 103, USHORT = 104, USING = 105, VAR = 106, VIRTUAL = 107, - VOID = 108, VOLATILE = 109, WHEN = 110, WHERE = 111, WHILE = 112, YIELD = 113, IDENTIFIER = 114, - LITERAL_ACCESS = 115, INTEGER_LITERAL = 116, HEX_INTEGER_LITERAL = 117, BIN_INTEGER_LITERAL = 118, - REAL_LITERAL = 119, CHARACTER_LITERAL = 120, REGULAR_STRING = 121, VERBATIUM_STRING = 122, - INTERPOLATED_REGULAR_STRING_START = 123, INTERPOLATED_VERBATIUM_STRING_START = 124, - OPEN_BRACE = 125, CLOSE_BRACE = 126, OPEN_BRACKET = 127, CLOSE_BRACKET = 128, - OPEN_PARENS = 129, CLOSE_PARENS = 130, DOT = 131, COMMA = 132, COLON = 133, SEMICOLON = 134, - PLUS = 135, MINUS = 136, STAR = 137, DIV = 138, PERCENT = 139, AMP = 140, BITWISE_OR = 141, - CARET = 142, BANG = 143, TILDE = 144, ASSIGNMENT = 145, LT = 146, GT = 147, INTERR = 148, - DOUBLE_COLON = 149, OP_COALESCING = 150, OP_INC = 151, OP_DEC = 152, OP_AND = 153, - OP_OR = 154, OP_PTR = 155, OP_EQ = 156, OP_NE = 157, OP_LE = 158, OP_GE = 159, OP_ADD_ASSIGNMENT = 160, - OP_SUB_ASSIGNMENT = 161, OP_MULT_ASSIGNMENT = 162, OP_DIV_ASSIGNMENT = 163, - OP_MOD_ASSIGNMENT = 164, OP_AND_ASSIGNMENT = 165, OP_OR_ASSIGNMENT = 166, OP_XOR_ASSIGNMENT = 167, - OP_LEFT_SHIFT = 168, OP_LEFT_SHIFT_ASSIGNMENT = 169, OP_COALESCING_ASSIGNMENT = 170, - OP_RANGE = 171, DOUBLE_CURLY_INSIDE = 172, OPEN_BRACE_INSIDE = 173, REGULAR_CHAR_INSIDE = 174, - VERBATIUM_DOUBLE_QUOTE_INSIDE = 175, DOUBLE_QUOTE_INSIDE = 176, REGULAR_STRING_INSIDE = 177, - VERBATIUM_INSIDE_STRING = 178, CLOSE_BRACE_INSIDE = 179, FORMAT_STRING = 180, - DIRECTIVE_WHITESPACES = 181, DIGITS = 182, DEFINE = 183, UNDEF = 184, ELIF = 185, - ENDIF = 186, LINE = 187, ERROR = 188, WARNING = 189, REGION = 190, ENDREGION = 191, - PRAGMA = 192, NULLABLE = 193, DIRECTIVE_HIDDEN = 194, CONDITIONAL_SYMBOL = 195, - DIRECTIVE_NEW_LINE = 196, TEXT = 197, DOUBLE_CURLY_CLOSE_INSIDE = 198; - public static final int - COMMENTS_CHANNEL = 2, DIRECTIVE = 3; - public static final int - INTERPOLATION_STRING = 1, INTERPOLATION_FORMAT = 2, DIRECTIVE_MODE = 3, DIRECTIVE_TEXT = 4; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "COMMENTS_CHANNEL", "DIRECTIVE" - }; - - public static String[] modeNames = { - "DEFAULT_MODE", "INTERPOLATION_STRING", "INTERPOLATION_FORMAT", "DIRECTIVE_MODE", - "DIRECTIVE_TEXT" - }; - - private static String[] makeRuleNames() { - return new String[]{ - "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", - "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", - "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", - "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", - "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", - "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", - "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", - "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", - "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", - "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", - "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", - "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", - "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", - "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", - "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", - "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", - "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", - "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", - "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", - "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", - "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", - "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", - "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", - "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", - "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", - "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", - "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", - "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", - "VERBATIUM_INSIDE_STRING", "DOUBLE_CURLY_CLOSE_INSIDE", "CLOSE_BRACE_INSIDE", - "FORMAT_STRING", "DIRECTIVE_WHITESPACES", "DIGITS", "DIRECTIVE_TRUE", - "DIRECTIVE_FALSE", "DEFINE", "UNDEF", "DIRECTIVE_IF", "ELIF", "DIRECTIVE_ELSE", - "ENDIF", "LINE", "ERROR", "WARNING", "REGION", "ENDREGION", "PRAGMA", - "NULLABLE", "DIRECTIVE_DEFAULT", "DIRECTIVE_HIDDEN", "DIRECTIVE_OPEN_PARENS", - "DIRECTIVE_CLOSE_PARENS", "DIRECTIVE_BANG", "DIRECTIVE_OP_EQ", "DIRECTIVE_OP_NE", - "DIRECTIVE_OP_AND", "DIRECTIVE_OP_OR", "DIRECTIVE_STRING", "CONDITIONAL_SYMBOL", - "DIRECTIVE_SINGLE_LINE_COMMENT", "DIRECTIVE_NEW_LINE", "TEXT", "TEXT_NEW_LINE", - "InputCharacter", "NewLineCharacter", "IntegerTypeSuffix", "ExponentPart", - "CommonCharacter", "SimpleEscapeSequence", "HexEscapeSequence", "NewLine", - "Whitespace", "UnicodeClassZS", "IdentifierOrKeyword", "IdentifierStartCharacter", - "IdentifierPartCharacter", "LetterCharacter", "DecimalDigitCharacter", - "ConnectingCharacter", "CombiningCharacter", "FormattingCharacter", "UnicodeEscapeSequence", - "HexDigit", "UnicodeClassLU", "UnicodeClassLL", "UnicodeClassLT", "UnicodeClassLM", - "UnicodeClassLO", "UnicodeClassNL", "UnicodeClassMN", "UnicodeClassMC", - "UnicodeClassCF", "UnicodeClassPC", "UnicodeClassND" - }; - } - - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[]{ - null, "'\u00EF\u00BB\u00BF'", null, "'/***/'", null, null, null, null, - "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", - "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", - "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", - "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", - "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", - "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", - "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", - "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", - "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", - "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", - "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", - "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", - "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", - "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", - "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", - "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", - "'yield'", null, null, null, null, null, null, null, null, null, null, - null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", - "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", - "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", - "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", - "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", - "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", - "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, - null, "'hidden'", null, null, null, "'}}'" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[]{ - null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", - "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", - "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", - "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", - "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", - "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", - "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", - "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", - "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", - "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", - "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", - "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", - "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", - "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", - "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", - "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", - "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", - "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", - "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", - "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", - "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", - "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", - "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", - "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", - "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", - "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", - "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", - "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", - "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", - "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", - "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", - "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" - }; - } - - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - private int interpolatedStringLevel; - private Stack interpolatedVerbatiums = new Stack(); - private Stack curlyLevels = new Stack(); - private boolean verbatium; - - - public CSharpLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "CSharpLexer.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public String[] getChannelNames() { - return channelNames; - } - - @Override - public String[] getModeNames() { - return modeNames; - } - - @Override - public ATN getATN() { - return _ATN; - } - - @Override - public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { - switch (ruleIndex) { - case 122: - INTERPOLATED_REGULAR_STRING_START_action((RuleContext) _localctx, actionIndex); - break; - case 123: - INTERPOLATED_VERBATIUM_STRING_START_action((RuleContext) _localctx, actionIndex); - break; - case 124: - OPEN_BRACE_action((RuleContext) _localctx, actionIndex); - break; - case 125: - CLOSE_BRACE_action((RuleContext) _localctx, actionIndex); - break; - case 132: - COLON_action((RuleContext) _localctx, actionIndex); - break; - case 172: - OPEN_BRACE_INSIDE_action((RuleContext) _localctx, actionIndex); - break; - case 175: - DOUBLE_QUOTE_INSIDE_action((RuleContext) _localctx, actionIndex); - break; - case 179: - CLOSE_BRACE_INSIDE_action((RuleContext) _localctx, actionIndex); - break; - } - } - - private void INTERPOLATED_REGULAR_STRING_START_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 0: - interpolatedStringLevel++; - interpolatedVerbatiums.push(false); - verbatium = false; - break; - } - } - - private void INTERPOLATED_VERBATIUM_STRING_START_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 1: - interpolatedStringLevel++; - interpolatedVerbatiums.push(true); - verbatium = true; - break; - } - } - - private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 2: - - if (interpolatedStringLevel > 0) { - curlyLevels.push(curlyLevels.pop() + 1); - } - break; - } - } - - private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 3: - - if (interpolatedStringLevel > 0) { - curlyLevels.push(curlyLevels.pop() - 1); - if (curlyLevels.peek() == 0) { - curlyLevels.pop(); - skip(); - popMode(); - } - } - - break; - } - } - - private void COLON_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 4: - - if (interpolatedStringLevel > 0) { - int ind = 1; - boolean switchToFormatString = true; - while ((char) _input.LA(ind) != '}') { - if (_input.LA(ind) == ':' || _input.LA(ind) == ')') { - switchToFormatString = false; - break; - } - ind++; - } - if (switchToFormatString) { - mode(INTERPOLATION_FORMAT); - } - } - - break; - } - } - - private void OPEN_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 5: - curlyLevels.push(1); - break; - } - } - - private void DOUBLE_QUOTE_INSIDE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 6: - interpolatedStringLevel--; - interpolatedVerbatiums.pop(); - verbatium = (interpolatedVerbatiums.size() > 0 ? interpolatedVerbatiums.peek() : false); - break; - } - } - - private void CLOSE_BRACE_INSIDE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 7: - curlyLevels.pop(); - break; - } - } - - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 173: - return REGULAR_CHAR_INSIDE_sempred((RuleContext) _localctx, predIndex); - case 174: - return VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred((RuleContext) _localctx, predIndex); - case 176: - return REGULAR_STRING_INSIDE_sempred((RuleContext) _localctx, predIndex); - case 177: - return VERBATIUM_INSIDE_STRING_sempred((RuleContext) _localctx, predIndex); - } - return true; - } - - private boolean REGULAR_CHAR_INSIDE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return !verbatium; - } - return true; - } - - private boolean VERBATIUM_DOUBLE_QUOTE_INSIDE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 1: - return verbatium; - } - return true; - } - - private boolean REGULAR_STRING_INSIDE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 2: - return !verbatium; - } - return true; - } - - private boolean VERBATIUM_INSIDE_STRING_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 3: - return verbatium; - } - return true; - } - - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00c8\u0816\b\1\b" + - "\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b" + - "\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t" + - "\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t" + - "\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t" + - "\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t" + - "(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t" + - "\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t" + - ":\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4" + - "F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\t" + - "Q\4R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\" + - "\4]\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h" + - "\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts" + - "\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177" + - "\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083" + - "\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088" + - "\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c" + - "\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091" + - "\t\u0091\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095" + - "\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a" + - "\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e" + - "\4\u009f\t\u009f\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3" + - "\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7" + - "\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac" + - "\t\u00ac\4\u00ad\t\u00ad\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0" + - "\4\u00b1\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5" + - "\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9" + - "\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be" + - "\t\u00be\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2" + - "\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7" + - "\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb" + - "\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0" + - "\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4" + - "\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9" + - "\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd" + - "\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2" + - "\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6" + - "\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb" + - "\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef" + - "\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4" + - "\t\u00f4\4\u00f5\t\u00f5\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\7\3\u01f9" + - "\n\3\f\3\16\3\u01fc\13\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3" + - "\5\3\5\3\5\3\5\3\5\7\5\u020e\n\5\f\5\16\5\u0211\13\5\3\5\3\5\3\5\3\5\3" + - "\5\3\6\3\6\3\6\3\6\7\6\u021c\n\6\f\6\16\6\u021f\13\6\3\6\3\6\3\7\3\7\3" + - "\7\3\7\7\7\u0227\n\7\f\7\16\7\u022a\13\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\6" + - "\b\u0233\n\b\r\b\16\b\u0234\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3" + - "\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\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\16\3\16\3\16\3\17\3\17\3\17\3\17\3" + - "\17\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3" + - "\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3" + - "\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3" + - "\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3" + - "\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3" + - "\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3" + - "\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3" + - "\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3" + - "!\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3" + - "$\3%\3%\3%\3%\3%\3&\3&\3&\3&\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\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3" + - "\61\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3" + - "\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3" + - "\67\3\67\3\67\38\38\38\38\39\39\39\39\39\39\39\39\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@\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3" + - "B\3B\3B\3C\3C\3C\3C\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3G\3" + - "G\3G\3G\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3J\3J\3J\3" + - "J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3L\3M\3M\3" + - "M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3" + - "P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3" + - "S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3" + - "V\3W\3W\3W\3W\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3" + - "Z\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" + - "`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3e\3" + - "e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3g\3g\3" + - "g\3g\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3k\3" + - "k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3" + - "n\3n\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3" + - "r\3r\3s\5s\u04e1\ns\3s\3s\3t\3t\7t\u04e7\nt\ft\16t\u04ea\13t\3t\7t\u04ed" + - "\nt\ft\16t\u04f0\13t\3t\5t\u04f3\nt\3t\3t\5t\u04f7\nt\3t\3t\3u\3u\7u\u04fd" + - "\nu\fu\16u\u0500\13u\3u\7u\u0503\nu\fu\16u\u0506\13u\3u\5u\u0509\nu\3" + - "v\3v\3v\7v\u050e\nv\fv\16v\u0511\13v\3v\6v\u0514\nv\rv\16v\u0515\3v\5" + - "v\u0519\nv\3w\3w\3w\7w\u051e\nw\fw\16w\u0521\13w\3w\6w\u0524\nw\rw\16" + - "w\u0525\3w\5w\u0529\nw\3x\3x\7x\u052d\nx\fx\16x\u0530\13x\3x\7x\u0533" + - "\nx\fx\16x\u0536\13x\5x\u0538\nx\3x\3x\3x\7x\u053d\nx\fx\16x\u0540\13" + - "x\3x\7x\u0543\nx\fx\16x\u0546\13x\3x\5x\u0549\nx\3x\5x\u054c\nx\3x\3x" + - "\7x\u0550\nx\fx\16x\u0553\13x\3x\7x\u0556\nx\fx\16x\u0559\13x\3x\3x\3" + - "x\5x\u055e\nx\5x\u0560\nx\5x\u0562\nx\3y\3y\3y\5y\u0567\ny\3y\3y\3z\3" + - "z\3z\7z\u056e\nz\fz\16z\u0571\13z\3z\3z\3{\3{\3{\3{\3{\3{\7{\u057b\n{" + - "\f{\16{\u057e\13{\3{\3{\3|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3" + - "~\3~\3~\3\177\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0082\3\u0082" + - "\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086" + - "\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b" + - "\3\u008b\3\u008c\3\u008c\3\u008d\3\u008d\3\u008e\3\u008e\3\u008f\3\u008f" + - "\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\3\u0094" + - "\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097" + - "\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a" + - "\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d\3\u009d" + - "\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0" + - "\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3" + - "\3\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6" + - "\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00a9" + - "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac" + - "\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae" + - "\3\u00ae\3\u00ae\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0" + - "\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\6\u00b2\u0622" + - "\n\u00b2\r\u00b2\16\u00b2\u0623\3\u00b3\3\u00b3\6\u00b3\u0628\n\u00b3" + - "\r\u00b3\16\u00b3\u0629\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5" + - "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b6\6\u00b6\u0638\n\u00b6" + - "\r\u00b6\16\u00b6\u0639\3\u00b7\6\u00b7\u063d\n\u00b7\r\u00b7\16\u00b7" + - "\u063e\3\u00b7\3\u00b7\3\u00b8\6\u00b8\u0644\n\u00b8\r\u00b8\16\u00b8" + - "\u0645\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9" + - "\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba" + - "\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb" + - "\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc" + - "\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be" + - "\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf" + - "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0" + - "\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1" + - "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\6\u00c2" + - "\u0697\n\u00c2\r\u00c2\16\u00c2\u0698\3\u00c2\3\u00c2\3\u00c2\3\u00c3" + - "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\6\u00c3" + - "\u06a7\n\u00c3\r\u00c3\16\u00c3\u06a8\3\u00c3\3\u00c3\3\u00c3\3\u00c4" + - "\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u06b6" + - "\n\u00c4\f\u00c4\16\u00c4\u06b9\13\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5" + - "\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5" + - "\3\u00c5\7\u00c5\u06c9\n\u00c5\f\u00c5\16\u00c5\u06cc\13\u00c5\3\u00c5" + - "\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6" + - "\3\u00c6\6\u00c6\u06d9\n\u00c6\r\u00c6\16\u00c6\u06da\3\u00c6\3\u00c6" + - "\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7" + - "\3\u00c7\3\u00c7\6\u00c7\u06ea\n\u00c7\r\u00c7\16\u00c7\u06eb\3\u00c7" + - "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8" + - "\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9" + - "\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca" + - "\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc" + - "\3\u00cc\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce" + - "\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf" + - "\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1" + - "\7\u00d1\u072e\n\u00d1\f\u00d1\16\u00d1\u0731\13\u00d1\3\u00d1\3\u00d1" + - "\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3" + - "\3\u00d3\3\u00d3\7\u00d3\u0740\n\u00d3\f\u00d3\16\u00d3\u0743\13\u00d3" + - "\3\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5" + - "\6\u00d5\u074e\n\u00d5\r\u00d5\16\u00d5\u074f\3\u00d5\3\u00d5\3\u00d6" + - "\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d7\3\u00d7\3\u00d8\3\u00d8" + - "\3\u00d9\5\u00d9\u075f\n\u00d9\3\u00d9\3\u00d9\5\u00d9\u0763\n\u00d9\3" + - "\u00d9\5\u00d9\u0766\n\u00d9\3\u00da\3\u00da\5\u00da\u076a\n\u00da\3\u00da" + - "\3\u00da\7\u00da\u076e\n\u00da\f\u00da\16\u00da\u0771\13\u00da\3\u00da" + - "\7\u00da\u0774\n\u00da\f\u00da\16\u00da\u0777\13\u00da\3\u00db\3\u00db" + - "\3\u00db\5\u00db\u077c\n\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc" + - "\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc" + - "\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\5\u00dc" + - "\u0794\n\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd" + - "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd" + - "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd" + - "\5\u00dd\u07af\n\u00dd\3\u00de\3\u00de\3\u00de\5\u00de\u07b4\n\u00de\3" + - "\u00df\3\u00df\5\u00df\u07b8\n\u00df\3\u00e0\3\u00e0\3\u00e1\3\u00e1\7" + - "\u00e1\u07be\n\u00e1\f\u00e1\16\u00e1\u07c1\13\u00e1\3\u00e2\3\u00e2\5" + - "\u00e2\u07c5\n\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\5\u00e3\u07cc" + - "\n\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\5\u00e4" + - "\u07d5\n\u00e4\3\u00e5\3\u00e5\5\u00e5\u07d9\n\u00e5\3\u00e6\3\u00e6\5" + - "\u00e6\u07dd\n\u00e6\3\u00e7\3\u00e7\3\u00e7\5\u00e7\u07e2\n\u00e7\3\u00e8" + - "\3\u00e8\5\u00e8\u07e6\n\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9" + - "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9" + - "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\5\u00e9\u07fc\n\u00e9" + - "\3\u00ea\5\u00ea\u07ff\n\u00ea\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ed" + - "\3\u00ed\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f1\3\u00f1" + - "\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f5\3\u00f5\4\u020f" + - "\u0228\2\u00f6\7\3\t\4\13\5\r\6\17\7\21\b\23\t\25\n\27\13\31\f\33\r\35" + - "\16\37\17!\20#\21%\22\'\23)\24+\25-\26/\27\61\30\63\31\65\32\67\339\34" + - ";\35=\36?\37A C!E\"G#I$K%M&O\'Q(S)U*W+Y,[-]._/a\60c\61e\62g\63i\64k\65" + - "m\66o\67q8s9u:w;y<{=}>\177?\u0081@\u0083A\u0085B\u0087C\u0089D\u008bE" + - "\u008dF\u008fG\u0091H\u0093I\u0095J\u0097K\u0099L\u009bM\u009dN\u009f" + - "O\u00a1P\u00a3Q\u00a5R\u00a7S\u00a9T\u00abU\u00adV\u00afW\u00b1X\u00b3" + - "Y\u00b5Z\u00b7[\u00b9\\\u00bb]\u00bd^\u00bf_\u00c1`\u00c3a\u00c5b\u00c7" + - "c\u00c9d\u00cbe\u00cdf\u00cfg\u00d1h\u00d3i\u00d5j\u00d7k\u00d9l\u00db" + - "m\u00ddn\u00dfo\u00e1p\u00e3q\u00e5r\u00e7s\u00e9t\u00ebu\u00edv\u00ef" + - "w\u00f1x\u00f3y\u00f5z\u00f7{\u00f9|\u00fb}\u00fd~\u00ff\177\u0101\u0080" + - "\u0103\u0081\u0105\u0082\u0107\u0083\u0109\u0084\u010b\u0085\u010d\u0086" + - "\u010f\u0087\u0111\u0088\u0113\u0089\u0115\u008a\u0117\u008b\u0119\u008c" + - "\u011b\u008d\u011d\u008e\u011f\u008f\u0121\u0090\u0123\u0091\u0125\u0092" + - "\u0127\u0093\u0129\u0094\u012b\u0095\u012d\u0096\u012f\u0097\u0131\u0098" + - "\u0133\u0099\u0135\u009a\u0137\u009b\u0139\u009c\u013b\u009d\u013d\u009e" + - "\u013f\u009f\u0141\u00a0\u0143\u00a1\u0145\u00a2\u0147\u00a3\u0149\u00a4" + - "\u014b\u00a5\u014d\u00a6\u014f\u00a7\u0151\u00a8\u0153\u00a9\u0155\u00aa" + - "\u0157\u00ab\u0159\u00ac\u015b\u00ad\u015d\u00ae\u015f\u00af\u0161\u00b0" + - "\u0163\u00b1\u0165\u00b2\u0167\u00b3\u0169\u00b4\u016b\u00c8\u016d\u00b5" + - "\u016f\u00b6\u0171\u00b7\u0173\u00b8\u0175\2\u0177\2\u0179\u00b9\u017b" + - "\u00ba\u017d\2\u017f\u00bb\u0181\2\u0183\u00bc\u0185\u00bd\u0187\u00be" + - "\u0189\u00bf\u018b\u00c0\u018d\u00c1\u018f\u00c2\u0191\u00c3\u0193\2\u0195" + - "\u00c4\u0197\2\u0199\2\u019b\2\u019d\2\u019f\2\u01a1\2\u01a3\2\u01a5\2" + - "\u01a7\u00c5\u01a9\2\u01ab\u00c6\u01ad\u00c7\u01af\2\u01b1\2\u01b3\2\u01b5" + - "\2\u01b7\2\u01b9\2\u01bb\2\u01bd\2\u01bf\2\u01c1\2\u01c3\2\u01c5\2\u01c7" + - "\2\u01c9\2\u01cb\2\u01cd\2\u01cf\2\u01d1\2\u01d3\2\u01d5\2\u01d7\2\u01d9" + - "\2\u01db\2\u01dd\2\u01df\2\u01e1\2\u01e3\2\u01e5\2\u01e7\2\u01e9\2\u01eb" + - "\2\u01ed\2\7\2\3\4\5\6!\3\2\61\61\3\2\62;\4\2ZZzz\4\2DDdd\3\2\62\63\b" + - "\2FFHHOOffhhoo\b\2\f\f\17\17))^^\u0087\u0087\u202a\u202b\b\2\f\f\17\17" + - "$$^^\u0087\u0087\u202a\u202b\3\2$$\5\2$$^^}}\4\2$$}}\3\2\177\177\7\2\f" + - "\f\17\17$$\u0087\u0087\u202a\u202b\6\2\f\f\17\17\u0087\u0087\u202a\u202b" + - "\4\2NNnn\4\2WWww\4\2GGgg\4\2--//\4\2\13\13\r\16\13\2\"\"\u00a2\u00a2\u1682" + - "\u1682\u1810\u1810\u2002\u2008\u200a\u200c\u2031\u2031\u2061\u2061\u3002" + - "\u3002\5\2\62;CHchT\2C\\\u00c2\u00d8\u00da\u00e0\u0102\u0138\u013b\u0149" + - "\u014c\u017f\u0183\u0184\u0186\u018d\u0190\u0193\u0195\u0196\u0198\u019a" + - "\u019e\u019f\u01a1\u01a2\u01a4\u01ab\u01ae\u01b5\u01b7\u01be\u01c6\u01cf" + - "\u01d1\u01dd\u01e0\u01f0\u01f3\u01f6\u01f8\u01fa\u01fc\u0234\u023c\u023d" + - "\u023f\u0240\u0243\u0248\u024a\u0250\u0372\u0374\u0378\u0381\u0388\u038c" + - "\u038e\u03a3\u03a5\u03ad\u03d1\u03d6\u03da\u03f0\u03f6\u03f9\u03fb\u03fc" + - "\u03ff\u0431\u0462\u0482\u048c\u04cf\u04d2\u0530\u0533\u0558\u10a2\u10c7" + - "\u10c9\u10cf\u1e02\u1e96\u1ea0\u1f00\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31" + - "\u1f3a\u1f41\u1f4a\u1f4f\u1f5b\u1f61\u1f6a\u1f71\u1fba\u1fbd\u1fca\u1fcd" + - "\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2109\u210d\u210f\u2112\u2114" + - "\u2117\u211f\u2126\u212f\u2132\u2135\u2140\u2141\u2147\u2185\u2c02\u2c30" + - "\u2c62\u2c66\u2c69\u2c72\u2c74\u2c77\u2c80\u2c82\u2c84\u2ce4\u2ced\u2cef" + - "\u2cf4\ua642\ua644\ua66e\ua682\ua69c\ua724\ua730\ua734\ua770\ua77b\ua788" + - "\ua78d\ua78f\ua792\ua794\ua798\ua7af\ua7b2\ua7b3\uff23\uff3cS\2c|\u00b7" + - "\u00f8\u00fa\u0101\u0103\u0179\u017c\u0182\u0185\u0187\u018a\u0194\u0197" + - "\u019d\u01a0\u01a3\u01a5\u01a7\u01aa\u01af\u01b2\u01b6\u01b8\u01c1\u01c8" + - "\u01ce\u01d0\u01f5\u01f7\u01fb\u01fd\u023b\u023e\u0244\u0249\u0295\u0297" + - "\u02b1\u0373\u0375\u0379\u037f\u0392\u03d0\u03d2\u03d3\u03d7\u03d9\u03db" + - "\u03f5\u03f7\u0461\u0463\u0483\u048d\u04c1\u04c4\u0531\u0563\u0589\u1d02" + - "\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03\u1e9f\u1ea1\u1f09\u1f12\u1f17\u1f22" + - "\u1f29\u1f32\u1f39\u1f42\u1f47\u1f52\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82" + - "\u1f89\u1f92\u1f99\u1fa2\u1fa9\u1fb2\u1fb6\u1fb8\u1fb9\u1fc0\u1fc6\u1fc8" + - "\u1fc9\u1fd2\u1fd5\u1fd8\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c" + - "\u2115\u2131\u213b\u213e\u213f\u2148\u214b\u2150\u2186\u2c32\u2c60\u2c63" + - "\u2c6e\u2c73\u2c7d\u2c83\u2cee\u2cf0\u2cf5\u2d02\u2d27\u2d29\u2d2f\ua643" + - "\ua66f\ua683\ua69d\ua725\ua733\ua735\ua77a\ua77c\ua77e\ua781\ua789\ua78e" + - "\ua790\ua793\ua797\ua799\ua7ab\ua7fc\uab5c\uab66\uab67\ufb02\ufb08\ufb15" + - "\ufb19\uff43\uff5c\b\2\u01c7\u01cd\u01f4\u1f91\u1f9a\u1fa1\u1faa\u1fb1" + - "\u1fbe\u1fce\u1ffe\u1ffe#\2\u02b2\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee" + - "\u02f0\u0376\u037c\u055b\u0642\u06e7\u06e8\u07f6\u07f7\u07fc\u081c\u0826" + - "\u082a\u0973\u0e48\u0ec8\u10fe\u17d9\u1845\u1aa9\u1c7f\u1d2e\u1d6c\u1d7a" + - "\u1dc1\u2073\u2081\u2092\u209e\u2c7e\u2c7f\u2d71\u2e31\u3007\u3037\u303d" + - "\u3100\ua017\ua4ff\ua60e\ua681\ua69e\ua69f\ua719\ua721\ua772\ua78a\ua7fa" + - "\ua7fb\ua9d1\ua9e8\uaa72\uaadf\uaaf5\uaaf6\uab5e\uab61\uff72\uffa1\u00ec" + - "\2\u00ac\u00bc\u01bd\u01c5\u0296\u05ec\u05f2\u05f4\u0622\u0641\u0643\u064c" + - "\u0670\u0671\u0673\u06d5\u06d7\u06fe\u0701\u0712\u0714\u0731\u074f\u07a7" + - "\u07b3\u07ec\u0802\u0817\u0842\u085a\u08a2\u08b4\u0906\u093b\u093f\u0952" + - "\u095a\u0963\u0974\u0982\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac\u09b2" + - "\u09b4\u09bb\u09bf\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c" + - "\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b" + - "\u0a5b\u0a5e\u0a60\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2" + - "\u0ab4\u0ab5\u0ab7\u0abb\u0abf\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12" + - "\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b63\u0b73\u0b85" + - "\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e\u0bac\u0bb0\u0bbb" + - "\u0bd2\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c3b\u0c3f\u0c8e\u0c90\u0c92" + - "\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4" + - "\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c\u0d3f\u0d50\u0d62\u0d63\u0d7c\u0d81" + - "\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dc8\u0e03\u0e32\u0e34\u0e35" + - "\u0e42\u0e47\u0e83\u0e84\u0e86\u0e8c\u0e8f\u0e99\u0e9b\u0ea1\u0ea3\u0ea5" + - "\u0ea7\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ec6\u0ede\u0ee1" + - "\u0f02\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1057\u105c\u105f" + - "\u1063\u1072\u1077\u1083\u1090\u10fc\u10ff\u124a\u124c\u124f\u1252\u1258" + - "\u125a\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4\u12b7\u12ba\u12c0" + - "\u12c2\u12c7\u12ca\u12d8\u12da\u1312\u1314\u1317\u131a\u135c\u1382\u1391" + - "\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u16f3\u16fa" + - "\u1702\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762\u176e\u1770\u1772" + - "\u1782\u17b5\u17de\u1844\u1846\u1879\u1882\u18aa\u18ac\u18f7\u1902\u1920" + - "\u1952\u196f\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56" + - "\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25" + - "\u1c4f\u1c51\u1c5c\u1c79\u1ceb\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u2137\u213a" + - "\u2d32\u2d69\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0" + - "\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0\u3008\u303e\u3043\u3098" + - "\u30a1\u30fc\u3101\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402\u4db7" + - "\u4e02\u9fce\ua002\ua016\ua018\ua48e\ua4d2\ua4f9\ua502\ua60d\ua612\ua621" + - "\ua62c\ua62d\ua670\ua6e7\ua7f9\ua803\ua805\ua807\ua809\ua80c\ua80e\ua824" + - "\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua927\ua932\ua948\ua962\ua97e" + - "\ua986\ua9b4\ua9e2\ua9e6\ua9e9\ua9f1\ua9fc\uaa00\uaa02\uaa2a\uaa42\uaa44" + - "\uaa46\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaab1\uaab3\uaabf\uaac2\uaac4" + - "\uaadd\uaade\uaae2\uaaec\uaaf4\uab08\uab0b\uab10\uab13\uab18\uab22\uab28" + - "\uab2a\uab30\uabc2\uabe4\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f" + - "\ufa72\ufadb\ufb1f\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufbb3\ufbd5\ufd3f" + - "\ufd52\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71" + - "\uff73\uff9f\uffa2\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde" + - "\4\2\u16f0\u16f2\u2162\u2171\5\2\u0905\u0905\u0940\u0942\u094b\u094e\5" + - "\2\u00af\u00af\u0602\u0605\u06df\u06df\b\2aa\u2041\u2042\u2056\u2056\ufe35" + - "\ufe36\ufe4f\ufe51\uff41\uff41\'\2\62;\u0662\u066b\u06f2\u06fb\u07c2\u07cb" + - "\u0968\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68\u0b71\u0be8\u0bf1" + - "\u0c68\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0de8\u0df1\u0e52\u0e5b\u0ed2\u0edb" + - "\u0f22\u0f2b\u1042\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948\u1951" + - "\u19d2\u19db\u1a82\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42\u1c4b" + - "\u1c52\u1c5b\ua622\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\ua9f2\ua9fb" + - "\uaa52\uaa5b\uabf2\uabfb\uff12\uff1b\2\u084e\2\7\3\2\2\2\2\t\3\2\2\2\2" + - "\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3" + - "\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2" + - "\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2" + - "\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2" + - "\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2" + - "\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q" + - "\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2" + - "\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2" + - "\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w" + - "\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2" + - "\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b" + - "\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2" + - "\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d" + - "\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2" + - "\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af" + - "\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2" + - "\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1" + - "\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2" + - "\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3" + - "\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2" + - "\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5" + - "\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2" + - "\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2\2\2\u00f7" + - "\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff\3\2\2" + - "\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109" + - "\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2" + - "\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119\3\2\2\2\2\u011b" + - "\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2\2\2\u0121\3\2\2\2\2\u0123\3\2\2" + - "\2\2\u0125\3\2\2\2\2\u0127\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d" + - "\3\2\2\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135\3\2\2" + - "\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2\2\2\u013d\3\2\2\2\2\u013f" + - "\3\2\2\2\2\u0141\3\2\2\2\2\u0143\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2" + - "\2\2\u0149\3\2\2\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151" + - "\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2\2\2\u0159\3\2\2" + - "\2\2\u015b\3\2\2\2\3\u015d\3\2\2\2\3\u015f\3\2\2\2\3\u0161\3\2\2\2\3\u0163" + - "\3\2\2\2\3\u0165\3\2\2\2\3\u0167\3\2\2\2\3\u0169\3\2\2\2\4\u016b\3\2\2" + - "\2\4\u016d\3\2\2\2\4\u016f\3\2\2\2\5\u0171\3\2\2\2\5\u0173\3\2\2\2\5\u0175" + - "\3\2\2\2\5\u0177\3\2\2\2\5\u0179\3\2\2\2\5\u017b\3\2\2\2\5\u017d\3\2\2" + - "\2\5\u017f\3\2\2\2\5\u0181\3\2\2\2\5\u0183\3\2\2\2\5\u0185\3\2\2\2\5\u0187" + - "\3\2\2\2\5\u0189\3\2\2\2\5\u018b\3\2\2\2\5\u018d\3\2\2\2\5\u018f\3\2\2" + - "\2\5\u0191\3\2\2\2\5\u0193\3\2\2\2\5\u0195\3\2\2\2\5\u0197\3\2\2\2\5\u0199" + - "\3\2\2\2\5\u019b\3\2\2\2\5\u019d\3\2\2\2\5\u019f\3\2\2\2\5\u01a1\3\2\2" + - "\2\5\u01a3\3\2\2\2\5\u01a5\3\2\2\2\5\u01a7\3\2\2\2\5\u01a9\3\2\2\2\5\u01ab" + - "\3\2\2\2\6\u01ad\3\2\2\2\6\u01af\3\2\2\2\7\u01ef\3\2\2\2\t\u01f3\3\2\2" + - "\2\13\u01ff\3\2\2\2\r\u0207\3\2\2\2\17\u0217\3\2\2\2\21\u0222\3\2\2\2" + - "\23\u0232\3\2\2\2\25\u0238\3\2\2\2\27\u023c\3\2\2\2\31\u0245\3\2\2\2\33" + - "\u0249\3\2\2\2\35\u024f\3\2\2\2\37\u0259\3\2\2\2!\u025c\3\2\2\2#\u0266" + - "\3\2\2\2%\u026c\3\2\2\2\'\u0272\3\2\2\2)\u0277\3\2\2\2+\u027c\3\2\2\2" + - "-\u0282\3\2\2\2/\u0285\3\2\2\2\61\u028a\3\2\2\2\63\u028f\3\2\2\2\65\u0295" + - "\3\2\2\2\67\u029a\3\2\2\29\u02a2\3\2\2\2;\u02a8\3\2\2\2=\u02ae\3\2\2\2" + - "?\u02b7\3\2\2\2A\u02bf\3\2\2\2C\u02c7\3\2\2\2E\u02d0\3\2\2\2G\u02db\3" + - "\2\2\2I\u02de\3\2\2\2K\u02e5\3\2\2\2M\u02ed\3\2\2\2O\u02f2\3\2\2\2Q\u02f7" + - "\3\2\2\2S\u02fe\3\2\2\2U\u0304\3\2\2\2W\u030d\3\2\2\2Y\u0314\3\2\2\2[" + - "\u031a\3\2\2\2]\u0322\3\2\2\2_\u0328\3\2\2\2a\u032e\3\2\2\2c\u0332\3\2" + - "\2\2e\u033a\3\2\2\2g\u033f\3\2\2\2i\u0343\3\2\2\2k\u0348\3\2\2\2m\u034e" + - "\3\2\2\2o\u0351\3\2\2\2q\u035a\3\2\2\2s\u035d\3\2\2\2u\u0361\3\2\2\2w" + - "\u036b\3\2\2\2y\u0374\3\2\2\2{\u0379\3\2\2\2}\u037c\3\2\2\2\177\u0381" + - "\3\2\2\2\u0081\u0385\3\2\2\2\u0083\u038a\3\2\2\2\u0085\u038f\3\2\2\2\u0087" + - "\u0396\3\2\2\2\u0089\u03a0\3\2\2\2\u008b\u03a4\3\2\2\2\u008d\u03a9\3\2" + - "\2\2\u008f\u03b0\3\2\2\2\u0091\u03b3\3\2\2\2\u0093\u03bc\3\2\2\2\u0095" + - "\u03c4\3\2\2\2\u0097\u03c8\3\2\2\2\u0099\u03d1\3\2\2\2\u009b\u03d8\3\2" + - "\2\2\u009d\u03e0\3\2\2\2\u009f\u03e8\3\2\2\2\u00a1\u03f2\3\2\2\2\u00a3" + - "\u03f9\3\2\2\2\u00a5\u0402\3\2\2\2\u00a7\u0406\3\2\2\2\u00a9\u040d\3\2" + - "\2\2\u00ab\u0414\3\2\2\2\u00ad\u041a\3\2\2\2\u00af\u0421\3\2\2\2\u00b1" + - "\u0428\3\2\2\2\u00b3\u042c\3\2\2\2\u00b5\u0432\3\2\2\2\u00b7\u0439\3\2" + - "\2\2\u00b9\u0444\3\2\2\2\u00bb\u044b\3\2\2\2\u00bd\u0452\3\2\2\2\u00bf" + - "\u0459\3\2\2\2\u00c1\u0460\3\2\2\2\u00c3\u0465\3\2\2\2\u00c5\u046b\3\2" + - "\2\2\u00c7\u0470\3\2\2\2\u00c9\u0474\3\2\2\2\u00cb\u047b\3\2\2\2\u00cd" + - "\u0480\3\2\2\2\u00cf\u0486\3\2\2\2\u00d1\u0490\3\2\2\2\u00d3\u049a\3\2" + - "\2\2\u00d5\u04a1\3\2\2\2\u00d7\u04a8\3\2\2\2\u00d9\u04ae\3\2\2\2\u00db" + - "\u04b2\3\2\2\2\u00dd\u04ba\3\2\2\2\u00df\u04bf\3\2\2\2\u00e1\u04c8\3\2" + - "\2\2\u00e3\u04cd\3\2\2\2\u00e5\u04d3\3\2\2\2\u00e7\u04d9\3\2\2\2\u00e9" + - "\u04e0\3\2\2\2\u00eb\u04e4\3\2\2\2\u00ed\u04fa\3\2\2\2\u00ef\u050a\3\2" + - "\2\2\u00f1\u051a\3\2\2\2\u00f3\u0561\3\2\2\2\u00f5\u0563\3\2\2\2\u00f7" + - "\u056a\3\2\2\2\u00f9\u0574\3\2\2\2\u00fb\u0581\3\2\2\2\u00fd\u0588\3\2" + - "\2\2\u00ff\u0590\3\2\2\2\u0101\u0593\3\2\2\2\u0103\u0596\3\2\2\2\u0105" + - "\u0598\3\2\2\2\u0107\u059a\3\2\2\2\u0109\u059c\3\2\2\2\u010b\u059e\3\2" + - "\2\2\u010d\u05a0\3\2\2\2\u010f\u05a2\3\2\2\2\u0111\u05a5\3\2\2\2\u0113" + - "\u05a7\3\2\2\2\u0115\u05a9\3\2\2\2\u0117\u05ab\3\2\2\2\u0119\u05ad\3\2" + - "\2\2\u011b\u05af\3\2\2\2\u011d\u05b1\3\2\2\2\u011f\u05b3\3\2\2\2\u0121" + - "\u05b5\3\2\2\2\u0123\u05b7\3\2\2\2\u0125\u05b9\3\2\2\2\u0127\u05bb\3\2" + - "\2\2\u0129\u05bd\3\2\2\2\u012b\u05bf\3\2\2\2\u012d\u05c1\3\2\2\2\u012f" + - "\u05c3\3\2\2\2\u0131\u05c6\3\2\2\2\u0133\u05c9\3\2\2\2\u0135\u05cc\3\2" + - "\2\2\u0137\u05cf\3\2\2\2\u0139\u05d2\3\2\2\2\u013b\u05d5\3\2\2\2\u013d" + - "\u05d8\3\2\2\2\u013f\u05db\3\2\2\2\u0141\u05de\3\2\2\2\u0143\u05e1\3\2" + - "\2\2\u0145\u05e4\3\2\2\2\u0147\u05e7\3\2\2\2\u0149\u05ea\3\2\2\2\u014b" + - "\u05ed\3\2\2\2\u014d\u05f0\3\2\2\2\u014f\u05f3\3\2\2\2\u0151\u05f6\3\2" + - "\2\2\u0153\u05f9\3\2\2\2\u0155\u05fc\3\2\2\2\u0157\u05ff\3\2\2\2\u0159" + - "\u0603\3\2\2\2\u015b\u0607\3\2\2\2\u015d\u060a\3\2\2\2\u015f\u060d\3\2" + - "\2\2\u0161\u0613\3\2\2\2\u0163\u0616\3\2\2\2\u0165\u061a\3\2\2\2\u0167" + - "\u061f\3\2\2\2\u0169\u0625\3\2\2\2\u016b\u062b\3\2\2\2\u016d\u0630\3\2" + - "\2\2\u016f\u0637\3\2\2\2\u0171\u063c\3\2\2\2\u0173\u0643\3\2\2\2\u0175" + - "\u0649\3\2\2\2\u0177\u0651\3\2\2\2\u0179\u065a\3\2\2\2\u017b\u0663\3\2" + - "\2\2\u017d\u066b\3\2\2\2\u017f\u0671\3\2\2\2\u0181\u0678\3\2\2\2\u0183" + - "\u0680\3\2\2\2\u0185\u0688\3\2\2\2\u0187\u068f\3\2\2\2\u0189\u069d\3\2" + - "\2\2\u018b\u06ad\3\2\2\2\u018d\u06bd\3\2\2\2\u018f\u06d0\3\2\2\2\u0191" + - "\u06df\3\2\2\2\u0193\u06f0\3\2\2\2\u0195\u06fb\3\2\2\2\u0197\u0704\3\2" + - "\2\2\u0199\u0709\3\2\2\2\u019b\u070e\3\2\2\2\u019d\u0713\3\2\2\2\u019f" + - "\u0719\3\2\2\2\u01a1\u071f\3\2\2\2\u01a3\u0725\3\2\2\2\u01a5\u072b\3\2" + - "\2\2\u01a7\u0737\3\2\2\2\u01a9\u073b\3\2\2\2\u01ab\u0747\3\2\2\2\u01ad" + - "\u074d\3\2\2\2\u01af\u0753\3\2\2\2\u01b1\u0759\3\2\2\2\u01b3\u075b\3\2" + - "\2\2\u01b5\u0765\3\2\2\2\u01b7\u0767\3\2\2\2\u01b9\u077b\3\2\2\2\u01bb" + - "\u0793\3\2\2\2\u01bd\u07ae\3\2\2\2\u01bf\u07b3\3\2\2\2\u01c1\u07b7\3\2" + - "\2\2\u01c3\u07b9\3\2\2\2\u01c5\u07bb\3\2\2\2\u01c7\u07c4\3\2\2\2\u01c9" + - "\u07cb\3\2\2\2\u01cb\u07d4\3\2\2\2\u01cd\u07d8\3\2\2\2\u01cf\u07dc\3\2" + - "\2\2\u01d1\u07e1\3\2\2\2\u01d3\u07e5\3\2\2\2\u01d5\u07fb\3\2\2\2\u01d7" + - "\u07fe\3\2\2\2\u01d9\u0800\3\2\2\2\u01db\u0802\3\2\2\2\u01dd\u0804\3\2" + - "\2\2\u01df\u0806\3\2\2\2\u01e1\u0808\3\2\2\2\u01e3\u080a\3\2\2\2\u01e5" + - "\u080c\3\2\2\2\u01e7\u080e\3\2\2\2\u01e9\u0810\3\2\2\2\u01eb\u0812\3\2" + - "\2\2\u01ed\u0814\3\2\2\2\u01ef\u01f0\7\u00f1\2\2\u01f0\u01f1\7\u00bd\2" + - "\2\u01f1\u01f2\7\u00c1\2\2\u01f2\b\3\2\2\2\u01f3\u01f4\7\61\2\2\u01f4" + - "\u01f5\7\61\2\2\u01f5\u01f6\7\61\2\2\u01f6\u01fa\3\2\2\2\u01f7\u01f9\5" + - "\u01b1\u00d7\2\u01f8\u01f7\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa\u01f8\3\2" + - "\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fd\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fd" + - "\u01fe\b\3\2\2\u01fe\n\3\2\2\2\u01ff\u0200\7\61\2\2\u0200\u0201\7,\2\2" + - "\u0201\u0202\7,\2\2\u0202\u0203\7,\2\2\u0203\u0204\7\61\2\2\u0204\u0205" + - "\3\2\2\2\u0205\u0206\b\4\2\2\u0206\f\3\2\2\2\u0207\u0208\7\61\2\2\u0208" + - "\u0209\7,\2\2\u0209\u020a\7,\2\2\u020a\u020b\3\2\2\2\u020b\u020f\n\2\2" + - "\2\u020c\u020e\13\2\2\2\u020d\u020c\3\2\2\2\u020e\u0211\3\2\2\2\u020f" + - "\u0210\3\2\2\2\u020f\u020d\3\2\2\2\u0210\u0212\3\2\2\2\u0211\u020f\3\2" + - "\2\2\u0212\u0213\7,\2\2\u0213\u0214\7\61\2\2\u0214\u0215\3\2\2\2\u0215" + - "\u0216\b\5\2\2\u0216\16\3\2\2\2\u0217\u0218\7\61\2\2\u0218\u0219\7\61" + - "\2\2\u0219\u021d\3\2\2\2\u021a\u021c\5\u01b1\u00d7\2\u021b\u021a\3\2\2" + - "\2\u021c\u021f\3\2\2\2\u021d\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220" + - "\3\2\2\2\u021f\u021d\3\2\2\2\u0220\u0221\b\6\2\2\u0221\20\3\2\2\2\u0222" + - "\u0223\7\61\2\2\u0223\u0224\7,\2\2\u0224\u0228\3\2\2\2\u0225\u0227\13" + - "\2\2\2\u0226\u0225\3\2\2\2\u0227\u022a\3\2\2\2\u0228\u0229\3\2\2\2\u0228" + - "\u0226\3\2\2\2\u0229\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022c\7," + - "\2\2\u022c\u022d\7\61\2\2\u022d\u022e\3\2\2\2\u022e\u022f\b\7\2\2\u022f" + - "\22\3\2\2\2\u0230\u0233\5\u01c1\u00df\2\u0231\u0233\5\u01bf\u00de\2\u0232" + - "\u0230\3\2\2\2\u0232\u0231\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0232\3\2" + - "\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237\b\b\3\2\u0237" + - "\24\3\2\2\2\u0238\u0239\7%\2\2\u0239\u023a\3\2\2\2\u023a\u023b\b\t\4\2" + - "\u023b\26\3\2\2\2\u023c\u023d\7c\2\2\u023d\u023e\7d\2\2\u023e\u023f\7" + - "u\2\2\u023f\u0240\7v\2\2\u0240\u0241\7t\2\2\u0241\u0242\7c\2\2\u0242\u0243" + - "\7e\2\2\u0243\u0244\7v\2\2\u0244\30\3\2\2\2\u0245\u0246\7c\2\2\u0246\u0247" + - "\7f\2\2\u0247\u0248\7f\2\2\u0248\32\3\2\2\2\u0249\u024a\7c\2\2\u024a\u024b" + - "\7n\2\2\u024b\u024c\7k\2\2\u024c\u024d\7c\2\2\u024d\u024e\7u\2\2\u024e" + - "\34\3\2\2\2\u024f\u0250\7a\2\2\u0250\u0251\7a\2\2\u0251\u0252\7c\2\2\u0252" + - "\u0253\7t\2\2\u0253\u0254\7i\2\2\u0254\u0255\7n\2\2\u0255\u0256\7k\2\2" + - "\u0256\u0257\7u\2\2\u0257\u0258\7v\2\2\u0258\36\3\2\2\2\u0259\u025a\7" + - "c\2\2\u025a\u025b\7u\2\2\u025b \3\2\2\2\u025c\u025d\7c\2\2\u025d\u025e" + - "\7u\2\2\u025e\u025f\7e\2\2\u025f\u0260\7g\2\2\u0260\u0261\7p\2\2\u0261" + - "\u0262\7f\2\2\u0262\u0263\7k\2\2\u0263\u0264\7p\2\2\u0264\u0265\7i\2\2" + - "\u0265\"\3\2\2\2\u0266\u0267\7c\2\2\u0267\u0268\7u\2\2\u0268\u0269\7{" + - "\2\2\u0269\u026a\7p\2\2\u026a\u026b\7e\2\2\u026b$\3\2\2\2\u026c\u026d" + - "\7c\2\2\u026d\u026e\7y\2\2\u026e\u026f\7c\2\2\u026f\u0270\7k\2\2\u0270" + - "\u0271\7v\2\2\u0271&\3\2\2\2\u0272\u0273\7d\2\2\u0273\u0274\7c\2\2\u0274" + - "\u0275\7u\2\2\u0275\u0276\7g\2\2\u0276(\3\2\2\2\u0277\u0278\7d\2\2\u0278" + - "\u0279\7q\2\2\u0279\u027a\7q\2\2\u027a\u027b\7n\2\2\u027b*\3\2\2\2\u027c" + - "\u027d\7d\2\2\u027d\u027e\7t\2\2\u027e\u027f\7g\2\2\u027f\u0280\7c\2\2" + - "\u0280\u0281\7m\2\2\u0281,\3\2\2\2\u0282\u0283\7d\2\2\u0283\u0284\7{\2" + - "\2\u0284.\3\2\2\2\u0285\u0286\7d\2\2\u0286\u0287\7{\2\2\u0287\u0288\7" + - "v\2\2\u0288\u0289\7g\2\2\u0289\60\3\2\2\2\u028a\u028b\7e\2\2\u028b\u028c" + - "\7c\2\2\u028c\u028d\7u\2\2\u028d\u028e\7g\2\2\u028e\62\3\2\2\2\u028f\u0290" + - "\7e\2\2\u0290\u0291\7c\2\2\u0291\u0292\7v\2\2\u0292\u0293\7e\2\2\u0293" + - "\u0294\7j\2\2\u0294\64\3\2\2\2\u0295\u0296\7e\2\2\u0296\u0297\7j\2\2\u0297" + - "\u0298\7c\2\2\u0298\u0299\7t\2\2\u0299\66\3\2\2\2\u029a\u029b\7e\2\2\u029b" + - "\u029c\7j\2\2\u029c\u029d\7g\2\2\u029d\u029e\7e\2\2\u029e\u029f\7m\2\2" + - "\u029f\u02a0\7g\2\2\u02a0\u02a1\7f\2\2\u02a18\3\2\2\2\u02a2\u02a3\7e\2" + - "\2\u02a3\u02a4\7n\2\2\u02a4\u02a5\7c\2\2\u02a5\u02a6\7u\2\2\u02a6\u02a7" + - "\7u\2\2\u02a7:\3\2\2\2\u02a8\u02a9\7e\2\2\u02a9\u02aa\7q\2\2\u02aa\u02ab" + - "\7p\2\2\u02ab\u02ac\7u\2\2\u02ac\u02ad\7v\2\2\u02ad<\3\2\2\2\u02ae\u02af" + - "\7e\2\2\u02af\u02b0\7q\2\2\u02b0\u02b1\7p\2\2\u02b1\u02b2\7v\2\2\u02b2" + - "\u02b3\7k\2\2\u02b3\u02b4\7p\2\2\u02b4\u02b5\7w\2\2\u02b5\u02b6\7g\2\2" + - "\u02b6>\3\2\2\2\u02b7\u02b8\7f\2\2\u02b8\u02b9\7g\2\2\u02b9\u02ba\7e\2" + - "\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7o\2\2\u02bc\u02bd\7c\2\2\u02bd\u02be" + - "\7n\2\2\u02be@\3\2\2\2\u02bf\u02c0\7f\2\2\u02c0\u02c1\7g\2\2\u02c1\u02c2" + - "\7h\2\2\u02c2\u02c3\7c\2\2\u02c3\u02c4\7w\2\2\u02c4\u02c5\7n\2\2\u02c5" + - "\u02c6\7v\2\2\u02c6B\3\2\2\2\u02c7\u02c8\7f\2\2\u02c8\u02c9\7g\2\2\u02c9" + - "\u02ca\7n\2\2\u02ca\u02cb\7g\2\2\u02cb\u02cc\7i\2\2\u02cc\u02cd\7c\2\2" + - "\u02cd\u02ce\7v\2\2\u02ce\u02cf\7g\2\2\u02cfD\3\2\2\2\u02d0\u02d1\7f\2" + - "\2\u02d1\u02d2\7g\2\2\u02d2\u02d3\7u\2\2\u02d3\u02d4\7e\2\2\u02d4\u02d5" + - "\7g\2\2\u02d5\u02d6\7p\2\2\u02d6\u02d7\7f\2\2\u02d7\u02d8\7k\2\2\u02d8" + - "\u02d9\7p\2\2\u02d9\u02da\7i\2\2\u02daF\3\2\2\2\u02db\u02dc\7f\2\2\u02dc" + - "\u02dd\7q\2\2\u02ddH\3\2\2\2\u02de\u02df\7f\2\2\u02df\u02e0\7q\2\2\u02e0" + - "\u02e1\7w\2\2\u02e1\u02e2\7d\2\2\u02e2\u02e3\7n\2\2\u02e3\u02e4\7g\2\2" + - "\u02e4J\3\2\2\2\u02e5\u02e6\7f\2\2\u02e6\u02e7\7{\2\2\u02e7\u02e8\7p\2" + - "\2\u02e8\u02e9\7c\2\2\u02e9\u02ea\7o\2\2\u02ea\u02eb\7k\2\2\u02eb\u02ec" + - "\7e\2\2\u02ecL\3\2\2\2\u02ed\u02ee\7g\2\2\u02ee\u02ef\7n\2\2\u02ef\u02f0" + - "\7u\2\2\u02f0\u02f1\7g\2\2\u02f1N\3\2\2\2\u02f2\u02f3\7g\2\2\u02f3\u02f4" + - "\7p\2\2\u02f4\u02f5\7w\2\2\u02f5\u02f6\7o\2\2\u02f6P\3\2\2\2\u02f7\u02f8" + - "\7g\2\2\u02f8\u02f9\7s\2\2\u02f9\u02fa\7w\2\2\u02fa\u02fb\7c\2\2\u02fb" + - "\u02fc\7n\2\2\u02fc\u02fd\7u\2\2\u02fdR\3\2\2\2\u02fe\u02ff\7g\2\2\u02ff" + - "\u0300\7x\2\2\u0300\u0301\7g\2\2\u0301\u0302\7p\2\2\u0302\u0303\7v\2\2" + - "\u0303T\3\2\2\2\u0304\u0305\7g\2\2\u0305\u0306\7z\2\2\u0306\u0307\7r\2" + - "\2\u0307\u0308\7n\2\2\u0308\u0309\7k\2\2\u0309\u030a\7e\2\2\u030a\u030b" + - "\7k\2\2\u030b\u030c\7v\2\2\u030cV\3\2\2\2\u030d\u030e\7g\2\2\u030e\u030f" + - "\7z\2\2\u030f\u0310\7v\2\2\u0310\u0311\7g\2\2\u0311\u0312\7t\2\2\u0312" + - "\u0313\7p\2\2\u0313X\3\2\2\2\u0314\u0315\7h\2\2\u0315\u0316\7c\2\2\u0316" + - "\u0317\7n\2\2\u0317\u0318\7u\2\2\u0318\u0319\7g\2\2\u0319Z\3\2\2\2\u031a" + - "\u031b\7h\2\2\u031b\u031c\7k\2\2\u031c\u031d\7p\2\2\u031d\u031e\7c\2\2" + - "\u031e\u031f\7n\2\2\u031f\u0320\7n\2\2\u0320\u0321\7{\2\2\u0321\\\3\2" + - "\2\2\u0322\u0323\7h\2\2\u0323\u0324\7k\2\2\u0324\u0325\7z\2\2\u0325\u0326" + - "\7g\2\2\u0326\u0327\7f\2\2\u0327^\3\2\2\2\u0328\u0329\7h\2\2\u0329\u032a" + - "\7n\2\2\u032a\u032b\7q\2\2\u032b\u032c\7c\2\2\u032c\u032d\7v\2\2\u032d" + - "`\3\2\2\2\u032e\u032f\7h\2\2\u032f\u0330\7q\2\2\u0330\u0331\7t\2\2\u0331" + - "b\3\2\2\2\u0332\u0333\7h\2\2\u0333\u0334\7q\2\2\u0334\u0335\7t\2\2\u0335" + - "\u0336\7g\2\2\u0336\u0337\7c\2\2\u0337\u0338\7e\2\2\u0338\u0339\7j\2\2" + - "\u0339d\3\2\2\2\u033a\u033b\7h\2\2\u033b\u033c\7t\2\2\u033c\u033d\7q\2" + - "\2\u033d\u033e\7o\2\2\u033ef\3\2\2\2\u033f\u0340\7i\2\2\u0340\u0341\7" + - "g\2\2\u0341\u0342\7v\2\2\u0342h\3\2\2\2\u0343\u0344\7i\2\2\u0344\u0345" + - "\7q\2\2\u0345\u0346\7v\2\2\u0346\u0347\7q\2\2\u0347j\3\2\2\2\u0348\u0349" + - "\7i\2\2\u0349\u034a\7t\2\2\u034a\u034b\7q\2\2\u034b\u034c\7w\2\2\u034c" + - "\u034d\7r\2\2\u034dl\3\2\2\2\u034e\u034f\7k\2\2\u034f\u0350\7h\2\2\u0350" + - "n\3\2\2\2\u0351\u0352\7k\2\2\u0352\u0353\7o\2\2\u0353\u0354\7r\2\2\u0354" + - "\u0355\7n\2\2\u0355\u0356\7k\2\2\u0356\u0357\7e\2\2\u0357\u0358\7k\2\2" + - "\u0358\u0359\7v\2\2\u0359p\3\2\2\2\u035a\u035b\7k\2\2\u035b\u035c\7p\2" + - "\2\u035cr\3\2\2\2\u035d\u035e\7k\2\2\u035e\u035f\7p\2\2\u035f\u0360\7" + - "v\2\2\u0360t\3\2\2\2\u0361\u0362\7k\2\2\u0362\u0363\7p\2\2\u0363\u0364" + - "\7v\2\2\u0364\u0365\7g\2\2\u0365\u0366\7t\2\2\u0366\u0367\7h\2\2\u0367" + - "\u0368\7c\2\2\u0368\u0369\7e\2\2\u0369\u036a\7g\2\2\u036av\3\2\2\2\u036b" + - "\u036c\7k\2\2\u036c\u036d\7p\2\2\u036d\u036e\7v\2\2\u036e\u036f\7g\2\2" + - "\u036f\u0370\7t\2\2\u0370\u0371\7p\2\2\u0371\u0372\7c\2\2\u0372\u0373" + - "\7n\2\2\u0373x\3\2\2\2\u0374\u0375\7k\2\2\u0375\u0376\7p\2\2\u0376\u0377" + - "\7v\2\2\u0377\u0378\7q\2\2\u0378z\3\2\2\2\u0379\u037a\7k\2\2\u037a\u037b" + - "\7u\2\2\u037b|\3\2\2\2\u037c\u037d\7l\2\2\u037d\u037e\7q\2\2\u037e\u037f" + - "\7k\2\2\u037f\u0380\7p\2\2\u0380~\3\2\2\2\u0381\u0382\7n\2\2\u0382\u0383" + - "\7g\2\2\u0383\u0384\7v\2\2\u0384\u0080\3\2\2\2\u0385\u0386\7n\2\2\u0386" + - "\u0387\7q\2\2\u0387\u0388\7e\2\2\u0388\u0389\7m\2\2\u0389\u0082\3\2\2" + - "\2\u038a\u038b\7n\2\2\u038b\u038c\7q\2\2\u038c\u038d\7p\2\2\u038d\u038e" + - "\7i\2\2\u038e\u0084\3\2\2\2\u038f\u0390\7p\2\2\u0390\u0391\7c\2\2\u0391" + - "\u0392\7o\2\2\u0392\u0393\7g\2\2\u0393\u0394\7q\2\2\u0394\u0395\7h\2\2" + - "\u0395\u0086\3\2\2\2\u0396\u0397\7p\2\2\u0397\u0398\7c\2\2\u0398\u0399" + - "\7o\2\2\u0399\u039a\7g\2\2\u039a\u039b\7u\2\2\u039b\u039c\7r\2\2\u039c" + - "\u039d\7c\2\2\u039d\u039e\7e\2\2\u039e\u039f\7g\2\2\u039f\u0088\3\2\2" + - "\2\u03a0\u03a1\7p\2\2\u03a1\u03a2\7g\2\2\u03a2\u03a3\7y\2\2\u03a3\u008a" + - "\3\2\2\2\u03a4\u03a5\7p\2\2\u03a5\u03a6\7w\2\2\u03a6\u03a7\7n\2\2\u03a7" + - "\u03a8\7n\2\2\u03a8\u008c\3\2\2\2\u03a9\u03aa\7q\2\2\u03aa\u03ab\7d\2" + - "\2\u03ab\u03ac\7l\2\2\u03ac\u03ad\7g\2\2\u03ad\u03ae\7e\2\2\u03ae\u03af" + - "\7v\2\2\u03af\u008e\3\2\2\2\u03b0\u03b1\7q\2\2\u03b1\u03b2\7p\2\2\u03b2" + - "\u0090\3\2\2\2\u03b3\u03b4\7q\2\2\u03b4\u03b5\7r\2\2\u03b5\u03b6\7g\2" + - "\2\u03b6\u03b7\7t\2\2\u03b7\u03b8\7c\2\2\u03b8\u03b9\7v\2\2\u03b9\u03ba" + - "\7q\2\2\u03ba\u03bb\7t\2\2\u03bb\u0092\3\2\2\2\u03bc\u03bd\7q\2\2\u03bd" + - "\u03be\7t\2\2\u03be\u03bf\7f\2\2\u03bf\u03c0\7g\2\2\u03c0\u03c1\7t\2\2" + - "\u03c1\u03c2\7d\2\2\u03c2\u03c3\7{\2\2\u03c3\u0094\3\2\2\2\u03c4\u03c5" + - "\7q\2\2\u03c5\u03c6\7w\2\2\u03c6\u03c7\7v\2\2\u03c7\u0096\3\2\2\2\u03c8" + - "\u03c9\7q\2\2\u03c9\u03ca\7x\2\2\u03ca\u03cb\7g\2\2\u03cb\u03cc\7t\2\2" + - "\u03cc\u03cd\7t\2\2\u03cd\u03ce\7k\2\2\u03ce\u03cf\7f\2\2\u03cf\u03d0" + - "\7g\2\2\u03d0\u0098\3\2\2\2\u03d1\u03d2\7r\2\2\u03d2\u03d3\7c\2\2\u03d3" + - "\u03d4\7t\2\2\u03d4\u03d5\7c\2\2\u03d5\u03d6\7o\2\2\u03d6\u03d7\7u\2\2" + - "\u03d7\u009a\3\2\2\2\u03d8\u03d9\7r\2\2\u03d9\u03da\7c\2\2\u03da\u03db" + - "\7t\2\2\u03db\u03dc\7v\2\2\u03dc\u03dd\7k\2\2\u03dd\u03de\7c\2\2\u03de" + - "\u03df\7n\2\2\u03df\u009c\3\2\2\2\u03e0\u03e1\7r\2\2\u03e1\u03e2\7t\2" + - "\2\u03e2\u03e3\7k\2\2\u03e3\u03e4\7x\2\2\u03e4\u03e5\7c\2\2\u03e5\u03e6" + - "\7v\2\2\u03e6\u03e7\7g\2\2\u03e7\u009e\3\2\2\2\u03e8\u03e9\7r\2\2\u03e9" + - "\u03ea\7t\2\2\u03ea\u03eb\7q\2\2\u03eb\u03ec\7v\2\2\u03ec\u03ed\7g\2\2" + - "\u03ed\u03ee\7e\2\2\u03ee\u03ef\7v\2\2\u03ef\u03f0\7g\2\2\u03f0\u03f1" + - "\7f\2\2\u03f1\u00a0\3\2\2\2\u03f2\u03f3\7r\2\2\u03f3\u03f4\7w\2\2\u03f4" + - "\u03f5\7d\2\2\u03f5\u03f6\7n\2\2\u03f6\u03f7\7k\2\2\u03f7\u03f8\7e\2\2" + - "\u03f8\u00a2\3\2\2\2\u03f9\u03fa\7t\2\2\u03fa\u03fb\7g\2\2\u03fb\u03fc" + - "\7c\2\2\u03fc\u03fd\7f\2\2\u03fd\u03fe\7q\2\2\u03fe\u03ff\7p\2\2\u03ff" + - "\u0400\7n\2\2\u0400\u0401\7{\2\2\u0401\u00a4\3\2\2\2\u0402\u0403\7t\2" + - "\2\u0403\u0404\7g\2\2\u0404\u0405\7h\2\2\u0405\u00a6\3\2\2\2\u0406\u0407" + - "\7t\2\2\u0407\u0408\7g\2\2\u0408\u0409\7o\2\2\u0409\u040a\7q\2\2\u040a" + - "\u040b\7x\2\2\u040b\u040c\7g\2\2\u040c\u00a8\3\2\2\2\u040d\u040e\7t\2" + - "\2\u040e\u040f\7g\2\2\u040f\u0410\7v\2\2\u0410\u0411\7w\2\2\u0411\u0412" + - "\7t\2\2\u0412\u0413\7p\2\2\u0413\u00aa\3\2\2\2\u0414\u0415\7u\2\2\u0415" + - "\u0416\7d\2\2\u0416\u0417\7{\2\2\u0417\u0418\7v\2\2\u0418\u0419\7g\2\2" + - "\u0419\u00ac\3\2\2\2\u041a\u041b\7u\2\2\u041b\u041c\7g\2\2\u041c\u041d" + - "\7c\2\2\u041d\u041e\7n\2\2\u041e\u041f\7g\2\2\u041f\u0420\7f\2\2\u0420" + - "\u00ae\3\2\2\2\u0421\u0422\7u\2\2\u0422\u0423\7g\2\2\u0423\u0424\7n\2" + - "\2\u0424\u0425\7g\2\2\u0425\u0426\7e\2\2\u0426\u0427\7v\2\2\u0427\u00b0" + - "\3\2\2\2\u0428\u0429\7u\2\2\u0429\u042a\7g\2\2\u042a\u042b\7v\2\2\u042b" + - "\u00b2\3\2\2\2\u042c\u042d\7u\2\2\u042d\u042e\7j\2\2\u042e\u042f\7q\2" + - "\2\u042f\u0430\7t\2\2\u0430\u0431\7v\2\2\u0431\u00b4\3\2\2\2\u0432\u0433" + - "\7u\2\2\u0433\u0434\7k\2\2\u0434\u0435\7|\2\2\u0435\u0436\7g\2\2\u0436" + - "\u0437\7q\2\2\u0437\u0438\7h\2\2\u0438\u00b6\3\2\2\2\u0439\u043a\7u\2" + - "\2\u043a\u043b\7v\2\2\u043b\u043c\7c\2\2\u043c\u043d\7e\2\2\u043d\u043e" + - "\7m\2\2\u043e\u043f\7c\2\2\u043f\u0440\7n\2\2\u0440\u0441\7n\2\2\u0441" + - "\u0442\7q\2\2\u0442\u0443\7e\2\2\u0443\u00b8\3\2\2\2\u0444\u0445\7u\2" + - "\2\u0445\u0446\7v\2\2\u0446\u0447\7c\2\2\u0447\u0448\7v\2\2\u0448\u0449" + - "\7k\2\2\u0449\u044a\7e\2\2\u044a\u00ba\3\2\2\2\u044b\u044c\7u\2\2\u044c" + - "\u044d\7v\2\2\u044d\u044e\7t\2\2\u044e\u044f\7k\2\2\u044f\u0450\7p\2\2" + - "\u0450\u0451\7i\2\2\u0451\u00bc\3\2\2\2\u0452\u0453\7u\2\2\u0453\u0454" + - "\7v\2\2\u0454\u0455\7t\2\2\u0455\u0456\7w\2\2\u0456\u0457\7e\2\2\u0457" + - "\u0458\7v\2\2\u0458\u00be\3\2\2\2\u0459\u045a\7u\2\2\u045a\u045b\7y\2" + - "\2\u045b\u045c\7k\2\2\u045c\u045d\7v\2\2\u045d\u045e\7e\2\2\u045e\u045f" + - "\7j\2\2\u045f\u00c0\3\2\2\2\u0460\u0461\7v\2\2\u0461\u0462\7j\2\2\u0462" + - "\u0463\7k\2\2\u0463\u0464\7u\2\2\u0464\u00c2\3\2\2\2\u0465\u0466\7v\2" + - "\2\u0466\u0467\7j\2\2\u0467\u0468\7t\2\2\u0468\u0469\7q\2\2\u0469\u046a" + - "\7y\2\2\u046a\u00c4\3\2\2\2\u046b\u046c\7v\2\2\u046c\u046d\7t\2\2\u046d" + - "\u046e\7w\2\2\u046e\u046f\7g\2\2\u046f\u00c6\3\2\2\2\u0470\u0471\7v\2" + - "\2\u0471\u0472\7t\2\2\u0472\u0473\7{\2\2\u0473\u00c8\3\2\2\2\u0474\u0475" + - "\7v\2\2\u0475\u0476\7{\2\2\u0476\u0477\7r\2\2\u0477\u0478\7g\2\2\u0478" + - "\u0479\7q\2\2\u0479\u047a\7h\2\2\u047a\u00ca\3\2\2\2\u047b\u047c\7w\2" + - "\2\u047c\u047d\7k\2\2\u047d\u047e\7p\2\2\u047e\u047f\7v\2\2\u047f\u00cc" + - "\3\2\2\2\u0480\u0481\7w\2\2\u0481\u0482\7n\2\2\u0482\u0483\7q\2\2\u0483" + - "\u0484\7p\2\2\u0484\u0485\7i\2\2\u0485\u00ce\3\2\2\2\u0486\u0487\7w\2" + - "\2\u0487\u0488\7p\2\2\u0488\u0489\7e\2\2\u0489\u048a\7j\2\2\u048a\u048b" + - "\7g\2\2\u048b\u048c\7e\2\2\u048c\u048d\7m\2\2\u048d\u048e\7g\2\2\u048e" + - "\u048f\7f\2\2\u048f\u00d0\3\2\2\2\u0490\u0491\7w\2\2\u0491\u0492\7p\2" + - "\2\u0492\u0493\7o\2\2\u0493\u0494\7c\2\2\u0494\u0495\7p\2\2\u0495\u0496" + - "\7c\2\2\u0496\u0497\7i\2\2\u0497\u0498\7g\2\2\u0498\u0499\7f\2\2\u0499" + - "\u00d2\3\2\2\2\u049a\u049b\7w\2\2\u049b\u049c\7p\2\2\u049c\u049d\7u\2" + - "\2\u049d\u049e\7c\2\2\u049e\u049f\7h\2\2\u049f\u04a0\7g\2\2\u04a0\u00d4" + - "\3\2\2\2\u04a1\u04a2\7w\2\2\u04a2\u04a3\7u\2\2\u04a3\u04a4\7j\2\2\u04a4" + - "\u04a5\7q\2\2\u04a5\u04a6\7t\2\2\u04a6\u04a7\7v\2\2\u04a7\u00d6\3\2\2" + - "\2\u04a8\u04a9\7w\2\2\u04a9\u04aa\7u\2\2\u04aa\u04ab\7k\2\2\u04ab\u04ac" + - "\7p\2\2\u04ac\u04ad\7i\2\2\u04ad\u00d8\3\2\2\2\u04ae\u04af\7x\2\2\u04af" + - "\u04b0\7c\2\2\u04b0\u04b1\7t\2\2\u04b1\u00da\3\2\2\2\u04b2\u04b3\7x\2" + - "\2\u04b3\u04b4\7k\2\2\u04b4\u04b5\7t\2\2\u04b5\u04b6\7v\2\2\u04b6\u04b7" + - "\7w\2\2\u04b7\u04b8\7c\2\2\u04b8\u04b9\7n\2\2\u04b9\u00dc\3\2\2\2\u04ba" + - "\u04bb\7x\2\2\u04bb\u04bc\7q\2\2\u04bc\u04bd\7k\2\2\u04bd\u04be\7f\2\2" + - "\u04be\u00de\3\2\2\2\u04bf\u04c0\7x\2\2\u04c0\u04c1\7q\2\2\u04c1\u04c2" + - "\7n\2\2\u04c2\u04c3\7c\2\2\u04c3\u04c4\7v\2\2\u04c4\u04c5\7k\2\2\u04c5" + - "\u04c6\7n\2\2\u04c6\u04c7\7g\2\2\u04c7\u00e0\3\2\2\2\u04c8\u04c9\7y\2" + - "\2\u04c9\u04ca\7j\2\2\u04ca\u04cb\7g\2\2\u04cb\u04cc\7p\2\2\u04cc\u00e2" + - "\3\2\2\2\u04cd\u04ce\7y\2\2\u04ce\u04cf\7j\2\2\u04cf\u04d0\7g\2\2\u04d0" + - "\u04d1\7t\2\2\u04d1\u04d2\7g\2\2\u04d2\u00e4\3\2\2\2\u04d3\u04d4\7y\2" + - "\2\u04d4\u04d5\7j\2\2\u04d5\u04d6\7k\2\2\u04d6\u04d7\7n\2\2\u04d7\u04d8" + - "\7g\2\2\u04d8\u00e6\3\2\2\2\u04d9\u04da\7{\2\2\u04da\u04db\7k\2\2\u04db" + - "\u04dc\7g\2\2\u04dc\u04dd\7n\2\2\u04dd\u04de\7f\2\2\u04de\u00e8\3\2\2" + - "\2\u04df\u04e1\7B\2\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u04e2" + - "\3\2\2\2\u04e2\u04e3\5\u01c5\u00e1\2\u04e3\u00ea\3\2\2\2\u04e4\u04ee\t" + - "\3\2\2\u04e5\u04e7\7a\2\2\u04e6\u04e5\3\2\2\2\u04e7\u04ea\3\2\2\2\u04e8" + - "\u04e6\3\2\2\2\u04e8\u04e9\3\2\2\2\u04e9\u04eb\3\2\2\2\u04ea\u04e8\3\2" + - "\2\2\u04eb\u04ed\t\3\2\2\u04ec\u04e8\3\2\2\2\u04ed\u04f0\3\2\2\2\u04ee" + - "\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f2\3\2\2\2\u04f0\u04ee\3\2" + - "\2\2\u04f1\u04f3\5\u01b5\u00d9\2\u04f2\u04f1\3\2\2\2\u04f2\u04f3\3\2\2" + - "\2\u04f3\u04f4\3\2\2\2\u04f4\u04f6\7\60\2\2\u04f5\u04f7\7B\2\2\u04f6\u04f5" + - "\3\2\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u04f9\5\u01c5\u00e1" + - "\2\u04f9\u00ec\3\2\2\2\u04fa\u0504\t\3\2\2\u04fb\u04fd\7a\2\2\u04fc\u04fb" + - "\3\2\2\2\u04fd\u0500\3\2\2\2\u04fe\u04fc\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff" + - "\u0501\3\2\2\2\u0500\u04fe\3\2\2\2\u0501\u0503\t\3\2\2\u0502\u04fe\3\2" + - "\2\2\u0503\u0506\3\2\2\2\u0504\u0502\3\2\2\2\u0504\u0505\3\2\2\2\u0505" + - "\u0508\3\2\2\2\u0506\u0504\3\2\2\2\u0507\u0509\5\u01b5\u00d9\2\u0508\u0507" + - "\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u00ee\3\2\2\2\u050a\u050b\7\62\2\2" + - "\u050b\u0513\t\4\2\2\u050c\u050e\7a\2\2\u050d\u050c\3\2\2\2\u050e\u0511" + - "\3\2\2\2\u050f\u050d\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512\3\2\2\2\u0511" + - "\u050f\3\2\2\2\u0512\u0514\5\u01d7\u00ea\2\u0513\u050f\3\2\2\2\u0514\u0515" + - "\3\2\2\2\u0515\u0513\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0518\3\2\2\2\u0517" + - "\u0519\5\u01b5\u00d9\2\u0518\u0517\3\2\2\2\u0518\u0519\3\2\2\2\u0519\u00f0" + - "\3\2\2\2\u051a\u051b\7\62\2\2\u051b\u0523\t\5\2\2\u051c\u051e\7a\2\2\u051d" + - "\u051c\3\2\2\2\u051e\u0521\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520\3\2" + - "\2\2\u0520\u0522\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\t\6\2\2\u0523" + - "\u051f\3\2\2\2\u0524\u0525\3\2\2\2\u0525\u0523\3\2\2\2\u0525\u0526\3\2" + - "\2\2\u0526\u0528\3\2\2\2\u0527\u0529\5\u01b5\u00d9\2\u0528\u0527\3\2\2" + - "\2\u0528\u0529\3\2\2\2\u0529\u00f2\3\2\2\2\u052a\u0534\t\3\2\2\u052b\u052d" + - "\7a\2\2\u052c\u052b\3\2\2\2\u052d\u0530\3\2\2\2\u052e\u052c\3\2\2\2\u052e" + - "\u052f\3\2\2\2\u052f\u0531\3\2\2\2\u0530\u052e\3\2\2\2\u0531\u0533\t\3" + - "\2\2\u0532\u052e\3\2\2\2\u0533\u0536\3\2\2\2\u0534\u0532\3\2\2\2\u0534" + - "\u0535\3\2\2\2\u0535\u0538\3\2\2\2\u0536\u0534\3\2\2\2\u0537\u052a\3\2" + - "\2\2\u0537\u0538\3\2\2\2\u0538\u0539\3\2\2\2\u0539\u053a\7\60\2\2\u053a" + - "\u0544\t\3\2\2\u053b\u053d\7a\2\2\u053c\u053b\3\2\2\2\u053d\u0540\3\2" + - "\2\2\u053e\u053c\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0541\3\2\2\2\u0540" + - "\u053e\3\2\2\2\u0541\u0543\t\3\2\2\u0542\u053e\3\2\2\2\u0543\u0546\3\2" + - "\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0548\3\2\2\2\u0546" + - "\u0544\3\2\2\2\u0547\u0549\5\u01b7\u00da\2\u0548\u0547\3\2\2\2\u0548\u0549" + - "\3\2\2\2\u0549\u054b\3\2\2\2\u054a\u054c\t\7\2\2\u054b\u054a\3\2\2\2\u054b" + - "\u054c\3\2\2\2\u054c\u0562\3\2\2\2\u054d\u0557\t\3\2\2\u054e\u0550\7a" + - "\2\2\u054f\u054e\3\2\2\2\u0550\u0553\3\2\2\2\u0551\u054f\3\2\2\2\u0551" + - "\u0552\3\2\2\2\u0552\u0554\3\2\2\2\u0553\u0551\3\2\2\2\u0554\u0556\t\3" + - "\2\2\u0555\u0551\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555\3\2\2\2\u0557" + - "\u0558\3\2\2\2\u0558\u055f\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u0560\t\7" + - "\2\2\u055b\u055d\5\u01b7\u00da\2\u055c\u055e\t\7\2\2\u055d\u055c\3\2\2" + - "\2\u055d\u055e\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055a\3\2\2\2\u055f\u055b" + - "\3\2\2\2\u0560\u0562\3\2\2\2\u0561\u0537\3\2\2\2\u0561\u054d\3\2\2\2\u0562" + - "\u00f4\3\2\2\2\u0563\u0566\7)\2\2\u0564\u0567\n\b\2\2\u0565\u0567\5\u01b9" + - "\u00db\2\u0566\u0564\3\2\2\2\u0566\u0565\3\2\2\2\u0567\u0568\3\2\2\2\u0568" + - "\u0569\7)\2\2\u0569\u00f6\3\2\2\2\u056a\u056f\7$\2\2\u056b\u056e\n\t\2" + - "\2\u056c\u056e\5\u01b9\u00db\2\u056d\u056b\3\2\2\2\u056d\u056c\3\2\2\2" + - "\u056e\u0571\3\2\2\2\u056f\u056d\3\2\2\2\u056f\u0570\3\2\2\2\u0570\u0572" + - "\3\2\2\2\u0571\u056f\3\2\2\2\u0572\u0573\7$\2\2\u0573\u00f8\3\2\2\2\u0574" + - "\u0575\7B\2\2\u0575\u0576\7$\2\2\u0576\u057c\3\2\2\2\u0577\u057b\n\n\2" + - "\2\u0578\u0579\7$\2\2\u0579\u057b\7$\2\2\u057a\u0577\3\2\2\2\u057a\u0578" + - "\3\2\2\2\u057b\u057e\3\2\2\2\u057c\u057a\3\2\2\2\u057c\u057d\3\2\2\2\u057d" + - "\u057f\3\2\2\2\u057e\u057c\3\2\2\2\u057f\u0580\7$\2\2\u0580\u00fa\3\2" + - "\2\2\u0581\u0582\7&\2\2\u0582\u0583\7$\2\2\u0583\u0584\3\2\2\2\u0584\u0585" + - "\b|\5\2\u0585\u0586\3\2\2\2\u0586\u0587\b|\6\2\u0587\u00fc\3\2\2\2\u0588" + - "\u0589\7&\2\2\u0589\u058a\7B\2\2\u058a\u058b\7$\2\2\u058b\u058c\3\2\2" + - "\2\u058c\u058d\b}\7\2\u058d\u058e\3\2\2\2\u058e\u058f\b}\6\2\u058f\u00fe" + - "\3\2\2\2\u0590\u0591\7}\2\2\u0591\u0592\b~\b\2\u0592\u0100\3\2\2\2\u0593" + - "\u0594\7\177\2\2\u0594\u0595\b\177\t\2\u0595\u0102\3\2\2\2\u0596\u0597" + - "\7]\2\2\u0597\u0104\3\2\2\2\u0598\u0599\7_\2\2\u0599\u0106\3\2\2\2\u059a" + - "\u059b\7*\2\2\u059b\u0108\3\2\2\2\u059c\u059d\7+\2\2\u059d\u010a\3\2\2" + - "\2\u059e\u059f\7\60\2\2\u059f\u010c\3\2\2\2\u05a0\u05a1\7.\2\2\u05a1\u010e" + - "\3\2\2\2\u05a2\u05a3\7<\2\2\u05a3\u05a4\b\u0086\n\2\u05a4\u0110\3\2\2" + - "\2\u05a5\u05a6\7=\2\2\u05a6\u0112\3\2\2\2\u05a7\u05a8\7-\2\2\u05a8\u0114" + - "\3\2\2\2\u05a9\u05aa\7/\2\2\u05aa\u0116\3\2\2\2\u05ab\u05ac\7,\2\2\u05ac" + - "\u0118\3\2\2\2\u05ad\u05ae\7\61\2\2\u05ae\u011a\3\2\2\2\u05af\u05b0\7" + - "\'\2\2\u05b0\u011c\3\2\2\2\u05b1\u05b2\7(\2\2\u05b2\u011e\3\2\2\2\u05b3" + - "\u05b4\7~\2\2\u05b4\u0120\3\2\2\2\u05b5\u05b6\7`\2\2\u05b6\u0122\3\2\2" + - "\2\u05b7\u05b8\7#\2\2\u05b8\u0124\3\2\2\2\u05b9\u05ba\7\u0080\2\2\u05ba" + - "\u0126\3\2\2\2\u05bb\u05bc\7?\2\2\u05bc\u0128\3\2\2\2\u05bd\u05be\7>\2" + - "\2\u05be\u012a\3\2\2\2\u05bf\u05c0\7@\2\2\u05c0\u012c\3\2\2\2\u05c1\u05c2" + - "\7A\2\2\u05c2\u012e\3\2\2\2\u05c3\u05c4\7<\2\2\u05c4\u05c5\7<\2\2\u05c5" + - "\u0130\3\2\2\2\u05c6\u05c7\7A\2\2\u05c7\u05c8\7A\2\2\u05c8\u0132\3\2\2" + - "\2\u05c9\u05ca\7-\2\2\u05ca\u05cb\7-\2\2\u05cb\u0134\3\2\2\2\u05cc\u05cd" + - "\7/\2\2\u05cd\u05ce\7/\2\2\u05ce\u0136\3\2\2\2\u05cf\u05d0\7(\2\2\u05d0" + - "\u05d1\7(\2\2\u05d1\u0138\3\2\2\2\u05d2\u05d3\7~\2\2\u05d3\u05d4\7~\2" + - "\2\u05d4\u013a\3\2\2\2\u05d5\u05d6\7/\2\2\u05d6\u05d7\7@\2\2\u05d7\u013c" + - "\3\2\2\2\u05d8\u05d9\7?\2\2\u05d9\u05da\7?\2\2\u05da\u013e\3\2\2\2\u05db" + - "\u05dc\7#\2\2\u05dc\u05dd\7?\2\2\u05dd\u0140\3\2\2\2\u05de\u05df\7>\2" + - "\2\u05df\u05e0\7?\2\2\u05e0\u0142\3\2\2\2\u05e1\u05e2\7@\2\2\u05e2\u05e3" + - "\7?\2\2\u05e3\u0144\3\2\2\2\u05e4\u05e5\7-\2\2\u05e5\u05e6\7?\2\2\u05e6" + - "\u0146\3\2\2\2\u05e7\u05e8\7/\2\2\u05e8\u05e9\7?\2\2\u05e9\u0148\3\2\2" + - "\2\u05ea\u05eb\7,\2\2\u05eb\u05ec\7?\2\2\u05ec\u014a\3\2\2\2\u05ed\u05ee" + - "\7\61\2\2\u05ee\u05ef\7?\2\2\u05ef\u014c\3\2\2\2\u05f0\u05f1\7\'\2\2\u05f1" + - "\u05f2\7?\2\2\u05f2\u014e\3\2\2\2\u05f3\u05f4\7(\2\2\u05f4\u05f5\7?\2" + - "\2\u05f5\u0150\3\2\2\2\u05f6\u05f7\7~\2\2\u05f7\u05f8\7?\2\2\u05f8\u0152" + - "\3\2\2\2\u05f9\u05fa\7`\2\2\u05fa\u05fb\7?\2\2\u05fb\u0154\3\2\2\2\u05fc" + - "\u05fd\7>\2\2\u05fd\u05fe\7>\2\2\u05fe\u0156\3\2\2\2\u05ff\u0600\7>\2" + - "\2\u0600\u0601\7>\2\2\u0601\u0602\7?\2\2\u0602\u0158\3\2\2\2\u0603\u0604" + - "\7A\2\2\u0604\u0605\7A\2\2\u0605\u0606\7?\2\2\u0606\u015a\3\2\2\2\u0607" + - "\u0608\7\60\2\2\u0608\u0609\7\60\2\2\u0609\u015c\3\2\2\2\u060a\u060b\7" + - "}\2\2\u060b\u060c\7}\2\2\u060c\u015e\3\2\2\2\u060d\u060e\7}\2\2\u060e" + - "\u060f\b\u00ae\13\2\u060f\u0610\3\2\2\2\u0610\u0611\b\u00ae\f\2\u0611" + - "\u0612\b\u00ae\r\2\u0612\u0160\3\2\2\2\u0613\u0614\6\u00af\2\2\u0614\u0615" + - "\5\u01bb\u00dc\2\u0615\u0162\3\2\2\2\u0616\u0617\6\u00b0\3\2\u0617\u0618" + - "\7$\2\2\u0618\u0619\7$\2\2\u0619\u0164\3\2\2\2\u061a\u061b\7$\2\2\u061b" + - "\u061c\b\u00b1\16\2\u061c\u061d\3\2\2\2\u061d\u061e\b\u00b1\17\2\u061e" + - "\u0166\3\2\2\2\u061f\u0621\6\u00b2\4\2\u0620\u0622\n\13\2\2\u0621\u0620" + - "\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0621\3\2\2\2\u0623\u0624\3\2\2\2\u0624" + - "\u0168\3\2\2\2\u0625\u0627\6\u00b3\5\2\u0626\u0628\n\f\2\2\u0627\u0626" + - "\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u0627\3\2\2\2\u0629\u062a\3\2\2\2\u062a" + - "\u016a\3\2\2\2\u062b\u062c\7\177\2\2\u062c\u062d\7\177\2\2\u062d\u062e" + - "\3\2\2\2\u062e\u062f\b\u00b4\20\2\u062f\u016c\3\2\2\2\u0630\u0631\7\177" + - "\2\2\u0631\u0632\b\u00b5\21\2\u0632\u0633\3\2\2\2\u0633\u0634\b\u00b5" + - "\f\2\u0634\u0635\b\u00b5\17\2\u0635\u016e\3\2\2\2\u0636\u0638\n\r\2\2" + - "\u0637\u0636\3\2\2\2\u0638\u0639\3\2\2\2\u0639\u0637\3\2\2\2\u0639\u063a" + - "\3\2\2\2\u063a\u0170\3\2\2\2\u063b\u063d\5\u01c1\u00df\2\u063c\u063b\3" + - "\2\2\2\u063d\u063e\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f" + - "\u0640\3\2\2\2\u0640\u0641\b\u00b7\3\2\u0641\u0172\3\2\2\2\u0642\u0644" + - "\t\3\2\2\u0643\u0642\3\2\2\2\u0644\u0645\3\2\2\2\u0645\u0643\3\2\2\2\u0645" + - "\u0646\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0648\b\u00b8\22\2\u0648\u0174" + - "\3\2\2\2\u0649\u064a\7v\2\2\u064a\u064b\7t\2\2\u064b\u064c\7w\2\2\u064c" + - "\u064d\7g\2\2\u064d\u064e\3\2\2\2\u064e\u064f\b\u00b9\22\2\u064f\u0650" + - "\b\u00b9\23\2\u0650\u0176\3\2\2\2\u0651\u0652\7h\2\2\u0652\u0653\7c\2" + - "\2\u0653\u0654\7n\2\2\u0654\u0655\7u\2\2\u0655\u0656\7g\2\2\u0656\u0657" + - "\3\2\2\2\u0657\u0658\b\u00ba\22\2\u0658\u0659\b\u00ba\24\2\u0659\u0178" + - "\3\2\2\2\u065a\u065b\7f\2\2\u065b\u065c\7g\2\2\u065c\u065d\7h\2\2\u065d" + - "\u065e\7k\2\2\u065e\u065f\7p\2\2\u065f\u0660\7g\2\2\u0660\u0661\3\2\2" + - "\2\u0661\u0662\b\u00bb\22\2\u0662\u017a\3\2\2\2\u0663\u0664\7w\2\2\u0664" + - "\u0665\7p\2\2\u0665\u0666\7f\2\2\u0666\u0667\7g\2\2\u0667\u0668\7h\2\2" + - "\u0668\u0669\3\2\2\2\u0669\u066a\b\u00bc\22\2\u066a\u017c\3\2\2\2\u066b" + - "\u066c\7k\2\2\u066c\u066d\7h\2\2\u066d\u066e\3\2\2\2\u066e\u066f\b\u00bd" + - "\22\2\u066f\u0670\b\u00bd\25\2\u0670\u017e\3\2\2\2\u0671\u0672\7g\2\2" + - "\u0672\u0673\7n\2\2\u0673\u0674\7k\2\2\u0674\u0675\7h\2\2\u0675\u0676" + - "\3\2\2\2\u0676\u0677\b\u00be\22\2\u0677\u0180\3\2\2\2\u0678\u0679\7g\2" + - "\2\u0679\u067a\7n\2\2\u067a\u067b\7u\2\2\u067b\u067c\7g\2\2\u067c\u067d" + - "\3\2\2\2\u067d\u067e\b\u00bf\22\2\u067e\u067f\b\u00bf\26\2\u067f\u0182" + - "\3\2\2\2\u0680\u0681\7g\2\2\u0681\u0682\7p\2\2\u0682\u0683\7f\2\2\u0683" + - "\u0684\7k\2\2\u0684\u0685\7h\2\2\u0685\u0686\3\2\2\2\u0686\u0687\b\u00c0" + - "\22\2\u0687\u0184\3\2\2\2\u0688\u0689\7n\2\2\u0689\u068a\7k\2\2\u068a" + - "\u068b\7p\2\2\u068b\u068c\7g\2\2\u068c\u068d\3\2\2\2\u068d\u068e\b\u00c1" + - "\22\2\u068e\u0186\3\2\2\2\u068f\u0690\7g\2\2\u0690\u0691\7t\2\2\u0691" + - "\u0692\7t\2\2\u0692\u0693\7q\2\2\u0693\u0694\7t\2\2\u0694\u0696\3\2\2" + - "\2\u0695\u0697\5\u01c1\u00df\2\u0696\u0695\3\2\2\2\u0697\u0698\3\2\2\2" + - "\u0698\u0696\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069b" + - "\b\u00c2\22\2\u069b\u069c\b\u00c2\27\2\u069c\u0188\3\2\2\2\u069d\u069e" + - "\7y\2\2\u069e\u069f\7c\2\2\u069f\u06a0\7t\2\2\u06a0\u06a1\7p\2\2\u06a1" + - "\u06a2\7k\2\2\u06a2\u06a3\7p\2\2\u06a3\u06a4\7i\2\2\u06a4\u06a6\3\2\2" + - "\2\u06a5\u06a7\5\u01c1\u00df\2\u06a6\u06a5\3\2\2\2\u06a7\u06a8\3\2\2\2" + - "\u06a8\u06a6\3\2\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06ab" + - "\b\u00c3\22\2\u06ab\u06ac\b\u00c3\27\2\u06ac\u018a\3\2\2\2\u06ad\u06ae" + - "\7t\2\2\u06ae\u06af\7g\2\2\u06af\u06b0\7i\2\2\u06b0\u06b1\7k\2\2\u06b1" + - "\u06b2\7q\2\2\u06b2\u06b3\7p\2\2\u06b3\u06b7\3\2\2\2\u06b4\u06b6\5\u01c1" + - "\u00df\2\u06b5\u06b4\3\2\2\2\u06b6\u06b9\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b7" + - "\u06b8\3\2\2\2\u06b8\u06ba\3\2\2\2\u06b9\u06b7\3\2\2\2\u06ba\u06bb\b\u00c4" + - "\22\2\u06bb\u06bc\b\u00c4\27\2\u06bc\u018c\3\2\2\2\u06bd\u06be\7g\2\2" + - "\u06be\u06bf\7p\2\2\u06bf\u06c0\7f\2\2\u06c0\u06c1\7t\2\2\u06c1\u06c2" + - "\7g\2\2\u06c2\u06c3\7i\2\2\u06c3\u06c4\7k\2\2\u06c4\u06c5\7q\2\2\u06c5" + - "\u06c6\7p\2\2\u06c6\u06ca\3\2\2\2\u06c7\u06c9\5\u01c1\u00df\2\u06c8\u06c7" + - "\3\2\2\2\u06c9\u06cc\3\2\2\2\u06ca\u06c8\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb" + - "\u06cd\3\2\2\2\u06cc\u06ca\3\2\2\2\u06cd\u06ce\b\u00c5\22\2\u06ce\u06cf" + - "\b\u00c5\27\2\u06cf\u018e\3\2\2\2\u06d0\u06d1\7r\2\2\u06d1\u06d2\7t\2" + - "\2\u06d2\u06d3\7c\2\2\u06d3\u06d4\7i\2\2\u06d4\u06d5\7o\2\2\u06d5\u06d6" + - "\7c\2\2\u06d6\u06d8\3\2\2\2\u06d7\u06d9\5\u01c1\u00df\2\u06d8\u06d7\3" + - "\2\2\2\u06d9\u06da\3\2\2\2\u06da\u06d8\3\2\2\2\u06da\u06db\3\2\2\2\u06db" + - "\u06dc\3\2\2\2\u06dc\u06dd\b\u00c6\22\2\u06dd\u06de\b\u00c6\27\2\u06de" + - "\u0190\3\2\2\2\u06df\u06e0\7p\2\2\u06e0\u06e1\7w\2\2\u06e1\u06e2\7n\2" + - "\2\u06e2\u06e3\7n\2\2\u06e3\u06e4\7c\2\2\u06e4\u06e5\7d\2\2\u06e5\u06e6" + - "\7n\2\2\u06e6\u06e7\7g\2\2\u06e7\u06e9\3\2\2\2\u06e8\u06ea\5\u01c1\u00df" + - "\2\u06e9\u06e8\3\2\2\2\u06ea\u06eb\3\2\2\2\u06eb\u06e9\3\2\2\2\u06eb\u06ec" + - "\3\2\2\2\u06ec\u06ed\3\2\2\2\u06ed\u06ee\b\u00c7\22\2\u06ee\u06ef\b\u00c7" + - "\27\2\u06ef\u0192\3\2\2\2\u06f0\u06f1\7f\2\2\u06f1\u06f2\7g\2\2\u06f2" + - "\u06f3\7h\2\2\u06f3\u06f4\7c\2\2\u06f4\u06f5\7w\2\2\u06f5\u06f6\7n\2\2" + - "\u06f6\u06f7\7v\2\2\u06f7\u06f8\3\2\2\2\u06f8\u06f9\b\u00c8\22\2\u06f9" + - "\u06fa\b\u00c8\30\2\u06fa\u0194\3\2\2\2\u06fb\u06fc\7j\2\2\u06fc\u06fd" + - "\7k\2\2\u06fd\u06fe\7f\2\2\u06fe\u06ff\7f\2\2\u06ff\u0700\7g\2\2\u0700" + - "\u0701\7p\2\2\u0701\u0702\3\2\2\2\u0702\u0703\b\u00c9\22\2\u0703\u0196" + - "\3\2\2\2\u0704\u0705\7*\2\2\u0705\u0706\3\2\2\2\u0706\u0707\b\u00ca\22" + - "\2\u0707\u0708\b\u00ca\31\2\u0708\u0198\3\2\2\2\u0709\u070a\7+\2\2\u070a" + - "\u070b\3\2\2\2\u070b\u070c\b\u00cb\22\2\u070c\u070d\b\u00cb\32\2\u070d" + - "\u019a\3\2\2\2\u070e\u070f\7#\2\2\u070f\u0710\3\2\2\2\u0710\u0711\b\u00cc" + - "\22\2\u0711\u0712\b\u00cc\33\2\u0712\u019c\3\2\2\2\u0713\u0714\7?\2\2" + - "\u0714\u0715\7?\2\2\u0715\u0716\3\2\2\2\u0716\u0717\b\u00cd\22\2\u0717" + - "\u0718\b\u00cd\34\2\u0718\u019e\3\2\2\2\u0719\u071a\7#\2\2\u071a\u071b" + - "\7?\2\2\u071b\u071c\3\2\2\2\u071c\u071d\b\u00ce\22\2\u071d\u071e\b\u00ce" + - "\35\2\u071e\u01a0\3\2\2\2\u071f\u0720\7(\2\2\u0720\u0721\7(\2\2\u0721" + - "\u0722\3\2\2\2\u0722\u0723\b\u00cf\22\2\u0723\u0724\b\u00cf\36\2\u0724" + - "\u01a2\3\2\2\2\u0725\u0726\7~\2\2\u0726\u0727\7~\2\2\u0727\u0728\3\2\2" + - "\2\u0728\u0729\b\u00d0\22\2\u0729\u072a\b\u00d0\37\2\u072a\u01a4\3\2\2" + - "\2\u072b\u072f\7$\2\2\u072c\u072e\n\16\2\2\u072d\u072c\3\2\2\2\u072e\u0731" + - "\3\2\2\2\u072f\u072d\3\2\2\2\u072f\u0730\3\2\2\2\u0730\u0732\3\2\2\2\u0731" + - "\u072f\3\2\2\2\u0732\u0733\7$\2\2\u0733\u0734\3\2\2\2\u0734\u0735\b\u00d1" + - "\22\2\u0735\u0736\b\u00d1 \2\u0736\u01a6\3\2\2\2\u0737\u0738\5\u01c5\u00e1" + - "\2\u0738\u0739\3\2\2\2\u0739\u073a\b\u00d2\22\2\u073a\u01a8\3\2\2\2\u073b" + - "\u073c\7\61\2\2\u073c\u073d\7\61\2\2\u073d\u0741\3\2\2\2\u073e\u0740\n" + - "\17\2\2\u073f\u073e\3\2\2\2\u0740\u0743\3\2\2\2\u0741\u073f\3\2\2\2\u0741" + - "\u0742\3\2\2\2\u0742\u0744\3\2\2\2\u0743\u0741\3\2\2\2\u0744\u0745\b\u00d3" + - "\2\2\u0745\u0746\b\u00d3!\2\u0746\u01aa\3\2\2\2\u0747\u0748\5\u01bf\u00de" + - "\2\u0748\u0749\3\2\2\2\u0749\u074a\b\u00d4\22\2\u074a\u074b\b\u00d4\"" + - "\2\u074b\u01ac\3\2\2\2\u074c\u074e\n\17\2\2\u074d\u074c\3\2\2\2\u074e" + - "\u074f\3\2\2\2\u074f\u074d\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u0751\3\2" + - "\2\2\u0751\u0752\b\u00d5\22\2\u0752\u01ae\3\2\2\2\u0753\u0754\5\u01bf" + - "\u00de\2\u0754\u0755\3\2\2\2\u0755\u0756\b\u00d6\22\2\u0756\u0757\b\u00d6" + - "#\2\u0757\u0758\b\u00d6\"\2\u0758\u01b0\3\2\2\2\u0759\u075a\n\17\2\2\u075a" + - "\u01b2\3\2\2\2\u075b\u075c\t\17\2\2\u075c\u01b4\3\2\2\2\u075d\u075f\t" + - "\20\2\2\u075e\u075d\3\2\2\2\u075e\u075f\3\2\2\2\u075f\u0760\3\2\2\2\u0760" + - "\u0766\t\21\2\2\u0761\u0763\t\21\2\2\u0762\u0761\3\2\2\2\u0762\u0763\3" + - "\2\2\2\u0763\u0764\3\2\2\2\u0764\u0766\t\20\2\2\u0765\u075e\3\2\2\2\u0765" + - "\u0762\3\2\2\2\u0766\u01b6\3\2\2\2\u0767\u0769\t\22\2\2\u0768\u076a\t" + - "\23\2\2\u0769\u0768\3\2\2\2\u0769\u076a\3\2\2\2\u076a\u076b\3\2\2\2\u076b" + - "\u0775\t\3\2\2\u076c\u076e\7a\2\2\u076d\u076c\3\2\2\2\u076e\u0771\3\2" + - "\2\2\u076f\u076d\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0772\3\2\2\2\u0771" + - "\u076f\3\2\2\2\u0772\u0774\t\3\2\2\u0773\u076f\3\2\2\2\u0774\u0777\3\2" + - "\2\2\u0775\u0773\3\2\2\2\u0775\u0776\3\2\2\2\u0776\u01b8\3\2\2\2\u0777" + - "\u0775\3\2\2\2\u0778\u077c\5\u01bb\u00dc\2\u0779\u077c\5\u01bd\u00dd\2" + - "\u077a\u077c\5\u01d5\u00e9\2\u077b\u0778\3\2\2\2\u077b\u0779\3\2\2\2\u077b" + - "\u077a\3\2\2\2\u077c\u01ba\3\2\2\2\u077d\u077e\7^\2\2\u077e\u0794\7)\2" + - "\2\u077f\u0780\7^\2\2\u0780\u0794\7$\2\2\u0781\u0782\7^\2\2\u0782\u0794" + - "\7^\2\2\u0783\u0784\7^\2\2\u0784\u0794\7\62\2\2\u0785\u0786\7^\2\2\u0786" + - "\u0794\7c\2\2\u0787\u0788\7^\2\2\u0788\u0794\7d\2\2\u0789\u078a\7^\2\2" + - "\u078a\u0794\7h\2\2\u078b\u078c\7^\2\2\u078c\u0794\7p\2\2\u078d\u078e" + - "\7^\2\2\u078e\u0794\7t\2\2\u078f\u0790\7^\2\2\u0790\u0794\7v\2\2\u0791" + - "\u0792\7^\2\2\u0792\u0794\7x\2\2\u0793\u077d\3\2\2\2\u0793\u077f\3\2\2" + - "\2\u0793\u0781\3\2\2\2\u0793\u0783\3\2\2\2\u0793\u0785\3\2\2\2\u0793\u0787" + - "\3\2\2\2\u0793\u0789\3\2\2\2\u0793\u078b\3\2\2\2\u0793\u078d\3\2\2\2\u0793" + - "\u078f\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u01bc\3\2\2\2\u0795\u0796\7^" + - "\2\2\u0796\u0797\7z\2\2\u0797\u0798\3\2\2\2\u0798\u07af\5\u01d7\u00ea" + - "\2\u0799\u079a\7^\2\2\u079a\u079b\7z\2\2\u079b\u079c\3\2\2\2\u079c\u079d" + - "\5\u01d7\u00ea\2\u079d\u079e\5\u01d7\u00ea\2\u079e\u07af\3\2\2\2\u079f" + - "\u07a0\7^\2\2\u07a0\u07a1\7z\2\2\u07a1\u07a2\3\2\2\2\u07a2\u07a3\5\u01d7" + - "\u00ea\2\u07a3\u07a4\5\u01d7\u00ea\2\u07a4\u07a5\5\u01d7\u00ea\2\u07a5" + - "\u07af\3\2\2\2\u07a6\u07a7\7^\2\2\u07a7\u07a8\7z\2\2\u07a8\u07a9\3\2\2" + - "\2\u07a9\u07aa\5\u01d7\u00ea\2\u07aa\u07ab\5\u01d7\u00ea\2\u07ab\u07ac" + - "\5\u01d7\u00ea\2\u07ac\u07ad\5\u01d7\u00ea\2\u07ad\u07af\3\2\2\2\u07ae" + - "\u0795\3\2\2\2\u07ae\u0799\3\2\2\2\u07ae\u079f\3\2\2\2\u07ae\u07a6\3\2" + - "\2\2\u07af\u01be\3\2\2\2\u07b0\u07b1\7\17\2\2\u07b1\u07b4\7\f\2\2\u07b2" + - "\u07b4\t\17\2\2\u07b3\u07b0\3\2\2\2\u07b3\u07b2\3\2\2\2\u07b4\u01c0\3" + - "\2\2\2\u07b5\u07b8\5\u01c3\u00e0\2\u07b6\u07b8\t\24\2\2\u07b7\u07b5\3" + - "\2\2\2\u07b7\u07b6\3\2\2\2\u07b8\u01c2\3\2\2\2\u07b9\u07ba\t\25\2\2\u07ba" + - "\u01c4\3\2\2\2\u07bb\u07bf\5\u01c7\u00e2\2\u07bc\u07be\5\u01c9\u00e3\2" + - "\u07bd\u07bc\3\2\2\2\u07be\u07c1\3\2\2\2\u07bf\u07bd\3\2\2\2\u07bf\u07c0" + - "\3\2\2\2\u07c0\u01c6\3\2\2\2\u07c1\u07bf\3\2\2\2\u07c2\u07c5\5\u01cb\u00e4" + - "\2\u07c3\u07c5\7a\2\2\u07c4\u07c2\3\2\2\2\u07c4\u07c3\3\2\2\2\u07c5\u01c8" + - "\3\2\2\2\u07c6\u07cc\5\u01cb\u00e4\2\u07c7\u07cc\5\u01cd\u00e5\2\u07c8" + - "\u07cc\5\u01cf\u00e6\2\u07c9\u07cc\5\u01d1\u00e7\2\u07ca\u07cc\5\u01d3" + - "\u00e8\2\u07cb\u07c6\3\2\2\2\u07cb\u07c7\3\2\2\2\u07cb\u07c8\3\2\2\2\u07cb" + - "\u07c9\3\2\2\2\u07cb\u07ca\3\2\2\2\u07cc\u01ca\3\2\2\2\u07cd\u07d5\5\u01d9" + - "\u00eb\2\u07ce\u07d5\5\u01db\u00ec\2\u07cf\u07d5\5\u01dd\u00ed\2\u07d0" + - "\u07d5\5\u01df\u00ee\2\u07d1\u07d5\5\u01e1\u00ef\2\u07d2\u07d5\5\u01e3" + - "\u00f0\2\u07d3\u07d5\5\u01d5\u00e9\2\u07d4\u07cd\3\2\2\2\u07d4\u07ce\3" + - "\2\2\2\u07d4\u07cf\3\2\2\2\u07d4\u07d0\3\2\2\2\u07d4\u07d1\3\2\2\2\u07d4" + - "\u07d2\3\2\2\2\u07d4\u07d3\3\2\2\2\u07d5\u01cc\3\2\2\2\u07d6\u07d9\5\u01ed" + - "\u00f5\2\u07d7\u07d9\5\u01d5\u00e9\2\u07d8\u07d6\3\2\2\2\u07d8\u07d7\3" + - "\2\2\2\u07d9\u01ce\3\2\2\2\u07da\u07dd\5\u01eb\u00f4\2\u07db\u07dd\5\u01d5" + - "\u00e9\2\u07dc\u07da\3\2\2\2\u07dc\u07db\3\2\2\2\u07dd\u01d0\3\2\2\2\u07de" + - "\u07e2\5\u01e5\u00f1\2\u07df\u07e2\5\u01e7\u00f2\2\u07e0\u07e2\5\u01d5" + - "\u00e9\2\u07e1\u07de\3\2\2\2\u07e1\u07df\3\2\2\2\u07e1\u07e0\3\2\2\2\u07e2" + - "\u01d2\3\2\2\2\u07e3\u07e6\5\u01e9\u00f3\2\u07e4\u07e6\5\u01d5\u00e9\2" + - "\u07e5\u07e3\3\2\2\2\u07e5\u07e4\3\2\2\2\u07e6\u01d4\3\2\2\2\u07e7\u07e8" + - "\7^\2\2\u07e8\u07e9\7w\2\2\u07e9\u07ea\3\2\2\2\u07ea\u07eb\5\u01d7\u00ea" + - "\2\u07eb\u07ec\5\u01d7\u00ea\2\u07ec\u07ed\5\u01d7\u00ea\2\u07ed\u07ee" + - "\5\u01d7\u00ea\2\u07ee\u07fc\3\2\2\2\u07ef\u07f0\7^\2\2\u07f0\u07f1\7" + - "W\2\2\u07f1\u07f2\3\2\2\2\u07f2\u07f3\5\u01d7\u00ea\2\u07f3\u07f4\5\u01d7" + - "\u00ea\2\u07f4\u07f5\5\u01d7\u00ea\2\u07f5\u07f6\5\u01d7\u00ea\2\u07f6" + - "\u07f7\5\u01d7\u00ea\2\u07f7\u07f8\5\u01d7\u00ea\2\u07f8\u07f9\5\u01d7" + - "\u00ea\2\u07f9\u07fa\5\u01d7\u00ea\2\u07fa\u07fc\3\2\2\2\u07fb\u07e7\3" + - "\2\2\2\u07fb\u07ef\3\2\2\2\u07fc\u01d6\3\2\2\2\u07fd\u07ff\t\26\2\2\u07fe" + - "\u07fd\3\2\2\2\u07ff\u01d8\3\2\2\2\u0800\u0801\t\27\2\2\u0801\u01da\3" + - "\2\2\2\u0802\u0803\t\30\2\2\u0803\u01dc\3\2\2\2\u0804\u0805\t\31\2\2\u0805" + - "\u01de\3\2\2\2\u0806\u0807\t\32\2\2\u0807\u01e0\3\2\2\2\u0808\u0809\t" + - "\33\2\2\u0809\u01e2\3\2\2\2\u080a\u080b\t\34\2\2\u080b\u01e4\3\2\2\2\u080c" + - "\u080d\4\u0302\u0312\2\u080d\u01e6\3\2\2\2\u080e\u080f\t\35\2\2\u080f" + - "\u01e8\3\2\2\2\u0810\u0811\t\36\2\2\u0811\u01ea\3\2\2\2\u0812\u0813\t" + - "\37\2\2\u0813\u01ec\3\2\2\2\u0814\u0815\t \2\2\u0815\u01ee\3\2\2\2O\2" + - "\3\4\5\6\u01fa\u020f\u021d\u0228\u0232\u0234\u04e0\u04e8\u04ee\u04f2\u04f6" + - "\u04fe\u0504\u0508\u050f\u0515\u0518\u051f\u0525\u0528\u052e\u0534\u0537" + - "\u053e\u0544\u0548\u054b\u0551\u0557\u055d\u055f\u0561\u0566\u056d\u056f" + - "\u057a\u057c\u0623\u0629\u0639\u063e\u0645\u0698\u06a8\u06b7\u06ca\u06da" + - "\u06eb\u072f\u0741\u074f\u075e\u0762\u0765\u0769\u076f\u0775\u077b\u0793" + - "\u07ae\u07b3\u07b7\u07bf\u07c4\u07cb\u07d4\u07d8\u07dc\u07e1\u07e5\u07fb" + - "\u07fe$\2\4\2\2\3\2\4\5\2\3|\2\7\3\2\3}\3\3~\4\3\177\5\3\u0086\6\3\u00ae" + - "\7\b\2\2\7\2\2\3\u00b1\b\6\2\2\t\u00b6\2\3\u00b5\t\2\5\2\tb\2\t,\2\t\66" + - "\2\t&\2\4\6\2\t \2\t\u0083\2\t\u0084\2\t\u0091\2\t\u009e\2\t\u009f\2\t" + - "\u009b\2\t\u009c\2\t]\2\t\7\2\4\2\2\t\u00c6\2"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.interp deleted file mode 100644 index 0f2fae6..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.interp +++ /dev/null @@ -1,625 +0,0 @@ -token literal names: -null -'\u00EF\u00BB\u00BF' -null -'/***/' -null -null -null -null -'#' -'abstract' -'add' -'alias' -'__arglist' -'as' -'ascending' -'async' -'await' -'base' -'bool' -'break' -'by' -'byte' -'case' -'catch' -'char' -'checked' -'class' -'const' -'continue' -'decimal' -'default' -'delegate' -'descending' -'do' -'double' -'dynamic' -'else' -'enum' -'equals' -'event' -'explicit' -'extern' -'false' -'finally' -'fixed' -'float' -'for' -'foreach' -'from' -'get' -'goto' -'group' -'if' -'implicit' -'in' -'int' -'interface' -'internal' -'into' -'is' -'join' -'let' -'lock' -'long' -'nameof' -'namespace' -'new' -'null' -'object' -'on' -'operator' -'orderby' -'out' -'override' -'params' -'partial' -'private' -'protected' -'public' -'readonly' -'ref' -'remove' -'return' -'sbyte' -'sealed' -'select' -'set' -'short' -'sizeof' -'stackalloc' -'static' -'string' -'struct' -'switch' -'this' -'throw' -'true' -'try' -'typeof' -'uint' -'ulong' -'unchecked' -'unmanaged' -'unsafe' -'ushort' -'using' -'var' -'virtual' -'void' -'volatile' -'when' -'where' -'while' -'yield' -null -null -null -null -null -null -null -null -null -null -null -'{' -'}' -'[' -']' -'(' -')' -'.' -',' -':' -';' -'+' -'-' -'*' -'/' -'%' -'&' -'|' -'^' -'!' -'~' -'=' -'<' -'>' -'?' -'::' -'??' -'++' -'--' -'&&' -'||' -'->' -'==' -'!=' -'<=' -'>=' -'+=' -'-=' -'*=' -'/=' -'%=' -'&=' -'|=' -'^=' -'<<' -'<<=' -'??=' -'..' -'{{' -null -null -null -null -null -null -null -null -null -null -'define' -'undef' -'elif' -'endif' -'line' -null -null -null -null -null -null -'hidden' -null -null -null -'}}' - -token symbolic names: -null -BYTE_ORDER_MARK -SINGLE_LINE_DOC_COMMENT -EMPTY_DELIMITED_DOC_COMMENT -DELIMITED_DOC_COMMENT -SINGLE_LINE_COMMENT -DELIMITED_COMMENT -WHITESPACES -SHARP -ABSTRACT -ADD -ALIAS -ARGLIST -AS -ASCENDING -ASYNC -AWAIT -BASE -BOOL -BREAK -BY -BYTE -CASE -CATCH -CHAR -CHECKED -CLASS -CONST -CONTINUE -DECIMAL -DEFAULT -DELEGATE -DESCENDING -DO -DOUBLE -DYNAMIC -ELSE -ENUM -EQUALS -EVENT -EXPLICIT -EXTERN -FALSE -FINALLY -FIXED -FLOAT -FOR -FOREACH -FROM -GET -GOTO -GROUP -IF -IMPLICIT -IN -INT -INTERFACE -INTERNAL -INTO -IS -JOIN -LET -LOCK -LONG -NAMEOF -NAMESPACE -NEW -NULL -OBJECT -ON -OPERATOR -ORDERBY -OUT -OVERRIDE -PARAMS -PARTIAL -PRIVATE -PROTECTED -PUBLIC -READONLY -REF -REMOVE -RETURN -SBYTE -SEALED -SELECT -SET -SHORT -SIZEOF -STACKALLOC -STATIC -STRING -STRUCT -SWITCH -THIS -THROW -TRUE -TRY -TYPEOF -UINT -ULONG -UNCHECKED -UNMANAGED -UNSAFE -USHORT -USING -VAR -VIRTUAL -VOID -VOLATILE -WHEN -WHERE -WHILE -YIELD -IDENTIFIER -LITERAL_ACCESS -INTEGER_LITERAL -HEX_INTEGER_LITERAL -BIN_INTEGER_LITERAL -REAL_LITERAL -CHARACTER_LITERAL -REGULAR_STRING -VERBATIUM_STRING -INTERPOLATED_REGULAR_STRING_START -INTERPOLATED_VERBATIUM_STRING_START -OPEN_BRACE -CLOSE_BRACE -OPEN_BRACKET -CLOSE_BRACKET -OPEN_PARENS -CLOSE_PARENS -DOT -COMMA -COLON -SEMICOLON -PLUS -MINUS -STAR -DIV -PERCENT -AMP -BITWISE_OR -CARET -BANG -TILDE -ASSIGNMENT -LT -GT -INTERR -DOUBLE_COLON -OP_COALESCING -OP_INC -OP_DEC -OP_AND -OP_OR -OP_PTR -OP_EQ -OP_NE -OP_LE -OP_GE -OP_ADD_ASSIGNMENT -OP_SUB_ASSIGNMENT -OP_MULT_ASSIGNMENT -OP_DIV_ASSIGNMENT -OP_MOD_ASSIGNMENT -OP_AND_ASSIGNMENT -OP_OR_ASSIGNMENT -OP_XOR_ASSIGNMENT -OP_LEFT_SHIFT -OP_LEFT_SHIFT_ASSIGNMENT -OP_COALESCING_ASSIGNMENT -OP_RANGE -DOUBLE_CURLY_INSIDE -OPEN_BRACE_INSIDE -REGULAR_CHAR_INSIDE -VERBATIUM_DOUBLE_QUOTE_INSIDE -DOUBLE_QUOTE_INSIDE -REGULAR_STRING_INSIDE -VERBATIUM_INSIDE_STRING -CLOSE_BRACE_INSIDE -FORMAT_STRING -DIRECTIVE_WHITESPACES -DIGITS -DEFINE -UNDEF -ELIF -ENDIF -LINE -ERROR -WARNING -REGION -ENDREGION -PRAGMA -NULLABLE -DIRECTIVE_HIDDEN -CONDITIONAL_SYMBOL -DIRECTIVE_NEW_LINE -TEXT -DOUBLE_CURLY_CLOSE_INSIDE - -rule names: -compilation_unit -namespace_or_type_name -type_ -base_type -tuple_type -tuple_element -simple_type -numeric_type -integral_type -floating_point_type -class_type -type_argument_list -argument_list -argument -expression -non_assignment_expression -assignment -assignment_operator -conditional_expression -null_coalescing_expression -conditional_or_expression -conditional_and_expression -inclusive_or_expression -exclusive_or_expression -and_expression -equality_expression -relational_expression -shift_expression -additive_expression -multiplicative_expression -switch_expression -switch_expression_arms -switch_expression_arm -range_expression -unary_expression -primary_expression -primary_expression_start -throwable_expression -throw_expression -member_access -bracket_expression -indexer_argument -predefined_type -expression_list -object_or_collection_initializer -object_initializer -member_initializer_list -member_initializer -initializer_value -collection_initializer -element_initializer -anonymous_object_initializer -member_declarator_list -member_declarator -unbound_type_name -generic_dimension_specifier -isType -isTypePatternArms -isTypePatternArm -lambda_expression -anonymous_function_signature -explicit_anonymous_function_parameter_list -explicit_anonymous_function_parameter -implicit_anonymous_function_parameter_list -anonymous_function_body -query_expression -from_clause -query_body -query_body_clause -let_clause -where_clause -combined_join_clause -orderby_clause -ordering -select_or_group_clause -query_continuation -statement -declarationStatement -local_function_declaration -local_function_header -local_function_modifiers -local_function_body -labeled_Statement -embedded_statement -simple_embedded_statement -block -local_variable_declaration -local_variable_type -local_variable_declarator -local_variable_initializer -local_constant_declaration -if_body -switch_section -switch_label -case_guard -statement_list -for_initializer -for_iterator -catch_clauses -specific_catch_clause -general_catch_clause -exception_filter -finally_clause -resource_acquisition -namespace_declaration -qualified_identifier -namespace_body -extern_alias_directives -extern_alias_directive -using_directives -using_directive -namespace_member_declarations -namespace_member_declaration -type_declaration -qualified_alias_member -type_parameter_list -type_parameter -class_base -interface_type_list -type_parameter_constraints_clauses -type_parameter_constraints_clause -type_parameter_constraints -primary_constraint -secondary_constraints -constructor_constraint -class_body -class_member_declarations -class_member_declaration -all_member_modifiers -all_member_modifier -common_member_declaration -typed_member_declaration -constant_declarators -constant_declarator -variable_declarators -variable_declarator -variable_initializer -return_type -member_name -method_body -formal_parameter_list -fixed_parameters -fixed_parameter -parameter_modifier -parameter_array -accessor_declarations -get_accessor_declaration -set_accessor_declaration -accessor_modifier -accessor_body -event_accessor_declarations -add_accessor_declaration -remove_accessor_declaration -overloadable_operator -conversion_operator_declarator -constructor_initializer -body -struct_interfaces -struct_body -struct_member_declaration -array_type -rank_specifier -array_initializer -variant_type_parameter_list -variant_type_parameter -variance_annotation -interface_base -interface_body -interface_member_declaration -interface_accessors -enum_base -enum_body -enum_member_declaration -global_attribute_section -global_attribute_target -attributes -attribute_section -attribute_target -attribute_list -attribute -attribute_argument -pointer_type -fixed_pointer_declarators -fixed_pointer_declarator -fixed_pointer_initializer -fixed_size_buffer_declarator -stackalloc_initializer -right_arrow -right_shift -right_shift_assignment -literal -boolean_literal -string_literal -interpolated_regular_string -interpolated_verbatium_string -interpolated_regular_string_part -interpolated_verbatium_string_part -interpolated_string_expression -keyword -class_definition -struct_definition -interface_definition -enum_definition -delegate_definition -event_declaration -field_declaration -property_declaration -constant_declaration -indexer_declaration -destructor_definition -constructor_declaration -method_declaration -method_member_name -operator_declaration -arg_declaration -method_invocation -object_creation_expression -identifier - - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 200, 2644, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 3, 2, 5, 2, 440, 10, 2, 3, 2, 5, 2, 443, 10, 2, 3, 2, 5, 2, 446, 10, 2, 3, 2, 7, 2, 449, 10, 2, 12, 2, 14, 2, 452, 11, 2, 3, 2, 5, 2, 455, 10, 2, 3, 2, 3, 2, 3, 3, 3, 3, 5, 3, 461, 10, 3, 3, 3, 5, 3, 464, 10, 3, 3, 3, 3, 3, 3, 3, 5, 3, 469, 10, 3, 7, 3, 471, 10, 3, 12, 3, 14, 3, 474, 11, 3, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 480, 10, 4, 12, 4, 14, 4, 483, 11, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 490, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 6, 6, 496, 10, 6, 13, 6, 14, 6, 497, 3, 6, 3, 6, 3, 7, 3, 7, 5, 7, 504, 10, 7, 3, 8, 3, 8, 5, 8, 508, 10, 8, 3, 9, 3, 9, 3, 9, 5, 9, 513, 10, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 523, 10, 12, 3, 13, 3, 13, 3, 13, 3, 13, 7, 13, 529, 10, 13, 12, 13, 14, 13, 532, 11, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 7, 14, 539, 10, 14, 12, 14, 14, 14, 542, 11, 14, 3, 15, 3, 15, 3, 15, 5, 15, 547, 10, 15, 3, 15, 5, 15, 550, 10, 15, 3, 15, 3, 15, 5, 15, 554, 10, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 562, 10, 16, 3, 17, 3, 17, 3, 17, 5, 17, 567, 10, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 577, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 590, 10, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 598, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 604, 10, 21, 5, 21, 606, 10, 21, 3, 22, 3, 22, 3, 22, 7, 22, 611, 10, 22, 12, 22, 14, 22, 614, 11, 22, 3, 23, 3, 23, 3, 23, 7, 23, 619, 10, 23, 12, 23, 14, 23, 622, 11, 23, 3, 24, 3, 24, 3, 24, 7, 24, 627, 10, 24, 12, 24, 14, 24, 630, 11, 24, 3, 25, 3, 25, 3, 25, 7, 25, 635, 10, 25, 12, 25, 14, 25, 638, 11, 25, 3, 26, 3, 26, 3, 26, 7, 26, 643, 10, 26, 12, 26, 14, 26, 646, 11, 26, 3, 27, 3, 27, 3, 27, 7, 27, 651, 10, 27, 12, 27, 14, 27, 654, 11, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 7, 28, 663, 10, 28, 12, 28, 14, 28, 666, 11, 28, 3, 29, 3, 29, 3, 29, 5, 29, 671, 10, 29, 3, 29, 7, 29, 674, 10, 29, 12, 29, 14, 29, 677, 11, 29, 3, 30, 3, 30, 3, 30, 7, 30, 682, 10, 30, 12, 30, 14, 30, 685, 11, 30, 3, 31, 3, 31, 3, 31, 7, 31, 690, 10, 31, 12, 31, 14, 31, 693, 11, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 5, 32, 700, 10, 32, 5, 32, 702, 10, 32, 3, 32, 5, 32, 705, 10, 32, 3, 33, 3, 33, 3, 33, 7, 33, 710, 10, 33, 12, 33, 14, 33, 713, 11, 33, 3, 34, 3, 34, 5, 34, 717, 10, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 5, 35, 724, 10, 35, 3, 35, 3, 35, 5, 35, 728, 10, 35, 5, 35, 730, 10, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 758, 10, 36, 3, 37, 3, 37, 5, 37, 762, 10, 37, 3, 37, 7, 37, 765, 10, 37, 12, 37, 14, 37, 768, 11, 37, 3, 37, 5, 37, 771, 10, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 779, 10, 37, 3, 37, 5, 37, 782, 10, 37, 3, 37, 7, 37, 785, 10, 37, 12, 37, 14, 37, 788, 11, 37, 3, 37, 5, 37, 791, 10, 37, 7, 37, 793, 10, 37, 12, 37, 14, 37, 796, 11, 37, 3, 38, 3, 38, 3, 38, 5, 38, 801, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 815, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 821, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 7, 38, 831, 10, 38, 12, 38, 14, 38, 834, 11, 38, 3, 38, 5, 38, 837, 10, 38, 3, 38, 6, 38, 840, 10, 38, 13, 38, 14, 38, 841, 3, 38, 3, 38, 5, 38, 846, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 852, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 6, 38, 858, 10, 38, 13, 38, 14, 38, 859, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 869, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 887, 10, 38, 3, 38, 5, 38, 890, 10, 38, 3, 38, 3, 38, 3, 38, 5, 38, 895, 10, 38, 3, 38, 5, 38, 898, 10, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 7, 38, 911, 10, 38, 12, 38, 14, 38, 914, 11, 38, 3, 38, 3, 38, 3, 38, 5, 38, 919, 10, 38, 3, 39, 3, 39, 5, 39, 923, 10, 39, 3, 40, 3, 40, 3, 40, 3, 41, 5, 41, 929, 10, 41, 3, 41, 3, 41, 3, 41, 5, 41, 934, 10, 41, 3, 42, 5, 42, 937, 10, 42, 3, 42, 3, 42, 3, 42, 3, 42, 7, 42, 943, 10, 42, 12, 42, 14, 42, 946, 11, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 5, 43, 953, 10, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 7, 45, 962, 10, 45, 12, 45, 14, 45, 965, 11, 45, 3, 46, 3, 46, 5, 46, 969, 10, 46, 3, 47, 3, 47, 3, 47, 5, 47, 974, 10, 47, 5, 47, 976, 10, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 7, 48, 983, 10, 48, 12, 48, 14, 48, 986, 11, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 993, 10, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 5, 50, 1000, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 7, 51, 1006, 10, 51, 12, 51, 14, 51, 1009, 11, 51, 3, 51, 5, 51, 1012, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 1021, 10, 52, 3, 53, 3, 53, 3, 53, 5, 53, 1026, 10, 53, 5, 53, 1028, 10, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 7, 54, 1035, 10, 54, 12, 54, 14, 54, 1038, 11, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 1045, 10, 55, 3, 56, 3, 56, 5, 56, 1049, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 1054, 10, 56, 5, 56, 1056, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 1061, 10, 56, 7, 56, 1063, 10, 56, 12, 56, 14, 56, 1066, 11, 56, 3, 57, 3, 57, 7, 57, 1070, 10, 57, 12, 57, 14, 57, 1073, 11, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 7, 58, 1080, 10, 58, 12, 58, 14, 58, 1083, 11, 58, 3, 58, 5, 58, 1086, 10, 58, 3, 58, 5, 58, 1089, 10, 58, 3, 58, 5, 58, 1092, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 7, 59, 1098, 10, 59, 12, 59, 14, 59, 1101, 11, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 5, 61, 1110, 10, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 5, 62, 1127, 10, 62, 3, 63, 3, 63, 3, 63, 7, 63, 1132, 10, 63, 12, 63, 14, 63, 1135, 11, 63, 3, 64, 5, 64, 1138, 10, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 7, 65, 1146, 10, 65, 12, 65, 14, 65, 1149, 11, 65, 3, 66, 3, 66, 5, 66, 1153, 10, 66, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 5, 68, 1160, 10, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 7, 69, 1167, 10, 69, 12, 69, 14, 69, 1170, 11, 69, 3, 69, 3, 69, 5, 69, 1174, 10, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 1181, 10, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 5, 73, 1193, 10, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 5, 73, 1204, 10, 73, 3, 74, 3, 74, 3, 74, 3, 74, 7, 74, 1210, 10, 74, 12, 74, 14, 74, 1213, 11, 74, 3, 75, 3, 75, 5, 75, 1217, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1226, 10, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 5, 78, 1235, 10, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1244, 10, 79, 3, 80, 3, 80, 3, 80, 3, 81, 5, 81, 1250, 10, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1255, 10, 81, 3, 81, 3, 81, 5, 81, 1259, 10, 81, 3, 81, 3, 81, 5, 81, 1263, 10, 81, 3, 82, 3, 82, 5, 82, 1267, 10, 82, 3, 82, 3, 82, 5, 82, 1271, 10, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 1278, 10, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 5, 85, 1286, 10, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1299, 10, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 7, 86, 1307, 10, 86, 12, 86, 14, 86, 1310, 11, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1331, 10, 86, 3, 86, 3, 86, 5, 86, 1335, 10, 86, 3, 86, 3, 86, 5, 86, 1339, 10, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1344, 10, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1364, 10, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1369, 10, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1374, 10, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1381, 10, 86, 3, 86, 5, 86, 1384, 10, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1406, 10, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1418, 10, 86, 3, 87, 3, 87, 5, 87, 1422, 10, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 1430, 10, 88, 3, 88, 3, 88, 3, 88, 3, 88, 7, 88, 1436, 10, 88, 12, 88, 14, 88, 1439, 11, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 1445, 10, 88, 3, 89, 3, 89, 5, 89, 1449, 10, 89, 3, 90, 3, 90, 3, 90, 5, 90, 1454, 10, 90, 3, 90, 5, 90, 1457, 10, 90, 3, 91, 3, 91, 3, 91, 5, 91, 1462, 10, 91, 3, 92, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 5, 93, 1470, 10, 93, 3, 94, 6, 94, 1473, 10, 94, 13, 94, 14, 94, 1474, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 5, 95, 1482, 10, 95, 3, 95, 3, 95, 3, 95, 3, 95, 5, 95, 1488, 10, 95, 3, 96, 3, 96, 3, 96, 3, 97, 6, 97, 1494, 10, 97, 13, 97, 14, 97, 1495, 3, 98, 3, 98, 3, 98, 3, 98, 7, 98, 1502, 10, 98, 12, 98, 14, 98, 1505, 11, 98, 5, 98, 1507, 10, 98, 3, 99, 3, 99, 3, 99, 7, 99, 1512, 10, 99, 12, 99, 14, 99, 1515, 11, 99, 3, 100, 3, 100, 7, 100, 1519, 10, 100, 12, 100, 14, 100, 1522, 11, 100, 3, 100, 5, 100, 1525, 10, 100, 3, 100, 5, 100, 1528, 10, 100, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1534, 10, 101, 3, 101, 3, 101, 5, 101, 1538, 10, 101, 3, 101, 3, 101, 3, 102, 3, 102, 5, 102, 1544, 10, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 5, 105, 1558, 10, 105, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 1564, 10, 106, 3, 107, 3, 107, 3, 107, 7, 107, 1569, 10, 107, 12, 107, 14, 107, 1572, 11, 107, 3, 108, 3, 108, 5, 108, 1576, 10, 108, 3, 108, 5, 108, 1579, 10, 108, 3, 108, 5, 108, 1582, 10, 108, 3, 108, 3, 108, 3, 109, 6, 109, 1587, 10, 109, 13, 109, 14, 109, 1588, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 6, 111, 1597, 10, 111, 13, 111, 14, 111, 1598, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 5, 112, 1616, 10, 112, 3, 113, 6, 113, 1619, 10, 113, 13, 113, 14, 113, 1620, 3, 114, 3, 114, 5, 114, 1625, 10, 114, 3, 115, 5, 115, 1628, 10, 115, 3, 115, 5, 115, 1631, 10, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1638, 10, 115, 3, 116, 3, 116, 3, 116, 3, 116, 5, 116, 1644, 10, 116, 3, 117, 3, 117, 3, 117, 3, 117, 7, 117, 1650, 10, 117, 12, 117, 14, 117, 1653, 11, 117, 3, 117, 3, 117, 3, 118, 5, 118, 1658, 10, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 7, 119, 1666, 10, 119, 12, 119, 14, 119, 1669, 11, 119, 3, 120, 3, 120, 3, 120, 7, 120, 1674, 10, 120, 12, 120, 14, 120, 1677, 11, 120, 3, 121, 6, 121, 1680, 10, 121, 13, 121, 14, 121, 1681, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 5, 123, 1693, 10, 123, 3, 123, 3, 123, 5, 123, 1697, 10, 123, 5, 123, 1699, 10, 123, 3, 124, 3, 124, 3, 124, 5, 124, 1704, 10, 124, 3, 124, 3, 124, 5, 124, 1708, 10, 124, 3, 125, 3, 125, 3, 125, 7, 125, 1713, 10, 125, 12, 125, 14, 125, 1716, 11, 125, 3, 126, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 5, 127, 1724, 10, 127, 3, 127, 3, 127, 3, 128, 6, 128, 1729, 10, 128, 13, 128, 14, 128, 1730, 3, 129, 5, 129, 1734, 10, 129, 3, 129, 5, 129, 1737, 10, 129, 3, 129, 3, 129, 5, 129, 1741, 10, 129, 3, 130, 6, 130, 1744, 10, 130, 13, 130, 14, 130, 1745, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 5, 132, 1759, 10, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 5, 132, 1769, 10, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1776, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1788, 10, 133, 3, 134, 3, 134, 3, 134, 7, 134, 1793, 10, 134, 12, 134, 14, 134, 1796, 11, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 7, 136, 1805, 10, 136, 12, 136, 14, 136, 1808, 11, 136, 3, 137, 3, 137, 3, 137, 5, 137, 1813, 10, 137, 3, 138, 3, 138, 5, 138, 1817, 10, 138, 3, 139, 3, 139, 5, 139, 1821, 10, 139, 3, 140, 3, 140, 3, 141, 3, 141, 5, 141, 1827, 10, 141, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 1833, 10, 142, 5, 142, 1835, 10, 142, 3, 143, 3, 143, 3, 143, 7, 143, 1840, 10, 143, 12, 143, 14, 143, 1843, 11, 143, 3, 144, 5, 144, 1846, 10, 144, 3, 144, 5, 144, 1849, 10, 144, 3, 144, 3, 144, 5, 144, 1853, 10, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 5, 145, 1863, 10, 145, 3, 146, 5, 146, 1866, 10, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 147, 5, 147, 1873, 10, 147, 3, 147, 5, 147, 1876, 10, 147, 3, 147, 3, 147, 3, 147, 5, 147, 1881, 10, 147, 3, 147, 3, 147, 3, 147, 5, 147, 1886, 10, 147, 5, 147, 1888, 10, 147, 3, 148, 5, 148, 1891, 10, 148, 3, 148, 5, 148, 1894, 10, 148, 3, 148, 3, 148, 3, 148, 3, 149, 5, 149, 1900, 10, 149, 3, 149, 5, 149, 1903, 10, 149, 3, 149, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 1915, 10, 150, 3, 151, 3, 151, 5, 151, 1919, 10, 151, 3, 152, 5, 152, 1922, 10, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 5, 152, 1932, 10, 152, 3, 153, 5, 153, 1935, 10, 153, 3, 153, 3, 153, 3, 153, 3, 154, 5, 154, 1941, 10, 154, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 1968, 10, 155, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 1981, 10, 157, 3, 157, 3, 157, 3, 158, 3, 158, 5, 158, 1987, 10, 158, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 7, 160, 1994, 10, 160, 12, 160, 14, 160, 1997, 11, 160, 3, 160, 3, 160, 3, 161, 5, 161, 2002, 10, 161, 3, 161, 5, 161, 2005, 10, 161, 3, 161, 3, 161, 3, 161, 3, 161, 6, 161, 2011, 10, 161, 13, 161, 14, 161, 2012, 3, 161, 3, 161, 5, 161, 2017, 10, 161, 3, 162, 3, 162, 7, 162, 2021, 10, 162, 12, 162, 14, 162, 2024, 11, 162, 3, 162, 6, 162, 2027, 10, 162, 13, 162, 14, 162, 2028, 3, 163, 3, 163, 7, 163, 2033, 10, 163, 12, 163, 14, 163, 2036, 11, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 164, 7, 164, 2044, 10, 164, 12, 164, 14, 164, 2047, 11, 164, 3, 164, 5, 164, 2050, 10, 164, 5, 164, 2052, 10, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 165, 7, 165, 2060, 10, 165, 12, 165, 14, 165, 2063, 11, 165, 3, 165, 3, 165, 3, 166, 5, 166, 2068, 10, 166, 3, 166, 5, 166, 2071, 10, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 169, 3, 169, 7, 169, 2082, 10, 169, 12, 169, 14, 169, 2085, 11, 169, 3, 169, 3, 169, 3, 170, 5, 170, 2090, 10, 170, 3, 170, 5, 170, 2093, 10, 170, 3, 170, 5, 170, 2096, 10, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 2103, 10, 170, 3, 170, 3, 170, 3, 170, 5, 170, 2108, 10, 170, 3, 170, 3, 170, 5, 170, 2112, 10, 170, 3, 170, 3, 170, 5, 170, 2116, 10, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 2133, 10, 170, 3, 170, 5, 170, 2136, 10, 170, 3, 170, 3, 170, 3, 170, 5, 170, 2141, 10, 170, 3, 170, 3, 170, 5, 170, 2145, 10, 170, 3, 170, 3, 170, 5, 170, 2149, 10, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 2158, 10, 170, 3, 171, 5, 171, 2161, 10, 171, 3, 171, 3, 171, 3, 171, 5, 171, 2166, 10, 171, 3, 171, 3, 171, 5, 171, 2170, 10, 171, 3, 171, 3, 171, 3, 171, 5, 171, 2175, 10, 171, 3, 171, 3, 171, 5, 171, 2179, 10, 171, 5, 171, 2181, 10, 171, 3, 172, 3, 172, 3, 172, 3, 173, 3, 173, 3, 173, 3, 173, 7, 173, 2190, 10, 173, 12, 173, 14, 173, 2193, 11, 173, 3, 173, 5, 173, 2196, 10, 173, 5, 173, 2198, 10, 173, 3, 173, 3, 173, 3, 174, 5, 174, 2203, 10, 174, 3, 174, 3, 174, 3, 174, 5, 174, 2208, 10, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 5, 175, 2215, 10, 175, 3, 175, 3, 175, 3, 176, 3, 176, 5, 176, 2221, 10, 176, 3, 177, 6, 177, 2224, 10, 177, 13, 177, 14, 177, 2225, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 2232, 10, 178, 3, 178, 3, 178, 5, 178, 2236, 10, 178, 3, 178, 3, 178, 3, 179, 3, 179, 5, 179, 2242, 10, 179, 3, 180, 3, 180, 3, 180, 7, 180, 2247, 10, 180, 12, 180, 14, 180, 2250, 11, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 7, 181, 2257, 10, 181, 12, 181, 14, 181, 2260, 11, 181, 5, 181, 2262, 10, 181, 3, 181, 5, 181, 2265, 10, 181, 3, 182, 3, 182, 3, 182, 5, 182, 2270, 10, 182, 3, 182, 3, 182, 3, 183, 3, 183, 5, 183, 2276, 10, 183, 3, 183, 3, 183, 7, 183, 2280, 10, 183, 12, 183, 14, 183, 2283, 11, 183, 3, 183, 3, 183, 3, 183, 3, 183, 5, 183, 2289, 10, 183, 3, 184, 3, 184, 3, 184, 7, 184, 2294, 10, 184, 12, 184, 14, 184, 2297, 11, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 186, 5, 186, 2304, 10, 186, 3, 186, 3, 186, 5, 186, 2308, 10, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 2323, 10, 188, 3, 188, 3, 188, 5, 188, 2327, 10, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 7, 188, 2334, 10, 188, 12, 188, 14, 188, 2337, 11, 188, 3, 188, 5, 188, 2340, 10, 188, 3, 188, 3, 188, 5, 188, 2344, 10, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 5, 192, 2366, 10, 192, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 5, 194, 2374, 10, 194, 3, 195, 3, 195, 7, 195, 2378, 10, 195, 12, 195, 14, 195, 2381, 11, 195, 3, 195, 3, 195, 3, 196, 3, 196, 7, 196, 2387, 10, 196, 12, 196, 14, 196, 2390, 11, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 5, 197, 2398, 10, 197, 3, 198, 3, 198, 3, 198, 3, 198, 5, 198, 2404, 10, 198, 3, 199, 3, 199, 3, 199, 7, 199, 2409, 10, 199, 12, 199, 14, 199, 2412, 11, 199, 3, 199, 3, 199, 6, 199, 2416, 10, 199, 13, 199, 14, 199, 2417, 5, 199, 2420, 10, 199, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 5, 201, 2427, 10, 201, 3, 201, 5, 201, 2430, 10, 201, 3, 201, 5, 201, 2433, 10, 201, 3, 201, 3, 201, 5, 201, 2437, 10, 201, 3, 202, 5, 202, 2440, 10, 202, 3, 202, 3, 202, 3, 202, 5, 202, 2445, 10, 202, 3, 202, 5, 202, 2448, 10, 202, 3, 202, 5, 202, 2451, 10, 202, 3, 202, 3, 202, 5, 202, 2455, 10, 202, 3, 203, 3, 203, 3, 203, 5, 203, 2460, 10, 203, 3, 203, 5, 203, 2463, 10, 203, 3, 203, 5, 203, 2466, 10, 203, 3, 203, 3, 203, 5, 203, 2470, 10, 203, 3, 204, 3, 204, 3, 204, 5, 204, 2475, 10, 204, 3, 204, 3, 204, 5, 204, 2479, 10, 204, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 2485, 10, 205, 3, 205, 3, 205, 5, 205, 2489, 10, 205, 3, 205, 3, 205, 5, 205, 2493, 10, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 5, 206, 2507, 10, 206, 3, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 5, 208, 2520, 10, 208, 3, 208, 3, 208, 3, 208, 3, 208, 5, 208, 2526, 10, 208, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 5, 210, 2545, 10, 210, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 5, 212, 2556, 10, 212, 3, 212, 3, 212, 5, 212, 2560, 10, 212, 3, 212, 3, 212, 3, 213, 3, 213, 5, 213, 2566, 10, 213, 3, 213, 3, 213, 5, 213, 2570, 10, 213, 3, 213, 3, 213, 5, 213, 2574, 10, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 5, 213, 2581, 10, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 5, 214, 2588, 10, 214, 3, 214, 5, 214, 2591, 10, 214, 3, 214, 3, 214, 7, 214, 2595, 10, 214, 12, 214, 14, 214, 2598, 11, 214, 3, 215, 3, 215, 3, 215, 3, 215, 5, 215, 2604, 10, 215, 3, 215, 3, 215, 3, 215, 5, 215, 2609, 10, 215, 3, 215, 5, 215, 2612, 10, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 5, 215, 2620, 10, 215, 3, 216, 3, 216, 3, 216, 3, 216, 5, 216, 2626, 10, 216, 3, 217, 3, 217, 5, 217, 2630, 10, 217, 3, 217, 3, 217, 3, 218, 3, 218, 5, 218, 2636, 10, 218, 3, 218, 3, 218, 5, 218, 2640, 10, 218, 3, 219, 3, 219, 3, 219, 2, 2, 220, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 2, 21, 10, 2, 23, 23, 26, 26, 57, 57, 65, 65, 85, 85, 89, 89, 101, 102, 106, 106, 4, 2, 36, 36, 47, 47, 5, 2, 56, 56, 74, 74, 82, 82, 3, 2, 158, 159, 4, 2, 148, 149, 160, 161, 3, 2, 137, 138, 3, 2, 139, 141, 16, 2, 20, 20, 23, 23, 26, 26, 31, 31, 36, 36, 47, 47, 57, 57, 65, 65, 70, 70, 85, 85, 89, 89, 93, 93, 101, 102, 106, 106, 4, 2, 16, 16, 34, 34, 4, 2, 17, 17, 105, 105, 14, 2, 11, 11, 17, 17, 43, 43, 59, 59, 68, 68, 75, 75, 77, 81, 86, 86, 92, 92, 105, 105, 109, 109, 111, 111, 4, 2, 42, 42, 55, 55, 4, 2, 19, 19, 96, 96, 4, 2, 139, 139, 150, 150, 4, 2, 56, 56, 74, 74, 4, 2, 44, 44, 98, 98, 21, 2, 11, 11, 15, 15, 19, 21, 23, 33, 35, 36, 38, 39, 41, 49, 52, 52, 54, 59, 61, 61, 64, 65, 67, 70, 72, 72, 74, 76, 78, 82, 84, 86, 89, 107, 109, 111, 114, 114, 3, 2, 81, 82, 22, 2, 12, 14, 16, 18, 22, 22, 34, 34, 37, 37, 40, 40, 50, 51, 53, 53, 60, 60, 62, 63, 66, 66, 71, 71, 73, 73, 77, 77, 83, 83, 87, 88, 104, 104, 108, 108, 112, 113, 115, 116, 2, 2914, 2, 439, 3, 2, 2, 2, 4, 463, 3, 2, 2, 2, 6, 475, 3, 2, 2, 2, 8, 489, 3, 2, 2, 2, 10, 491, 3, 2, 2, 2, 12, 501, 3, 2, 2, 2, 14, 507, 3, 2, 2, 2, 16, 512, 3, 2, 2, 2, 18, 514, 3, 2, 2, 2, 20, 516, 3, 2, 2, 2, 22, 522, 3, 2, 2, 2, 24, 524, 3, 2, 2, 2, 26, 535, 3, 2, 2, 2, 28, 546, 3, 2, 2, 2, 30, 561, 3, 2, 2, 2, 32, 566, 3, 2, 2, 2, 34, 576, 3, 2, 2, 2, 36, 589, 3, 2, 2, 2, 38, 591, 3, 2, 2, 2, 40, 599, 3, 2, 2, 2, 42, 607, 3, 2, 2, 2, 44, 615, 3, 2, 2, 2, 46, 623, 3, 2, 2, 2, 48, 631, 3, 2, 2, 2, 50, 639, 3, 2, 2, 2, 52, 647, 3, 2, 2, 2, 54, 655, 3, 2, 2, 2, 56, 667, 3, 2, 2, 2, 58, 678, 3, 2, 2, 2, 60, 686, 3, 2, 2, 2, 62, 694, 3, 2, 2, 2, 64, 706, 3, 2, 2, 2, 66, 714, 3, 2, 2, 2, 68, 729, 3, 2, 2, 2, 70, 757, 3, 2, 2, 2, 72, 759, 3, 2, 2, 2, 74, 918, 3, 2, 2, 2, 76, 922, 3, 2, 2, 2, 78, 924, 3, 2, 2, 2, 80, 928, 3, 2, 2, 2, 82, 936, 3, 2, 2, 2, 84, 952, 3, 2, 2, 2, 86, 956, 3, 2, 2, 2, 88, 958, 3, 2, 2, 2, 90, 968, 3, 2, 2, 2, 92, 970, 3, 2, 2, 2, 94, 979, 3, 2, 2, 2, 96, 992, 3, 2, 2, 2, 98, 999, 3, 2, 2, 2, 100, 1001, 3, 2, 2, 2, 102, 1020, 3, 2, 2, 2, 104, 1022, 3, 2, 2, 2, 106, 1031, 3, 2, 2, 2, 108, 1044, 3, 2, 2, 2, 110, 1046, 3, 2, 2, 2, 112, 1067, 3, 2, 2, 2, 114, 1076, 3, 2, 2, 2, 116, 1093, 3, 2, 2, 2, 118, 1104, 3, 2, 2, 2, 120, 1109, 3, 2, 2, 2, 122, 1126, 3, 2, 2, 2, 124, 1128, 3, 2, 2, 2, 126, 1137, 3, 2, 2, 2, 128, 1142, 3, 2, 2, 2, 130, 1152, 3, 2, 2, 2, 132, 1154, 3, 2, 2, 2, 134, 1157, 3, 2, 2, 2, 136, 1168, 3, 2, 2, 2, 138, 1180, 3, 2, 2, 2, 140, 1182, 3, 2, 2, 2, 142, 1187, 3, 2, 2, 2, 144, 1190, 3, 2, 2, 2, 146, 1205, 3, 2, 2, 2, 148, 1214, 3, 2, 2, 2, 150, 1225, 3, 2, 2, 2, 152, 1227, 3, 2, 2, 2, 154, 1234, 3, 2, 2, 2, 156, 1243, 3, 2, 2, 2, 158, 1245, 3, 2, 2, 2, 160, 1249, 3, 2, 2, 2, 162, 1270, 3, 2, 2, 2, 164, 1277, 3, 2, 2, 2, 166, 1279, 3, 2, 2, 2, 168, 1285, 3, 2, 2, 2, 170, 1417, 3, 2, 2, 2, 172, 1419, 3, 2, 2, 2, 174, 1444, 3, 2, 2, 2, 176, 1448, 3, 2, 2, 2, 178, 1450, 3, 2, 2, 2, 180, 1461, 3, 2, 2, 2, 182, 1463, 3, 2, 2, 2, 184, 1469, 3, 2, 2, 2, 186, 1472, 3, 2, 2, 2, 188, 1487, 3, 2, 2, 2, 190, 1489, 3, 2, 2, 2, 192, 1493, 3, 2, 2, 2, 194, 1506, 3, 2, 2, 2, 196, 1508, 3, 2, 2, 2, 198, 1527, 3, 2, 2, 2, 200, 1529, 3, 2, 2, 2, 202, 1541, 3, 2, 2, 2, 204, 1547, 3, 2, 2, 2, 206, 1552, 3, 2, 2, 2, 208, 1557, 3, 2, 2, 2, 210, 1559, 3, 2, 2, 2, 212, 1565, 3, 2, 2, 2, 214, 1573, 3, 2, 2, 2, 216, 1586, 3, 2, 2, 2, 218, 1590, 3, 2, 2, 2, 220, 1596, 3, 2, 2, 2, 222, 1615, 3, 2, 2, 2, 224, 1618, 3, 2, 2, 2, 226, 1624, 3, 2, 2, 2, 228, 1627, 3, 2, 2, 2, 230, 1639, 3, 2, 2, 2, 232, 1645, 3, 2, 2, 2, 234, 1657, 3, 2, 2, 2, 236, 1661, 3, 2, 2, 2, 238, 1670, 3, 2, 2, 2, 240, 1679, 3, 2, 2, 2, 242, 1683, 3, 2, 2, 2, 244, 1698, 3, 2, 2, 2, 246, 1707, 3, 2, 2, 2, 248, 1709, 3, 2, 2, 2, 250, 1717, 3, 2, 2, 2, 252, 1721, 3, 2, 2, 2, 254, 1728, 3, 2, 2, 2, 256, 1733, 3, 2, 2, 2, 258, 1743, 3, 2, 2, 2, 260, 1747, 3, 2, 2, 2, 262, 1768, 3, 2, 2, 2, 264, 1775, 3, 2, 2, 2, 266, 1789, 3, 2, 2, 2, 268, 1797, 3, 2, 2, 2, 270, 1801, 3, 2, 2, 2, 272, 1809, 3, 2, 2, 2, 274, 1816, 3, 2, 2, 2, 276, 1820, 3, 2, 2, 2, 278, 1822, 3, 2, 2, 2, 280, 1826, 3, 2, 2, 2, 282, 1834, 3, 2, 2, 2, 284, 1836, 3, 2, 2, 2, 286, 1852, 3, 2, 2, 2, 288, 1862, 3, 2, 2, 2, 290, 1865, 3, 2, 2, 2, 292, 1872, 3, 2, 2, 2, 294, 1890, 3, 2, 2, 2, 296, 1899, 3, 2, 2, 2, 298, 1914, 3, 2, 2, 2, 300, 1918, 3, 2, 2, 2, 302, 1921, 3, 2, 2, 2, 304, 1934, 3, 2, 2, 2, 306, 1940, 3, 2, 2, 2, 308, 1967, 3, 2, 2, 2, 310, 1969, 3, 2, 2, 2, 312, 1976, 3, 2, 2, 2, 314, 1986, 3, 2, 2, 2, 316, 1988, 3, 2, 2, 2, 318, 1991, 3, 2, 2, 2, 320, 2001, 3, 2, 2, 2, 322, 2018, 3, 2, 2, 2, 324, 2030, 3, 2, 2, 2, 326, 2039, 3, 2, 2, 2, 328, 2055, 3, 2, 2, 2, 330, 2067, 3, 2, 2, 2, 332, 2074, 3, 2, 2, 2, 334, 2076, 3, 2, 2, 2, 336, 2079, 3, 2, 2, 2, 338, 2089, 3, 2, 2, 2, 340, 2160, 3, 2, 2, 2, 342, 2182, 3, 2, 2, 2, 344, 2185, 3, 2, 2, 2, 346, 2202, 3, 2, 2, 2, 348, 2209, 3, 2, 2, 2, 350, 2220, 3, 2, 2, 2, 352, 2223, 3, 2, 2, 2, 354, 2227, 3, 2, 2, 2, 356, 2241, 3, 2, 2, 2, 358, 2243, 3, 2, 2, 2, 360, 2251, 3, 2, 2, 2, 362, 2269, 3, 2, 2, 2, 364, 2288, 3, 2, 2, 2, 366, 2290, 3, 2, 2, 2, 368, 2298, 3, 2, 2, 2, 370, 2307, 3, 2, 2, 2, 372, 2309, 3, 2, 2, 2, 374, 2343, 3, 2, 2, 2, 376, 2345, 3, 2, 2, 2, 378, 2349, 3, 2, 2, 2, 380, 2353, 3, 2, 2, 2, 382, 2365, 3, 2, 2, 2, 384, 2367, 3, 2, 2, 2, 386, 2373, 3, 2, 2, 2, 388, 2375, 3, 2, 2, 2, 390, 2384, 3, 2, 2, 2, 392, 2397, 3, 2, 2, 2, 394, 2403, 3, 2, 2, 2, 396, 2405, 3, 2, 2, 2, 398, 2421, 3, 2, 2, 2, 400, 2423, 3, 2, 2, 2, 402, 2439, 3, 2, 2, 2, 404, 2456, 3, 2, 2, 2, 406, 2471, 3, 2, 2, 2, 408, 2480, 3, 2, 2, 2, 410, 2496, 3, 2, 2, 2, 412, 2508, 3, 2, 2, 2, 414, 2511, 3, 2, 2, 2, 416, 2527, 3, 2, 2, 2, 418, 2532, 3, 2, 2, 2, 420, 2546, 3, 2, 2, 2, 422, 2552, 3, 2, 2, 2, 424, 2563, 3, 2, 2, 2, 426, 2587, 3, 2, 2, 2, 428, 2599, 3, 2, 2, 2, 430, 2621, 3, 2, 2, 2, 432, 2627, 3, 2, 2, 2, 434, 2633, 3, 2, 2, 2, 436, 2641, 3, 2, 2, 2, 438, 440, 7, 3, 2, 2, 439, 438, 3, 2, 2, 2, 439, 440, 3, 2, 2, 2, 440, 442, 3, 2, 2, 2, 441, 443, 5, 216, 109, 2, 442, 441, 3, 2, 2, 2, 442, 443, 3, 2, 2, 2, 443, 445, 3, 2, 2, 2, 444, 446, 5, 220, 111, 2, 445, 444, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 450, 3, 2, 2, 2, 447, 449, 5, 348, 175, 2, 448, 447, 3, 2, 2, 2, 449, 452, 3, 2, 2, 2, 450, 448, 3, 2, 2, 2, 450, 451, 3, 2, 2, 2, 451, 454, 3, 2, 2, 2, 452, 450, 3, 2, 2, 2, 453, 455, 5, 224, 113, 2, 454, 453, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 456, 3, 2, 2, 2, 456, 457, 7, 2, 2, 3, 457, 3, 3, 2, 2, 2, 458, 460, 5, 436, 219, 2, 459, 461, 5, 24, 13, 2, 460, 459, 3, 2, 2, 2, 460, 461, 3, 2, 2, 2, 461, 464, 3, 2, 2, 2, 462, 464, 5, 230, 116, 2, 463, 458, 3, 2, 2, 2, 463, 462, 3, 2, 2, 2, 464, 472, 3, 2, 2, 2, 465, 466, 7, 133, 2, 2, 466, 468, 5, 436, 219, 2, 467, 469, 5, 24, 13, 2, 468, 467, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 471, 3, 2, 2, 2, 470, 465, 3, 2, 2, 2, 471, 474, 3, 2, 2, 2, 472, 470, 3, 2, 2, 2, 472, 473, 3, 2, 2, 2, 473, 5, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 475, 481, 5, 8, 5, 2, 476, 480, 7, 150, 2, 2, 477, 480, 5, 324, 163, 2, 478, 480, 7, 139, 2, 2, 479, 476, 3, 2, 2, 2, 479, 477, 3, 2, 2, 2, 479, 478, 3, 2, 2, 2, 480, 483, 3, 2, 2, 2, 481, 479, 3, 2, 2, 2, 481, 482, 3, 2, 2, 2, 482, 7, 3, 2, 2, 2, 483, 481, 3, 2, 2, 2, 484, 490, 5, 14, 8, 2, 485, 490, 5, 22, 12, 2, 486, 487, 7, 110, 2, 2, 487, 490, 7, 139, 2, 2, 488, 490, 5, 10, 6, 2, 489, 484, 3, 2, 2, 2, 489, 485, 3, 2, 2, 2, 489, 486, 3, 2, 2, 2, 489, 488, 3, 2, 2, 2, 490, 9, 3, 2, 2, 2, 491, 492, 7, 131, 2, 2, 492, 495, 5, 12, 7, 2, 493, 494, 7, 134, 2, 2, 494, 496, 5, 12, 7, 2, 495, 493, 3, 2, 2, 2, 496, 497, 3, 2, 2, 2, 497, 495, 3, 2, 2, 2, 497, 498, 3, 2, 2, 2, 498, 499, 3, 2, 2, 2, 499, 500, 7, 132, 2, 2, 500, 11, 3, 2, 2, 2, 501, 503, 5, 6, 4, 2, 502, 504, 5, 436, 219, 2, 503, 502, 3, 2, 2, 2, 503, 504, 3, 2, 2, 2, 504, 13, 3, 2, 2, 2, 505, 508, 5, 16, 9, 2, 506, 508, 7, 20, 2, 2, 507, 505, 3, 2, 2, 2, 507, 506, 3, 2, 2, 2, 508, 15, 3, 2, 2, 2, 509, 513, 5, 18, 10, 2, 510, 513, 5, 20, 11, 2, 511, 513, 7, 31, 2, 2, 512, 509, 3, 2, 2, 2, 512, 510, 3, 2, 2, 2, 512, 511, 3, 2, 2, 2, 513, 17, 3, 2, 2, 2, 514, 515, 9, 2, 2, 2, 515, 19, 3, 2, 2, 2, 516, 517, 9, 3, 2, 2, 517, 21, 3, 2, 2, 2, 518, 523, 5, 4, 3, 2, 519, 523, 7, 70, 2, 2, 520, 523, 7, 37, 2, 2, 521, 523, 7, 93, 2, 2, 522, 518, 3, 2, 2, 2, 522, 519, 3, 2, 2, 2, 522, 520, 3, 2, 2, 2, 522, 521, 3, 2, 2, 2, 523, 23, 3, 2, 2, 2, 524, 525, 7, 148, 2, 2, 525, 530, 5, 6, 4, 2, 526, 527, 7, 134, 2, 2, 527, 529, 5, 6, 4, 2, 528, 526, 3, 2, 2, 2, 529, 532, 3, 2, 2, 2, 530, 528, 3, 2, 2, 2, 530, 531, 3, 2, 2, 2, 531, 533, 3, 2, 2, 2, 532, 530, 3, 2, 2, 2, 533, 534, 7, 149, 2, 2, 534, 25, 3, 2, 2, 2, 535, 540, 5, 28, 15, 2, 536, 537, 7, 134, 2, 2, 537, 539, 5, 28, 15, 2, 538, 536, 3, 2, 2, 2, 539, 542, 3, 2, 2, 2, 540, 538, 3, 2, 2, 2, 540, 541, 3, 2, 2, 2, 541, 27, 3, 2, 2, 2, 542, 540, 3, 2, 2, 2, 543, 544, 5, 436, 219, 2, 544, 545, 7, 135, 2, 2, 545, 547, 3, 2, 2, 2, 546, 543, 3, 2, 2, 2, 546, 547, 3, 2, 2, 2, 547, 549, 3, 2, 2, 2, 548, 550, 9, 4, 2, 2, 549, 548, 3, 2, 2, 2, 549, 550, 3, 2, 2, 2, 550, 553, 3, 2, 2, 2, 551, 554, 7, 108, 2, 2, 552, 554, 5, 6, 4, 2, 553, 551, 3, 2, 2, 2, 553, 552, 3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 556, 5, 30, 16, 2, 556, 29, 3, 2, 2, 2, 557, 562, 5, 34, 18, 2, 558, 562, 5, 32, 17, 2, 559, 560, 7, 82, 2, 2, 560, 562, 5, 32, 17, 2, 561, 557, 3, 2, 2, 2, 561, 558, 3, 2, 2, 2, 561, 559, 3, 2, 2, 2, 562, 31, 3, 2, 2, 2, 563, 567, 5, 120, 61, 2, 564, 567, 5, 132, 67, 2, 565, 567, 5, 38, 20, 2, 566, 563, 3, 2, 2, 2, 566, 564, 3, 2, 2, 2, 566, 565, 3, 2, 2, 2, 567, 33, 3, 2, 2, 2, 568, 569, 5, 70, 36, 2, 569, 570, 5, 36, 19, 2, 570, 571, 5, 30, 16, 2, 571, 577, 3, 2, 2, 2, 572, 573, 5, 70, 36, 2, 573, 574, 7, 172, 2, 2, 574, 575, 5, 76, 39, 2, 575, 577, 3, 2, 2, 2, 576, 568, 3, 2, 2, 2, 576, 572, 3, 2, 2, 2, 577, 35, 3, 2, 2, 2, 578, 590, 7, 147, 2, 2, 579, 590, 7, 162, 2, 2, 580, 590, 7, 163, 2, 2, 581, 590, 7, 164, 2, 2, 582, 590, 7, 165, 2, 2, 583, 590, 7, 166, 2, 2, 584, 590, 7, 167, 2, 2, 585, 590, 7, 168, 2, 2, 586, 590, 7, 169, 2, 2, 587, 590, 7, 171, 2, 2, 588, 590, 5, 380, 191, 2, 589, 578, 3, 2, 2, 2, 589, 579, 3, 2, 2, 2, 589, 580, 3, 2, 2, 2, 589, 581, 3, 2, 2, 2, 589, 582, 3, 2, 2, 2, 589, 583, 3, 2, 2, 2, 589, 584, 3, 2, 2, 2, 589, 585, 3, 2, 2, 2, 589, 586, 3, 2, 2, 2, 589, 587, 3, 2, 2, 2, 589, 588, 3, 2, 2, 2, 590, 37, 3, 2, 2, 2, 591, 597, 5, 40, 21, 2, 592, 593, 7, 150, 2, 2, 593, 594, 5, 76, 39, 2, 594, 595, 7, 135, 2, 2, 595, 596, 5, 76, 39, 2, 596, 598, 3, 2, 2, 2, 597, 592, 3, 2, 2, 2, 597, 598, 3, 2, 2, 2, 598, 39, 3, 2, 2, 2, 599, 605, 5, 42, 22, 2, 600, 603, 7, 152, 2, 2, 601, 604, 5, 40, 21, 2, 602, 604, 5, 78, 40, 2, 603, 601, 3, 2, 2, 2, 603, 602, 3, 2, 2, 2, 604, 606, 3, 2, 2, 2, 605, 600, 3, 2, 2, 2, 605, 606, 3, 2, 2, 2, 606, 41, 3, 2, 2, 2, 607, 612, 5, 44, 23, 2, 608, 609, 7, 156, 2, 2, 609, 611, 5, 44, 23, 2, 610, 608, 3, 2, 2, 2, 611, 614, 3, 2, 2, 2, 612, 610, 3, 2, 2, 2, 612, 613, 3, 2, 2, 2, 613, 43, 3, 2, 2, 2, 614, 612, 3, 2, 2, 2, 615, 620, 5, 46, 24, 2, 616, 617, 7, 155, 2, 2, 617, 619, 5, 46, 24, 2, 618, 616, 3, 2, 2, 2, 619, 622, 3, 2, 2, 2, 620, 618, 3, 2, 2, 2, 620, 621, 3, 2, 2, 2, 621, 45, 3, 2, 2, 2, 622, 620, 3, 2, 2, 2, 623, 628, 5, 48, 25, 2, 624, 625, 7, 143, 2, 2, 625, 627, 5, 48, 25, 2, 626, 624, 3, 2, 2, 2, 627, 630, 3, 2, 2, 2, 628, 626, 3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 47, 3, 2, 2, 2, 630, 628, 3, 2, 2, 2, 631, 636, 5, 50, 26, 2, 632, 633, 7, 144, 2, 2, 633, 635, 5, 50, 26, 2, 634, 632, 3, 2, 2, 2, 635, 638, 3, 2, 2, 2, 636, 634, 3, 2, 2, 2, 636, 637, 3, 2, 2, 2, 637, 49, 3, 2, 2, 2, 638, 636, 3, 2, 2, 2, 639, 644, 5, 52, 27, 2, 640, 641, 7, 142, 2, 2, 641, 643, 5, 52, 27, 2, 642, 640, 3, 2, 2, 2, 643, 646, 3, 2, 2, 2, 644, 642, 3, 2, 2, 2, 644, 645, 3, 2, 2, 2, 645, 51, 3, 2, 2, 2, 646, 644, 3, 2, 2, 2, 647, 652, 5, 54, 28, 2, 648, 649, 9, 5, 2, 2, 649, 651, 5, 54, 28, 2, 650, 648, 3, 2, 2, 2, 651, 654, 3, 2, 2, 2, 652, 650, 3, 2, 2, 2, 652, 653, 3, 2, 2, 2, 653, 53, 3, 2, 2, 2, 654, 652, 3, 2, 2, 2, 655, 664, 5, 56, 29, 2, 656, 657, 9, 6, 2, 2, 657, 663, 5, 56, 29, 2, 658, 659, 7, 61, 2, 2, 659, 663, 5, 114, 58, 2, 660, 661, 7, 15, 2, 2, 661, 663, 5, 6, 4, 2, 662, 656, 3, 2, 2, 2, 662, 658, 3, 2, 2, 2, 662, 660, 3, 2, 2, 2, 663, 666, 3, 2, 2, 2, 664, 662, 3, 2, 2, 2, 664, 665, 3, 2, 2, 2, 665, 55, 3, 2, 2, 2, 666, 664, 3, 2, 2, 2, 667, 675, 5, 58, 30, 2, 668, 671, 7, 170, 2, 2, 669, 671, 5, 378, 190, 2, 670, 668, 3, 2, 2, 2, 670, 669, 3, 2, 2, 2, 671, 672, 3, 2, 2, 2, 672, 674, 5, 58, 30, 2, 673, 670, 3, 2, 2, 2, 674, 677, 3, 2, 2, 2, 675, 673, 3, 2, 2, 2, 675, 676, 3, 2, 2, 2, 676, 57, 3, 2, 2, 2, 677, 675, 3, 2, 2, 2, 678, 683, 5, 60, 31, 2, 679, 680, 9, 7, 2, 2, 680, 682, 5, 60, 31, 2, 681, 679, 3, 2, 2, 2, 682, 685, 3, 2, 2, 2, 683, 681, 3, 2, 2, 2, 683, 684, 3, 2, 2, 2, 684, 59, 3, 2, 2, 2, 685, 683, 3, 2, 2, 2, 686, 691, 5, 62, 32, 2, 687, 688, 9, 8, 2, 2, 688, 690, 5, 62, 32, 2, 689, 687, 3, 2, 2, 2, 690, 693, 3, 2, 2, 2, 691, 689, 3, 2, 2, 2, 691, 692, 3, 2, 2, 2, 692, 61, 3, 2, 2, 2, 693, 691, 3, 2, 2, 2, 694, 704, 5, 68, 35, 2, 695, 696, 7, 95, 2, 2, 696, 701, 7, 127, 2, 2, 697, 699, 5, 64, 33, 2, 698, 700, 7, 134, 2, 2, 699, 698, 3, 2, 2, 2, 699, 700, 3, 2, 2, 2, 700, 702, 3, 2, 2, 2, 701, 697, 3, 2, 2, 2, 701, 702, 3, 2, 2, 2, 702, 703, 3, 2, 2, 2, 703, 705, 7, 128, 2, 2, 704, 695, 3, 2, 2, 2, 704, 705, 3, 2, 2, 2, 705, 63, 3, 2, 2, 2, 706, 711, 5, 66, 34, 2, 707, 708, 7, 134, 2, 2, 708, 710, 5, 66, 34, 2, 709, 707, 3, 2, 2, 2, 710, 713, 3, 2, 2, 2, 711, 709, 3, 2, 2, 2, 711, 712, 3, 2, 2, 2, 712, 65, 3, 2, 2, 2, 713, 711, 3, 2, 2, 2, 714, 716, 5, 30, 16, 2, 715, 717, 5, 190, 96, 2, 716, 715, 3, 2, 2, 2, 716, 717, 3, 2, 2, 2, 717, 718, 3, 2, 2, 2, 718, 719, 5, 376, 189, 2, 719, 720, 5, 76, 39, 2, 720, 67, 3, 2, 2, 2, 721, 730, 5, 70, 36, 2, 722, 724, 5, 70, 36, 2, 723, 722, 3, 2, 2, 2, 723, 724, 3, 2, 2, 2, 724, 725, 3, 2, 2, 2, 725, 727, 7, 173, 2, 2, 726, 728, 5, 70, 36, 2, 727, 726, 3, 2, 2, 2, 727, 728, 3, 2, 2, 2, 728, 730, 3, 2, 2, 2, 729, 721, 3, 2, 2, 2, 729, 723, 3, 2, 2, 2, 730, 69, 3, 2, 2, 2, 731, 758, 5, 72, 37, 2, 732, 733, 7, 137, 2, 2, 733, 758, 5, 70, 36, 2, 734, 735, 7, 138, 2, 2, 735, 758, 5, 70, 36, 2, 736, 737, 7, 145, 2, 2, 737, 758, 5, 70, 36, 2, 738, 739, 7, 146, 2, 2, 739, 758, 5, 70, 36, 2, 740, 741, 7, 153, 2, 2, 741, 758, 5, 70, 36, 2, 742, 743, 7, 154, 2, 2, 743, 758, 5, 70, 36, 2, 744, 745, 7, 131, 2, 2, 745, 746, 5, 6, 4, 2, 746, 747, 7, 132, 2, 2, 747, 748, 5, 70, 36, 2, 748, 758, 3, 2, 2, 2, 749, 750, 7, 18, 2, 2, 750, 758, 5, 70, 36, 2, 751, 752, 7, 142, 2, 2, 752, 758, 5, 70, 36, 2, 753, 754, 7, 139, 2, 2, 754, 758, 5, 70, 36, 2, 755, 756, 7, 144, 2, 2, 756, 758, 5, 70, 36, 2, 757, 731, 3, 2, 2, 2, 757, 732, 3, 2, 2, 2, 757, 734, 3, 2, 2, 2, 757, 736, 3, 2, 2, 2, 757, 738, 3, 2, 2, 2, 757, 740, 3, 2, 2, 2, 757, 742, 3, 2, 2, 2, 757, 744, 3, 2, 2, 2, 757, 749, 3, 2, 2, 2, 757, 751, 3, 2, 2, 2, 757, 753, 3, 2, 2, 2, 757, 755, 3, 2, 2, 2, 758, 71, 3, 2, 2, 2, 759, 761, 5, 74, 38, 2, 760, 762, 7, 145, 2, 2, 761, 760, 3, 2, 2, 2, 761, 762, 3, 2, 2, 2, 762, 766, 3, 2, 2, 2, 763, 765, 5, 82, 42, 2, 764, 763, 3, 2, 2, 2, 765, 768, 3, 2, 2, 2, 766, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 770, 3, 2, 2, 2, 768, 766, 3, 2, 2, 2, 769, 771, 7, 145, 2, 2, 770, 769, 3, 2, 2, 2, 770, 771, 3, 2, 2, 2, 771, 794, 3, 2, 2, 2, 772, 779, 5, 80, 41, 2, 773, 779, 5, 432, 217, 2, 774, 779, 7, 153, 2, 2, 775, 779, 7, 154, 2, 2, 776, 777, 7, 157, 2, 2, 777, 779, 5, 436, 219, 2, 778, 772, 3, 2, 2, 2, 778, 773, 3, 2, 2, 2, 778, 774, 3, 2, 2, 2, 778, 775, 3, 2, 2, 2, 778, 776, 3, 2, 2, 2, 779, 781, 3, 2, 2, 2, 780, 782, 7, 145, 2, 2, 781, 780, 3, 2, 2, 2, 781, 782, 3, 2, 2, 2, 782, 786, 3, 2, 2, 2, 783, 785, 5, 82, 42, 2, 784, 783, 3, 2, 2, 2, 785, 788, 3, 2, 2, 2, 786, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 790, 3, 2, 2, 2, 788, 786, 3, 2, 2, 2, 789, 791, 7, 145, 2, 2, 790, 789, 3, 2, 2, 2, 790, 791, 3, 2, 2, 2, 791, 793, 3, 2, 2, 2, 792, 778, 3, 2, 2, 2, 793, 796, 3, 2, 2, 2, 794, 792, 3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 73, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 919, 5, 382, 192, 2, 798, 800, 5, 436, 219, 2, 799, 801, 5, 24, 13, 2, 800, 799, 3, 2, 2, 2, 800, 801, 3, 2, 2, 2, 801, 919, 3, 2, 2, 2, 802, 803, 7, 131, 2, 2, 803, 804, 5, 30, 16, 2, 804, 805, 7, 132, 2, 2, 805, 919, 3, 2, 2, 2, 806, 919, 5, 86, 44, 2, 807, 919, 5, 230, 116, 2, 808, 919, 7, 117, 2, 2, 809, 919, 7, 96, 2, 2, 810, 820, 7, 19, 2, 2, 811, 812, 7, 133, 2, 2, 812, 814, 5, 436, 219, 2, 813, 815, 5, 24, 13, 2, 814, 813, 3, 2, 2, 2, 814, 815, 3, 2, 2, 2, 815, 821, 3, 2, 2, 2, 816, 817, 7, 129, 2, 2, 817, 818, 5, 88, 45, 2, 818, 819, 7, 130, 2, 2, 819, 821, 3, 2, 2, 2, 820, 811, 3, 2, 2, 2, 820, 816, 3, 2, 2, 2, 821, 919, 3, 2, 2, 2, 822, 851, 7, 68, 2, 2, 823, 845, 5, 6, 4, 2, 824, 846, 5, 434, 218, 2, 825, 846, 5, 90, 46, 2, 826, 827, 7, 129, 2, 2, 827, 828, 5, 88, 45, 2, 828, 832, 7, 130, 2, 2, 829, 831, 5, 324, 163, 2, 830, 829, 3, 2, 2, 2, 831, 834, 3, 2, 2, 2, 832, 830, 3, 2, 2, 2, 832, 833, 3, 2, 2, 2, 833, 836, 3, 2, 2, 2, 834, 832, 3, 2, 2, 2, 835, 837, 5, 326, 164, 2, 836, 835, 3, 2, 2, 2, 836, 837, 3, 2, 2, 2, 837, 846, 3, 2, 2, 2, 838, 840, 5, 324, 163, 2, 839, 838, 3, 2, 2, 2, 840, 841, 3, 2, 2, 2, 841, 839, 3, 2, 2, 2, 841, 842, 3, 2, 2, 2, 842, 843, 3, 2, 2, 2, 843, 844, 5, 326, 164, 2, 844, 846, 3, 2, 2, 2, 845, 824, 3, 2, 2, 2, 845, 825, 3, 2, 2, 2, 845, 826, 3, 2, 2, 2, 845, 839, 3, 2, 2, 2, 846, 852, 3, 2, 2, 2, 847, 852, 5, 104, 53, 2, 848, 849, 5, 324, 163, 2, 849, 850, 5, 326, 164, 2, 850, 852, 3, 2, 2, 2, 851, 823, 3, 2, 2, 2, 851, 847, 3, 2, 2, 2, 851, 848, 3, 2, 2, 2, 852, 919, 3, 2, 2, 2, 853, 854, 7, 131, 2, 2, 854, 857, 5, 28, 15, 2, 855, 856, 7, 134, 2, 2, 856, 858, 5, 28, 15, 2, 857, 855, 3, 2, 2, 2, 858, 859, 3, 2, 2, 2, 859, 857, 3, 2, 2, 2, 859, 860, 3, 2, 2, 2, 860, 861, 3, 2, 2, 2, 861, 862, 7, 132, 2, 2, 862, 919, 3, 2, 2, 2, 863, 864, 7, 100, 2, 2, 864, 868, 7, 131, 2, 2, 865, 869, 5, 110, 56, 2, 866, 869, 5, 6, 4, 2, 867, 869, 7, 110, 2, 2, 868, 865, 3, 2, 2, 2, 868, 866, 3, 2, 2, 2, 868, 867, 3, 2, 2, 2, 869, 870, 3, 2, 2, 2, 870, 919, 7, 132, 2, 2, 871, 872, 7, 27, 2, 2, 872, 873, 7, 131, 2, 2, 873, 874, 5, 30, 16, 2, 874, 875, 7, 132, 2, 2, 875, 919, 3, 2, 2, 2, 876, 877, 7, 103, 2, 2, 877, 878, 7, 131, 2, 2, 878, 879, 5, 30, 16, 2, 879, 880, 7, 132, 2, 2, 880, 919, 3, 2, 2, 2, 881, 886, 7, 32, 2, 2, 882, 883, 7, 131, 2, 2, 883, 884, 5, 6, 4, 2, 884, 885, 7, 132, 2, 2, 885, 887, 3, 2, 2, 2, 886, 882, 3, 2, 2, 2, 886, 887, 3, 2, 2, 2, 887, 919, 3, 2, 2, 2, 888, 890, 7, 17, 2, 2, 889, 888, 3, 2, 2, 2, 889, 890, 3, 2, 2, 2, 890, 891, 3, 2, 2, 2, 891, 897, 7, 33, 2, 2, 892, 894, 7, 131, 2, 2, 893, 895, 5, 124, 63, 2, 894, 893, 3, 2, 2, 2, 894, 895, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 898, 7, 132, 2, 2, 897, 892, 3, 2, 2, 2, 897, 898, 3, 2, 2, 2, 898, 899, 3, 2, 2, 2, 899, 919, 5, 172, 87, 2, 900, 901, 7, 90, 2, 2, 901, 902, 7, 131, 2, 2, 902, 903, 5, 6, 4, 2, 903, 904, 7, 132, 2, 2, 904, 919, 3, 2, 2, 2, 905, 906, 7, 66, 2, 2, 906, 912, 7, 131, 2, 2, 907, 908, 5, 436, 219, 2, 908, 909, 7, 133, 2, 2, 909, 911, 3, 2, 2, 2, 910, 907, 3, 2, 2, 2, 911, 914, 3, 2, 2, 2, 912, 910, 3, 2, 2, 2, 912, 913, 3, 2, 2, 2, 913, 915, 3, 2, 2, 2, 914, 912, 3, 2, 2, 2, 915, 916, 5, 436, 219, 2, 916, 917, 7, 132, 2, 2, 917, 919, 3, 2, 2, 2, 918, 797, 3, 2, 2, 2, 918, 798, 3, 2, 2, 2, 918, 802, 3, 2, 2, 2, 918, 806, 3, 2, 2, 2, 918, 807, 3, 2, 2, 2, 918, 808, 3, 2, 2, 2, 918, 809, 3, 2, 2, 2, 918, 810, 3, 2, 2, 2, 918, 822, 3, 2, 2, 2, 918, 853, 3, 2, 2, 2, 918, 863, 3, 2, 2, 2, 918, 871, 3, 2, 2, 2, 918, 876, 3, 2, 2, 2, 918, 881, 3, 2, 2, 2, 918, 889, 3, 2, 2, 2, 918, 900, 3, 2, 2, 2, 918, 905, 3, 2, 2, 2, 919, 75, 3, 2, 2, 2, 920, 923, 5, 30, 16, 2, 921, 923, 5, 78, 40, 2, 922, 920, 3, 2, 2, 2, 922, 921, 3, 2, 2, 2, 923, 77, 3, 2, 2, 2, 924, 925, 7, 97, 2, 2, 925, 926, 5, 30, 16, 2, 926, 79, 3, 2, 2, 2, 927, 929, 7, 150, 2, 2, 928, 927, 3, 2, 2, 2, 928, 929, 3, 2, 2, 2, 929, 930, 3, 2, 2, 2, 930, 931, 7, 133, 2, 2, 931, 933, 5, 436, 219, 2, 932, 934, 5, 24, 13, 2, 933, 932, 3, 2, 2, 2, 933, 934, 3, 2, 2, 2, 934, 81, 3, 2, 2, 2, 935, 937, 7, 150, 2, 2, 936, 935, 3, 2, 2, 2, 936, 937, 3, 2, 2, 2, 937, 938, 3, 2, 2, 2, 938, 939, 7, 129, 2, 2, 939, 944, 5, 84, 43, 2, 940, 941, 7, 134, 2, 2, 941, 943, 5, 84, 43, 2, 942, 940, 3, 2, 2, 2, 943, 946, 3, 2, 2, 2, 944, 942, 3, 2, 2, 2, 944, 945, 3, 2, 2, 2, 945, 947, 3, 2, 2, 2, 946, 944, 3, 2, 2, 2, 947, 948, 7, 130, 2, 2, 948, 83, 3, 2, 2, 2, 949, 950, 5, 436, 219, 2, 950, 951, 7, 135, 2, 2, 951, 953, 3, 2, 2, 2, 952, 949, 3, 2, 2, 2, 952, 953, 3, 2, 2, 2, 953, 954, 3, 2, 2, 2, 954, 955, 5, 30, 16, 2, 955, 85, 3, 2, 2, 2, 956, 957, 9, 9, 2, 2, 957, 87, 3, 2, 2, 2, 958, 963, 5, 30, 16, 2, 959, 960, 7, 134, 2, 2, 960, 962, 5, 30, 16, 2, 961, 959, 3, 2, 2, 2, 962, 965, 3, 2, 2, 2, 963, 961, 3, 2, 2, 2, 963, 964, 3, 2, 2, 2, 964, 89, 3, 2, 2, 2, 965, 963, 3, 2, 2, 2, 966, 969, 5, 92, 47, 2, 967, 969, 5, 100, 51, 2, 968, 966, 3, 2, 2, 2, 968, 967, 3, 2, 2, 2, 969, 91, 3, 2, 2, 2, 970, 975, 7, 127, 2, 2, 971, 973, 5, 94, 48, 2, 972, 974, 7, 134, 2, 2, 973, 972, 3, 2, 2, 2, 973, 974, 3, 2, 2, 2, 974, 976, 3, 2, 2, 2, 975, 971, 3, 2, 2, 2, 975, 976, 3, 2, 2, 2, 976, 977, 3, 2, 2, 2, 977, 978, 7, 128, 2, 2, 978, 93, 3, 2, 2, 2, 979, 984, 5, 96, 49, 2, 980, 981, 7, 134, 2, 2, 981, 983, 5, 96, 49, 2, 982, 980, 3, 2, 2, 2, 983, 986, 3, 2, 2, 2, 984, 982, 3, 2, 2, 2, 984, 985, 3, 2, 2, 2, 985, 95, 3, 2, 2, 2, 986, 984, 3, 2, 2, 2, 987, 993, 5, 436, 219, 2, 988, 989, 7, 129, 2, 2, 989, 990, 5, 30, 16, 2, 990, 991, 7, 130, 2, 2, 991, 993, 3, 2, 2, 2, 992, 987, 3, 2, 2, 2, 992, 988, 3, 2, 2, 2, 993, 994, 3, 2, 2, 2, 994, 995, 7, 147, 2, 2, 995, 996, 5, 98, 50, 2, 996, 97, 3, 2, 2, 2, 997, 1000, 5, 30, 16, 2, 998, 1000, 5, 90, 46, 2, 999, 997, 3, 2, 2, 2, 999, 998, 3, 2, 2, 2, 1000, 99, 3, 2, 2, 2, 1001, 1002, 7, 127, 2, 2, 1002, 1007, 5, 102, 52, 2, 1003, 1004, 7, 134, 2, 2, 1004, 1006, 5, 102, 52, 2, 1005, 1003, 3, 2, 2, 2, 1006, 1009, 3, 2, 2, 2, 1007, 1005, 3, 2, 2, 2, 1007, 1008, 3, 2, 2, 2, 1008, 1011, 3, 2, 2, 2, 1009, 1007, 3, 2, 2, 2, 1010, 1012, 7, 134, 2, 2, 1011, 1010, 3, 2, 2, 2, 1011, 1012, 3, 2, 2, 2, 1012, 1013, 3, 2, 2, 2, 1013, 1014, 7, 128, 2, 2, 1014, 101, 3, 2, 2, 2, 1015, 1021, 5, 32, 17, 2, 1016, 1017, 7, 127, 2, 2, 1017, 1018, 5, 88, 45, 2, 1018, 1019, 7, 128, 2, 2, 1019, 1021, 3, 2, 2, 2, 1020, 1015, 3, 2, 2, 2, 1020, 1016, 3, 2, 2, 2, 1021, 103, 3, 2, 2, 2, 1022, 1027, 7, 127, 2, 2, 1023, 1025, 5, 106, 54, 2, 1024, 1026, 7, 134, 2, 2, 1025, 1024, 3, 2, 2, 2, 1025, 1026, 3, 2, 2, 2, 1026, 1028, 3, 2, 2, 2, 1027, 1023, 3, 2, 2, 2, 1027, 1028, 3, 2, 2, 2, 1028, 1029, 3, 2, 2, 2, 1029, 1030, 7, 128, 2, 2, 1030, 105, 3, 2, 2, 2, 1031, 1036, 5, 108, 55, 2, 1032, 1033, 7, 134, 2, 2, 1033, 1035, 5, 108, 55, 2, 1034, 1032, 3, 2, 2, 2, 1035, 1038, 3, 2, 2, 2, 1036, 1034, 3, 2, 2, 2, 1036, 1037, 3, 2, 2, 2, 1037, 107, 3, 2, 2, 2, 1038, 1036, 3, 2, 2, 2, 1039, 1045, 5, 72, 37, 2, 1040, 1041, 5, 436, 219, 2, 1041, 1042, 7, 147, 2, 2, 1042, 1043, 5, 30, 16, 2, 1043, 1045, 3, 2, 2, 2, 1044, 1039, 3, 2, 2, 2, 1044, 1040, 3, 2, 2, 2, 1045, 109, 3, 2, 2, 2, 1046, 1055, 5, 436, 219, 2, 1047, 1049, 5, 112, 57, 2, 1048, 1047, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 1056, 3, 2, 2, 2, 1050, 1051, 7, 151, 2, 2, 1051, 1053, 5, 436, 219, 2, 1052, 1054, 5, 112, 57, 2, 1053, 1052, 3, 2, 2, 2, 1053, 1054, 3, 2, 2, 2, 1054, 1056, 3, 2, 2, 2, 1055, 1048, 3, 2, 2, 2, 1055, 1050, 3, 2, 2, 2, 1056, 1064, 3, 2, 2, 2, 1057, 1058, 7, 133, 2, 2, 1058, 1060, 5, 436, 219, 2, 1059, 1061, 5, 112, 57, 2, 1060, 1059, 3, 2, 2, 2, 1060, 1061, 3, 2, 2, 2, 1061, 1063, 3, 2, 2, 2, 1062, 1057, 3, 2, 2, 2, 1063, 1066, 3, 2, 2, 2, 1064, 1062, 3, 2, 2, 2, 1064, 1065, 3, 2, 2, 2, 1065, 111, 3, 2, 2, 2, 1066, 1064, 3, 2, 2, 2, 1067, 1071, 7, 148, 2, 2, 1068, 1070, 7, 134, 2, 2, 1069, 1068, 3, 2, 2, 2, 1070, 1073, 3, 2, 2, 2, 1071, 1069, 3, 2, 2, 2, 1071, 1072, 3, 2, 2, 2, 1072, 1074, 3, 2, 2, 2, 1073, 1071, 3, 2, 2, 2, 1074, 1075, 7, 149, 2, 2, 1075, 113, 3, 2, 2, 2, 1076, 1081, 5, 8, 5, 2, 1077, 1080, 5, 324, 163, 2, 1078, 1080, 7, 139, 2, 2, 1079, 1077, 3, 2, 2, 2, 1079, 1078, 3, 2, 2, 2, 1080, 1083, 3, 2, 2, 2, 1081, 1079, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 1085, 3, 2, 2, 2, 1083, 1081, 3, 2, 2, 2, 1084, 1086, 7, 150, 2, 2, 1085, 1084, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086, 1088, 3, 2, 2, 2, 1087, 1089, 5, 116, 59, 2, 1088, 1087, 3, 2, 2, 2, 1088, 1089, 3, 2, 2, 2, 1089, 1091, 3, 2, 2, 2, 1090, 1092, 5, 436, 219, 2, 1091, 1090, 3, 2, 2, 2, 1091, 1092, 3, 2, 2, 2, 1092, 115, 3, 2, 2, 2, 1093, 1094, 7, 127, 2, 2, 1094, 1099, 5, 118, 60, 2, 1095, 1096, 7, 134, 2, 2, 1096, 1098, 5, 118, 60, 2, 1097, 1095, 3, 2, 2, 2, 1098, 1101, 3, 2, 2, 2, 1099, 1097, 3, 2, 2, 2, 1099, 1100, 3, 2, 2, 2, 1100, 1102, 3, 2, 2, 2, 1101, 1099, 3, 2, 2, 2, 1102, 1103, 7, 128, 2, 2, 1103, 117, 3, 2, 2, 2, 1104, 1105, 5, 436, 219, 2, 1105, 1106, 7, 135, 2, 2, 1106, 1107, 5, 30, 16, 2, 1107, 119, 3, 2, 2, 2, 1108, 1110, 7, 17, 2, 2, 1109, 1108, 3, 2, 2, 2, 1109, 1110, 3, 2, 2, 2, 1110, 1111, 3, 2, 2, 2, 1111, 1112, 5, 122, 62, 2, 1112, 1113, 5, 376, 189, 2, 1113, 1114, 5, 130, 66, 2, 1114, 121, 3, 2, 2, 2, 1115, 1116, 7, 131, 2, 2, 1116, 1127, 7, 132, 2, 2, 1117, 1118, 7, 131, 2, 2, 1118, 1119, 5, 124, 63, 2, 1119, 1120, 7, 132, 2, 2, 1120, 1127, 3, 2, 2, 2, 1121, 1122, 7, 131, 2, 2, 1122, 1123, 5, 128, 65, 2, 1123, 1124, 7, 132, 2, 2, 1124, 1127, 3, 2, 2, 2, 1125, 1127, 5, 436, 219, 2, 1126, 1115, 3, 2, 2, 2, 1126, 1117, 3, 2, 2, 2, 1126, 1121, 3, 2, 2, 2, 1126, 1125, 3, 2, 2, 2, 1127, 123, 3, 2, 2, 2, 1128, 1133, 5, 126, 64, 2, 1129, 1130, 7, 134, 2, 2, 1130, 1132, 5, 126, 64, 2, 1131, 1129, 3, 2, 2, 2, 1132, 1135, 3, 2, 2, 2, 1133, 1131, 3, 2, 2, 2, 1133, 1134, 3, 2, 2, 2, 1134, 125, 3, 2, 2, 2, 1135, 1133, 3, 2, 2, 2, 1136, 1138, 9, 4, 2, 2, 1137, 1136, 3, 2, 2, 2, 1137, 1138, 3, 2, 2, 2, 1138, 1139, 3, 2, 2, 2, 1139, 1140, 5, 6, 4, 2, 1140, 1141, 5, 436, 219, 2, 1141, 127, 3, 2, 2, 2, 1142, 1147, 5, 436, 219, 2, 1143, 1144, 7, 134, 2, 2, 1144, 1146, 5, 436, 219, 2, 1145, 1143, 3, 2, 2, 2, 1146, 1149, 3, 2, 2, 2, 1147, 1145, 3, 2, 2, 2, 1147, 1148, 3, 2, 2, 2, 1148, 129, 3, 2, 2, 2, 1149, 1147, 3, 2, 2, 2, 1150, 1153, 5, 76, 39, 2, 1151, 1153, 5, 172, 87, 2, 1152, 1150, 3, 2, 2, 2, 1152, 1151, 3, 2, 2, 2, 1153, 131, 3, 2, 2, 2, 1154, 1155, 5, 134, 68, 2, 1155, 1156, 5, 136, 69, 2, 1156, 133, 3, 2, 2, 2, 1157, 1159, 7, 50, 2, 2, 1158, 1160, 5, 6, 4, 2, 1159, 1158, 3, 2, 2, 2, 1159, 1160, 3, 2, 2, 2, 1160, 1161, 3, 2, 2, 2, 1161, 1162, 5, 436, 219, 2, 1162, 1163, 7, 56, 2, 2, 1163, 1164, 5, 30, 16, 2, 1164, 135, 3, 2, 2, 2, 1165, 1167, 5, 138, 70, 2, 1166, 1165, 3, 2, 2, 2, 1167, 1170, 3, 2, 2, 2, 1168, 1166, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 1171, 3, 2, 2, 2, 1170, 1168, 3, 2, 2, 2, 1171, 1173, 5, 150, 76, 2, 1172, 1174, 5, 152, 77, 2, 1173, 1172, 3, 2, 2, 2, 1173, 1174, 3, 2, 2, 2, 1174, 137, 3, 2, 2, 2, 1175, 1181, 5, 134, 68, 2, 1176, 1181, 5, 140, 71, 2, 1177, 1181, 5, 142, 72, 2, 1178, 1181, 5, 144, 73, 2, 1179, 1181, 5, 146, 74, 2, 1180, 1175, 3, 2, 2, 2, 1180, 1176, 3, 2, 2, 2, 1180, 1177, 3, 2, 2, 2, 1180, 1178, 3, 2, 2, 2, 1180, 1179, 3, 2, 2, 2, 1181, 139, 3, 2, 2, 2, 1182, 1183, 7, 63, 2, 2, 1183, 1184, 5, 436, 219, 2, 1184, 1185, 7, 147, 2, 2, 1185, 1186, 5, 30, 16, 2, 1186, 141, 3, 2, 2, 2, 1187, 1188, 7, 113, 2, 2, 1188, 1189, 5, 30, 16, 2, 1189, 143, 3, 2, 2, 2, 1190, 1192, 7, 62, 2, 2, 1191, 1193, 5, 6, 4, 2, 1192, 1191, 3, 2, 2, 2, 1192, 1193, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 1195, 5, 436, 219, 2, 1195, 1196, 7, 56, 2, 2, 1196, 1197, 5, 30, 16, 2, 1197, 1198, 7, 71, 2, 2, 1198, 1199, 5, 30, 16, 2, 1199, 1200, 7, 40, 2, 2, 1200, 1203, 5, 30, 16, 2, 1201, 1202, 7, 60, 2, 2, 1202, 1204, 5, 436, 219, 2, 1203, 1201, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 145, 3, 2, 2, 2, 1205, 1206, 7, 73, 2, 2, 1206, 1211, 5, 148, 75, 2, 1207, 1208, 7, 134, 2, 2, 1208, 1210, 5, 148, 75, 2, 1209, 1207, 3, 2, 2, 2, 1210, 1213, 3, 2, 2, 2, 1211, 1209, 3, 2, 2, 2, 1211, 1212, 3, 2, 2, 2, 1212, 147, 3, 2, 2, 2, 1213, 1211, 3, 2, 2, 2, 1214, 1216, 5, 30, 16, 2, 1215, 1217, 9, 10, 2, 2, 1216, 1215, 3, 2, 2, 2, 1216, 1217, 3, 2, 2, 2, 1217, 149, 3, 2, 2, 2, 1218, 1219, 7, 87, 2, 2, 1219, 1226, 5, 30, 16, 2, 1220, 1221, 7, 53, 2, 2, 1221, 1222, 5, 30, 16, 2, 1222, 1223, 7, 22, 2, 2, 1223, 1224, 5, 30, 16, 2, 1224, 1226, 3, 2, 2, 2, 1225, 1218, 3, 2, 2, 2, 1225, 1220, 3, 2, 2, 2, 1226, 151, 3, 2, 2, 2, 1227, 1228, 7, 60, 2, 2, 1228, 1229, 5, 436, 219, 2, 1229, 1230, 5, 136, 69, 2, 1230, 153, 3, 2, 2, 2, 1231, 1235, 5, 166, 84, 2, 1232, 1235, 5, 156, 79, 2, 1233, 1235, 5, 168, 85, 2, 1234, 1231, 3, 2, 2, 2, 1234, 1232, 3, 2, 2, 2, 1234, 1233, 3, 2, 2, 2, 1235, 155, 3, 2, 2, 2, 1236, 1237, 5, 174, 88, 2, 1237, 1238, 7, 136, 2, 2, 1238, 1244, 3, 2, 2, 2, 1239, 1240, 5, 182, 92, 2, 1240, 1241, 7, 136, 2, 2, 1241, 1244, 3, 2, 2, 2, 1242, 1244, 5, 158, 80, 2, 1243, 1236, 3, 2, 2, 2, 1243, 1239, 3, 2, 2, 2, 1243, 1242, 3, 2, 2, 2, 1244, 157, 3, 2, 2, 2, 1245, 1246, 5, 160, 81, 2, 1246, 1247, 5, 164, 83, 2, 1247, 159, 3, 2, 2, 2, 1248, 1250, 5, 162, 82, 2, 1249, 1248, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1251, 3, 2, 2, 2, 1251, 1252, 5, 276, 139, 2, 1252, 1254, 5, 436, 219, 2, 1253, 1255, 5, 232, 117, 2, 1254, 1253, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1256, 3, 2, 2, 2, 1256, 1258, 7, 131, 2, 2, 1257, 1259, 5, 282, 142, 2, 1258, 1257, 3, 2, 2, 2, 1258, 1259, 3, 2, 2, 2, 1259, 1260, 3, 2, 2, 2, 1260, 1262, 7, 132, 2, 2, 1261, 1263, 5, 240, 121, 2, 1262, 1261, 3, 2, 2, 2, 1262, 1263, 3, 2, 2, 2, 1263, 161, 3, 2, 2, 2, 1264, 1266, 9, 11, 2, 2, 1265, 1267, 7, 92, 2, 2, 1266, 1265, 3, 2, 2, 2, 1266, 1267, 3, 2, 2, 2, 1267, 1271, 3, 2, 2, 2, 1268, 1269, 7, 92, 2, 2, 1269, 1271, 9, 11, 2, 2, 1270, 1264, 3, 2, 2, 2, 1270, 1268, 3, 2, 2, 2, 1271, 163, 3, 2, 2, 2, 1272, 1278, 5, 172, 87, 2, 1273, 1274, 5, 376, 189, 2, 1274, 1275, 5, 76, 39, 2, 1275, 1276, 7, 136, 2, 2, 1276, 1278, 3, 2, 2, 2, 1277, 1272, 3, 2, 2, 2, 1277, 1273, 3, 2, 2, 2, 1278, 165, 3, 2, 2, 2, 1279, 1280, 5, 436, 219, 2, 1280, 1281, 7, 135, 2, 2, 1281, 1282, 5, 154, 78, 2, 1282, 167, 3, 2, 2, 2, 1283, 1286, 5, 172, 87, 2, 1284, 1286, 5, 170, 86, 2, 1285, 1283, 3, 2, 2, 2, 1285, 1284, 3, 2, 2, 2, 1286, 169, 3, 2, 2, 2, 1287, 1418, 7, 136, 2, 2, 1288, 1289, 5, 30, 16, 2, 1289, 1290, 7, 136, 2, 2, 1290, 1418, 3, 2, 2, 2, 1291, 1292, 7, 54, 2, 2, 1292, 1293, 7, 131, 2, 2, 1293, 1294, 5, 30, 16, 2, 1294, 1295, 7, 132, 2, 2, 1295, 1298, 5, 184, 93, 2, 1296, 1297, 7, 38, 2, 2, 1297, 1299, 5, 184, 93, 2, 1298, 1296, 3, 2, 2, 2, 1298, 1299, 3, 2, 2, 2, 1299, 1418, 3, 2, 2, 2, 1300, 1301, 7, 95, 2, 2, 1301, 1302, 7, 131, 2, 2, 1302, 1303, 5, 30, 16, 2, 1303, 1304, 7, 132, 2, 2, 1304, 1308, 7, 127, 2, 2, 1305, 1307, 5, 186, 94, 2, 1306, 1305, 3, 2, 2, 2, 1307, 1310, 3, 2, 2, 2, 1308, 1306, 3, 2, 2, 2, 1308, 1309, 3, 2, 2, 2, 1309, 1311, 3, 2, 2, 2, 1310, 1308, 3, 2, 2, 2, 1311, 1312, 7, 128, 2, 2, 1312, 1418, 3, 2, 2, 2, 1313, 1314, 7, 114, 2, 2, 1314, 1315, 7, 131, 2, 2, 1315, 1316, 5, 30, 16, 2, 1316, 1317, 7, 132, 2, 2, 1317, 1318, 5, 168, 85, 2, 1318, 1418, 3, 2, 2, 2, 1319, 1320, 7, 35, 2, 2, 1320, 1321, 5, 168, 85, 2, 1321, 1322, 7, 114, 2, 2, 1322, 1323, 7, 131, 2, 2, 1323, 1324, 5, 30, 16, 2, 1324, 1325, 7, 132, 2, 2, 1325, 1326, 7, 136, 2, 2, 1326, 1418, 3, 2, 2, 2, 1327, 1328, 7, 48, 2, 2, 1328, 1330, 7, 131, 2, 2, 1329, 1331, 5, 194, 98, 2, 1330, 1329, 3, 2, 2, 2, 1330, 1331, 3, 2, 2, 2, 1331, 1332, 3, 2, 2, 2, 1332, 1334, 7, 136, 2, 2, 1333, 1335, 5, 30, 16, 2, 1334, 1333, 3, 2, 2, 2, 1334, 1335, 3, 2, 2, 2, 1335, 1336, 3, 2, 2, 2, 1336, 1338, 7, 136, 2, 2, 1337, 1339, 5, 196, 99, 2, 1338, 1337, 3, 2, 2, 2, 1338, 1339, 3, 2, 2, 2, 1339, 1340, 3, 2, 2, 2, 1340, 1341, 7, 132, 2, 2, 1341, 1418, 5, 168, 85, 2, 1342, 1344, 7, 18, 2, 2, 1343, 1342, 3, 2, 2, 2, 1343, 1344, 3, 2, 2, 2, 1344, 1345, 3, 2, 2, 2, 1345, 1346, 7, 49, 2, 2, 1346, 1347, 7, 131, 2, 2, 1347, 1348, 5, 176, 89, 2, 1348, 1349, 5, 436, 219, 2, 1349, 1350, 7, 56, 2, 2, 1350, 1351, 5, 30, 16, 2, 1351, 1352, 7, 132, 2, 2, 1352, 1353, 5, 168, 85, 2, 1353, 1418, 3, 2, 2, 2, 1354, 1355, 7, 21, 2, 2, 1355, 1418, 7, 136, 2, 2, 1356, 1357, 7, 30, 2, 2, 1357, 1418, 7, 136, 2, 2, 1358, 1363, 7, 52, 2, 2, 1359, 1364, 5, 436, 219, 2, 1360, 1361, 7, 24, 2, 2, 1361, 1364, 5, 30, 16, 2, 1362, 1364, 7, 32, 2, 2, 1363, 1359, 3, 2, 2, 2, 1363, 1360, 3, 2, 2, 2, 1363, 1362, 3, 2, 2, 2, 1364, 1365, 3, 2, 2, 2, 1365, 1418, 7, 136, 2, 2, 1366, 1368, 7, 84, 2, 2, 1367, 1369, 5, 30, 16, 2, 1368, 1367, 3, 2, 2, 2, 1368, 1369, 3, 2, 2, 2, 1369, 1370, 3, 2, 2, 2, 1370, 1418, 7, 136, 2, 2, 1371, 1373, 7, 97, 2, 2, 1372, 1374, 5, 30, 16, 2, 1373, 1372, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1375, 3, 2, 2, 2, 1375, 1418, 7, 136, 2, 2, 1376, 1377, 7, 99, 2, 2, 1377, 1383, 5, 172, 87, 2, 1378, 1380, 5, 198, 100, 2, 1379, 1381, 5, 206, 104, 2, 1380, 1379, 3, 2, 2, 2, 1380, 1381, 3, 2, 2, 2, 1381, 1384, 3, 2, 2, 2, 1382, 1384, 5, 206, 104, 2, 1383, 1378, 3, 2, 2, 2, 1383, 1382, 3, 2, 2, 2, 1384, 1418, 3, 2, 2, 2, 1385, 1386, 7, 27, 2, 2, 1386, 1418, 5, 172, 87, 2, 1387, 1388, 7, 103, 2, 2, 1388, 1418, 5, 172, 87, 2, 1389, 1390, 7, 64, 2, 2, 1390, 1391, 7, 131, 2, 2, 1391, 1392, 5, 30, 16, 2, 1392, 1393, 7, 132, 2, 2, 1393, 1394, 5, 168, 85, 2, 1394, 1418, 3, 2, 2, 2, 1395, 1396, 7, 107, 2, 2, 1396, 1397, 7, 131, 2, 2, 1397, 1398, 5, 208, 105, 2, 1398, 1399, 7, 132, 2, 2, 1399, 1400, 5, 168, 85, 2, 1400, 1418, 3, 2, 2, 2, 1401, 1405, 7, 115, 2, 2, 1402, 1403, 7, 84, 2, 2, 1403, 1406, 5, 30, 16, 2, 1404, 1406, 7, 21, 2, 2, 1405, 1402, 3, 2, 2, 2, 1405, 1404, 3, 2, 2, 2, 1406, 1407, 3, 2, 2, 2, 1407, 1418, 7, 136, 2, 2, 1408, 1409, 7, 105, 2, 2, 1409, 1418, 5, 172, 87, 2, 1410, 1411, 7, 46, 2, 2, 1411, 1412, 7, 131, 2, 2, 1412, 1413, 5, 364, 183, 2, 1413, 1414, 5, 366, 184, 2, 1414, 1415, 7, 132, 2, 2, 1415, 1416, 5, 168, 85, 2, 1416, 1418, 3, 2, 2, 2, 1417, 1287, 3, 2, 2, 2, 1417, 1288, 3, 2, 2, 2, 1417, 1291, 3, 2, 2, 2, 1417, 1300, 3, 2, 2, 2, 1417, 1313, 3, 2, 2, 2, 1417, 1319, 3, 2, 2, 2, 1417, 1327, 3, 2, 2, 2, 1417, 1343, 3, 2, 2, 2, 1417, 1354, 3, 2, 2, 2, 1417, 1356, 3, 2, 2, 2, 1417, 1358, 3, 2, 2, 2, 1417, 1366, 3, 2, 2, 2, 1417, 1371, 3, 2, 2, 2, 1417, 1376, 3, 2, 2, 2, 1417, 1385, 3, 2, 2, 2, 1417, 1387, 3, 2, 2, 2, 1417, 1389, 3, 2, 2, 2, 1417, 1395, 3, 2, 2, 2, 1417, 1401, 3, 2, 2, 2, 1417, 1408, 3, 2, 2, 2, 1417, 1410, 3, 2, 2, 2, 1418, 171, 3, 2, 2, 2, 1419, 1421, 7, 127, 2, 2, 1420, 1422, 5, 192, 97, 2, 1421, 1420, 3, 2, 2, 2, 1421, 1422, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1424, 7, 128, 2, 2, 1424, 173, 3, 2, 2, 2, 1425, 1430, 7, 107, 2, 2, 1426, 1430, 7, 82, 2, 2, 1427, 1428, 7, 82, 2, 2, 1428, 1430, 7, 81, 2, 2, 1429, 1425, 3, 2, 2, 2, 1429, 1426, 3, 2, 2, 2, 1429, 1427, 3, 2, 2, 2, 1429, 1430, 3, 2, 2, 2, 1430, 1431, 3, 2, 2, 2, 1431, 1432, 5, 176, 89, 2, 1432, 1437, 5, 178, 90, 2, 1433, 1434, 7, 134, 2, 2, 1434, 1436, 5, 178, 90, 2, 1435, 1433, 3, 2, 2, 2, 1436, 1439, 3, 2, 2, 2, 1437, 1435, 3, 2, 2, 2, 1437, 1438, 3, 2, 2, 2, 1438, 1445, 3, 2, 2, 2, 1439, 1437, 3, 2, 2, 2, 1440, 1441, 7, 46, 2, 2, 1441, 1442, 5, 364, 183, 2, 1442, 1443, 5, 366, 184, 2, 1443, 1445, 3, 2, 2, 2, 1444, 1429, 3, 2, 2, 2, 1444, 1440, 3, 2, 2, 2, 1445, 175, 3, 2, 2, 2, 1446, 1449, 7, 108, 2, 2, 1447, 1449, 5, 6, 4, 2, 1448, 1446, 3, 2, 2, 2, 1448, 1447, 3, 2, 2, 2, 1449, 177, 3, 2, 2, 2, 1450, 1456, 5, 436, 219, 2, 1451, 1453, 7, 147, 2, 2, 1452, 1454, 7, 82, 2, 2, 1453, 1452, 3, 2, 2, 2, 1453, 1454, 3, 2, 2, 2, 1454, 1455, 3, 2, 2, 2, 1455, 1457, 5, 180, 91, 2, 1456, 1451, 3, 2, 2, 2, 1456, 1457, 3, 2, 2, 2, 1457, 179, 3, 2, 2, 2, 1458, 1462, 5, 30, 16, 2, 1459, 1462, 5, 326, 164, 2, 1460, 1462, 5, 374, 188, 2, 1461, 1458, 3, 2, 2, 2, 1461, 1459, 3, 2, 2, 2, 1461, 1460, 3, 2, 2, 2, 1462, 181, 3, 2, 2, 2, 1463, 1464, 7, 29, 2, 2, 1464, 1465, 5, 6, 4, 2, 1465, 1466, 5, 266, 134, 2, 1466, 183, 3, 2, 2, 2, 1467, 1470, 5, 172, 87, 2, 1468, 1470, 5, 170, 86, 2, 1469, 1467, 3, 2, 2, 2, 1469, 1468, 3, 2, 2, 2, 1470, 185, 3, 2, 2, 2, 1471, 1473, 5, 188, 95, 2, 1472, 1471, 3, 2, 2, 2, 1473, 1474, 3, 2, 2, 2, 1474, 1472, 3, 2, 2, 2, 1474, 1475, 3, 2, 2, 2, 1475, 1476, 3, 2, 2, 2, 1476, 1477, 5, 192, 97, 2, 1477, 187, 3, 2, 2, 2, 1478, 1479, 7, 24, 2, 2, 1479, 1481, 5, 30, 16, 2, 1480, 1482, 5, 190, 96, 2, 1481, 1480, 3, 2, 2, 2, 1481, 1482, 3, 2, 2, 2, 1482, 1483, 3, 2, 2, 2, 1483, 1484, 7, 135, 2, 2, 1484, 1488, 3, 2, 2, 2, 1485, 1486, 7, 32, 2, 2, 1486, 1488, 7, 135, 2, 2, 1487, 1478, 3, 2, 2, 2, 1487, 1485, 3, 2, 2, 2, 1488, 189, 3, 2, 2, 2, 1489, 1490, 7, 112, 2, 2, 1490, 1491, 5, 30, 16, 2, 1491, 191, 3, 2, 2, 2, 1492, 1494, 5, 154, 78, 2, 1493, 1492, 3, 2, 2, 2, 1494, 1495, 3, 2, 2, 2, 1495, 1493, 3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 193, 3, 2, 2, 2, 1497, 1507, 5, 174, 88, 2, 1498, 1503, 5, 30, 16, 2, 1499, 1500, 7, 134, 2, 2, 1500, 1502, 5, 30, 16, 2, 1501, 1499, 3, 2, 2, 2, 1502, 1505, 3, 2, 2, 2, 1503, 1501, 3, 2, 2, 2, 1503, 1504, 3, 2, 2, 2, 1504, 1507, 3, 2, 2, 2, 1505, 1503, 3, 2, 2, 2, 1506, 1497, 3, 2, 2, 2, 1506, 1498, 3, 2, 2, 2, 1507, 195, 3, 2, 2, 2, 1508, 1513, 5, 30, 16, 2, 1509, 1510, 7, 134, 2, 2, 1510, 1512, 5, 30, 16, 2, 1511, 1509, 3, 2, 2, 2, 1512, 1515, 3, 2, 2, 2, 1513, 1511, 3, 2, 2, 2, 1513, 1514, 3, 2, 2, 2, 1514, 197, 3, 2, 2, 2, 1515, 1513, 3, 2, 2, 2, 1516, 1520, 5, 200, 101, 2, 1517, 1519, 5, 200, 101, 2, 1518, 1517, 3, 2, 2, 2, 1519, 1522, 3, 2, 2, 2, 1520, 1518, 3, 2, 2, 2, 1520, 1521, 3, 2, 2, 2, 1521, 1524, 3, 2, 2, 2, 1522, 1520, 3, 2, 2, 2, 1523, 1525, 5, 202, 102, 2, 1524, 1523, 3, 2, 2, 2, 1524, 1525, 3, 2, 2, 2, 1525, 1528, 3, 2, 2, 2, 1526, 1528, 5, 202, 102, 2, 1527, 1516, 3, 2, 2, 2, 1527, 1526, 3, 2, 2, 2, 1528, 199, 3, 2, 2, 2, 1529, 1530, 7, 25, 2, 2, 1530, 1531, 7, 131, 2, 2, 1531, 1533, 5, 22, 12, 2, 1532, 1534, 5, 436, 219, 2, 1533, 1532, 3, 2, 2, 2, 1533, 1534, 3, 2, 2, 2, 1534, 1535, 3, 2, 2, 2, 1535, 1537, 7, 132, 2, 2, 1536, 1538, 5, 204, 103, 2, 1537, 1536, 3, 2, 2, 2, 1537, 1538, 3, 2, 2, 2, 1538, 1539, 3, 2, 2, 2, 1539, 1540, 5, 172, 87, 2, 1540, 201, 3, 2, 2, 2, 1541, 1543, 7, 25, 2, 2, 1542, 1544, 5, 204, 103, 2, 1543, 1542, 3, 2, 2, 2, 1543, 1544, 3, 2, 2, 2, 1544, 1545, 3, 2, 2, 2, 1545, 1546, 5, 172, 87, 2, 1546, 203, 3, 2, 2, 2, 1547, 1548, 7, 112, 2, 2, 1548, 1549, 7, 131, 2, 2, 1549, 1550, 5, 30, 16, 2, 1550, 1551, 7, 132, 2, 2, 1551, 205, 3, 2, 2, 2, 1552, 1553, 7, 45, 2, 2, 1553, 1554, 5, 172, 87, 2, 1554, 207, 3, 2, 2, 2, 1555, 1558, 5, 174, 88, 2, 1556, 1558, 5, 30, 16, 2, 1557, 1555, 3, 2, 2, 2, 1557, 1556, 3, 2, 2, 2, 1558, 209, 3, 2, 2, 2, 1559, 1560, 7, 67, 2, 2, 1560, 1561, 5, 212, 107, 2, 1561, 1563, 5, 214, 108, 2, 1562, 1564, 7, 136, 2, 2, 1563, 1562, 3, 2, 2, 2, 1563, 1564, 3, 2, 2, 2, 1564, 211, 3, 2, 2, 2, 1565, 1570, 5, 436, 219, 2, 1566, 1567, 7, 133, 2, 2, 1567, 1569, 5, 436, 219, 2, 1568, 1566, 3, 2, 2, 2, 1569, 1572, 3, 2, 2, 2, 1570, 1568, 3, 2, 2, 2, 1570, 1571, 3, 2, 2, 2, 1571, 213, 3, 2, 2, 2, 1572, 1570, 3, 2, 2, 2, 1573, 1575, 7, 127, 2, 2, 1574, 1576, 5, 216, 109, 2, 1575, 1574, 3, 2, 2, 2, 1575, 1576, 3, 2, 2, 2, 1576, 1578, 3, 2, 2, 2, 1577, 1579, 5, 220, 111, 2, 1578, 1577, 3, 2, 2, 2, 1578, 1579, 3, 2, 2, 2, 1579, 1581, 3, 2, 2, 2, 1580, 1582, 5, 224, 113, 2, 1581, 1580, 3, 2, 2, 2, 1581, 1582, 3, 2, 2, 2, 1582, 1583, 3, 2, 2, 2, 1583, 1584, 7, 128, 2, 2, 1584, 215, 3, 2, 2, 2, 1585, 1587, 5, 218, 110, 2, 1586, 1585, 3, 2, 2, 2, 1587, 1588, 3, 2, 2, 2, 1588, 1586, 3, 2, 2, 2, 1588, 1589, 3, 2, 2, 2, 1589, 217, 3, 2, 2, 2, 1590, 1591, 7, 43, 2, 2, 1591, 1592, 7, 13, 2, 2, 1592, 1593, 5, 436, 219, 2, 1593, 1594, 7, 136, 2, 2, 1594, 219, 3, 2, 2, 2, 1595, 1597, 5, 222, 112, 2, 1596, 1595, 3, 2, 2, 2, 1597, 1598, 3, 2, 2, 2, 1598, 1596, 3, 2, 2, 2, 1598, 1599, 3, 2, 2, 2, 1599, 221, 3, 2, 2, 2, 1600, 1601, 7, 107, 2, 2, 1601, 1602, 5, 436, 219, 2, 1602, 1603, 7, 147, 2, 2, 1603, 1604, 5, 4, 3, 2, 1604, 1605, 7, 136, 2, 2, 1605, 1616, 3, 2, 2, 2, 1606, 1607, 7, 107, 2, 2, 1607, 1608, 5, 4, 3, 2, 1608, 1609, 7, 136, 2, 2, 1609, 1616, 3, 2, 2, 2, 1610, 1611, 7, 107, 2, 2, 1611, 1612, 7, 92, 2, 2, 1612, 1613, 5, 4, 3, 2, 1613, 1614, 7, 136, 2, 2, 1614, 1616, 3, 2, 2, 2, 1615, 1600, 3, 2, 2, 2, 1615, 1606, 3, 2, 2, 2, 1615, 1610, 3, 2, 2, 2, 1616, 223, 3, 2, 2, 2, 1617, 1619, 5, 226, 114, 2, 1618, 1617, 3, 2, 2, 2, 1619, 1620, 3, 2, 2, 2, 1620, 1618, 3, 2, 2, 2, 1620, 1621, 3, 2, 2, 2, 1621, 225, 3, 2, 2, 2, 1622, 1625, 5, 210, 106, 2, 1623, 1625, 5, 228, 115, 2, 1624, 1622, 3, 2, 2, 2, 1624, 1623, 3, 2, 2, 2, 1625, 227, 3, 2, 2, 2, 1626, 1628, 5, 352, 177, 2, 1627, 1626, 3, 2, 2, 2, 1627, 1628, 3, 2, 2, 2, 1628, 1630, 3, 2, 2, 2, 1629, 1631, 5, 258, 130, 2, 1630, 1629, 3, 2, 2, 2, 1630, 1631, 3, 2, 2, 2, 1631, 1637, 3, 2, 2, 2, 1632, 1638, 5, 400, 201, 2, 1633, 1638, 5, 402, 202, 2, 1634, 1638, 5, 404, 203, 2, 1635, 1638, 5, 406, 204, 2, 1636, 1638, 5, 408, 205, 2, 1637, 1632, 3, 2, 2, 2, 1637, 1633, 3, 2, 2, 2, 1637, 1634, 3, 2, 2, 2, 1637, 1635, 3, 2, 2, 2, 1637, 1636, 3, 2, 2, 2, 1638, 229, 3, 2, 2, 2, 1639, 1640, 5, 436, 219, 2, 1640, 1641, 7, 151, 2, 2, 1641, 1643, 5, 436, 219, 2, 1642, 1644, 5, 24, 13, 2, 1643, 1642, 3, 2, 2, 2, 1643, 1644, 3, 2, 2, 2, 1644, 231, 3, 2, 2, 2, 1645, 1646, 7, 148, 2, 2, 1646, 1651, 5, 234, 118, 2, 1647, 1648, 7, 134, 2, 2, 1648, 1650, 5, 234, 118, 2, 1649, 1647, 3, 2, 2, 2, 1650, 1653, 3, 2, 2, 2, 1651, 1649, 3, 2, 2, 2, 1651, 1652, 3, 2, 2, 2, 1652, 1654, 3, 2, 2, 2, 1653, 1651, 3, 2, 2, 2, 1654, 1655, 7, 149, 2, 2, 1655, 233, 3, 2, 2, 2, 1656, 1658, 5, 352, 177, 2, 1657, 1656, 3, 2, 2, 2, 1657, 1658, 3, 2, 2, 2, 1658, 1659, 3, 2, 2, 2, 1659, 1660, 5, 436, 219, 2, 1660, 235, 3, 2, 2, 2, 1661, 1662, 7, 135, 2, 2, 1662, 1667, 5, 22, 12, 2, 1663, 1664, 7, 134, 2, 2, 1664, 1666, 5, 4, 3, 2, 1665, 1663, 3, 2, 2, 2, 1666, 1669, 3, 2, 2, 2, 1667, 1665, 3, 2, 2, 2, 1667, 1668, 3, 2, 2, 2, 1668, 237, 3, 2, 2, 2, 1669, 1667, 3, 2, 2, 2, 1670, 1675, 5, 4, 3, 2, 1671, 1672, 7, 134, 2, 2, 1672, 1674, 5, 4, 3, 2, 1673, 1671, 3, 2, 2, 2, 1674, 1677, 3, 2, 2, 2, 1675, 1673, 3, 2, 2, 2, 1675, 1676, 3, 2, 2, 2, 1676, 239, 3, 2, 2, 2, 1677, 1675, 3, 2, 2, 2, 1678, 1680, 5, 242, 122, 2, 1679, 1678, 3, 2, 2, 2, 1680, 1681, 3, 2, 2, 2, 1681, 1679, 3, 2, 2, 2, 1681, 1682, 3, 2, 2, 2, 1682, 241, 3, 2, 2, 2, 1683, 1684, 7, 113, 2, 2, 1684, 1685, 5, 436, 219, 2, 1685, 1686, 7, 135, 2, 2, 1686, 1687, 5, 244, 123, 2, 1687, 243, 3, 2, 2, 2, 1688, 1699, 5, 250, 126, 2, 1689, 1692, 5, 246, 124, 2, 1690, 1691, 7, 134, 2, 2, 1691, 1693, 5, 248, 125, 2, 1692, 1690, 3, 2, 2, 2, 1692, 1693, 3, 2, 2, 2, 1693, 1696, 3, 2, 2, 2, 1694, 1695, 7, 134, 2, 2, 1695, 1697, 5, 250, 126, 2, 1696, 1694, 3, 2, 2, 2, 1696, 1697, 3, 2, 2, 2, 1697, 1699, 3, 2, 2, 2, 1698, 1688, 3, 2, 2, 2, 1698, 1689, 3, 2, 2, 2, 1699, 245, 3, 2, 2, 2, 1700, 1708, 5, 22, 12, 2, 1701, 1703, 7, 28, 2, 2, 1702, 1704, 7, 150, 2, 2, 1703, 1702, 3, 2, 2, 2, 1703, 1704, 3, 2, 2, 2, 1704, 1708, 3, 2, 2, 2, 1705, 1708, 7, 94, 2, 2, 1706, 1708, 7, 104, 2, 2, 1707, 1700, 3, 2, 2, 2, 1707, 1701, 3, 2, 2, 2, 1707, 1705, 3, 2, 2, 2, 1707, 1706, 3, 2, 2, 2, 1708, 247, 3, 2, 2, 2, 1709, 1714, 5, 4, 3, 2, 1710, 1711, 7, 134, 2, 2, 1711, 1713, 5, 4, 3, 2, 1712, 1710, 3, 2, 2, 2, 1713, 1716, 3, 2, 2, 2, 1714, 1712, 3, 2, 2, 2, 1714, 1715, 3, 2, 2, 2, 1715, 249, 3, 2, 2, 2, 1716, 1714, 3, 2, 2, 2, 1717, 1718, 7, 68, 2, 2, 1718, 1719, 7, 131, 2, 2, 1719, 1720, 7, 132, 2, 2, 1720, 251, 3, 2, 2, 2, 1721, 1723, 7, 127, 2, 2, 1722, 1724, 5, 254, 128, 2, 1723, 1722, 3, 2, 2, 2, 1723, 1724, 3, 2, 2, 2, 1724, 1725, 3, 2, 2, 2, 1725, 1726, 7, 128, 2, 2, 1726, 253, 3, 2, 2, 2, 1727, 1729, 5, 256, 129, 2, 1728, 1727, 3, 2, 2, 2, 1729, 1730, 3, 2, 2, 2, 1730, 1728, 3, 2, 2, 2, 1730, 1731, 3, 2, 2, 2, 1731, 255, 3, 2, 2, 2, 1732, 1734, 5, 352, 177, 2, 1733, 1732, 3, 2, 2, 2, 1733, 1734, 3, 2, 2, 2, 1734, 1736, 3, 2, 2, 2, 1735, 1737, 5, 258, 130, 2, 1736, 1735, 3, 2, 2, 2, 1736, 1737, 3, 2, 2, 2, 1737, 1740, 3, 2, 2, 2, 1738, 1741, 5, 262, 132, 2, 1739, 1741, 5, 420, 211, 2, 1740, 1738, 3, 2, 2, 2, 1740, 1739, 3, 2, 2, 2, 1741, 257, 3, 2, 2, 2, 1742, 1744, 5, 260, 131, 2, 1743, 1742, 3, 2, 2, 2, 1744, 1745, 3, 2, 2, 2, 1745, 1743, 3, 2, 2, 2, 1745, 1746, 3, 2, 2, 2, 1746, 259, 3, 2, 2, 2, 1747, 1748, 9, 12, 2, 2, 1748, 261, 3, 2, 2, 2, 1749, 1769, 5, 416, 209, 2, 1750, 1769, 5, 264, 133, 2, 1751, 1769, 5, 410, 206, 2, 1752, 1758, 5, 310, 156, 2, 1753, 1759, 5, 314, 158, 2, 1754, 1755, 5, 376, 189, 2, 1755, 1756, 5, 76, 39, 2, 1756, 1757, 7, 136, 2, 2, 1757, 1759, 3, 2, 2, 2, 1758, 1753, 3, 2, 2, 2, 1758, 1754, 3, 2, 2, 2, 1759, 1769, 3, 2, 2, 2, 1760, 1769, 5, 422, 212, 2, 1761, 1762, 7, 110, 2, 2, 1762, 1769, 5, 424, 213, 2, 1763, 1769, 5, 400, 201, 2, 1764, 1769, 5, 402, 202, 2, 1765, 1769, 5, 404, 203, 2, 1766, 1769, 5, 406, 204, 2, 1767, 1769, 5, 408, 205, 2, 1768, 1749, 3, 2, 2, 2, 1768, 1750, 3, 2, 2, 2, 1768, 1751, 3, 2, 2, 2, 1768, 1752, 3, 2, 2, 2, 1768, 1760, 3, 2, 2, 2, 1768, 1761, 3, 2, 2, 2, 1768, 1763, 3, 2, 2, 2, 1768, 1764, 3, 2, 2, 2, 1768, 1765, 3, 2, 2, 2, 1768, 1766, 3, 2, 2, 2, 1768, 1767, 3, 2, 2, 2, 1769, 263, 3, 2, 2, 2, 1770, 1776, 7, 82, 2, 2, 1771, 1772, 7, 81, 2, 2, 1772, 1776, 7, 82, 2, 2, 1773, 1774, 7, 82, 2, 2, 1774, 1776, 7, 81, 2, 2, 1775, 1770, 3, 2, 2, 2, 1775, 1771, 3, 2, 2, 2, 1775, 1773, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 1777, 3, 2, 2, 2, 1777, 1787, 5, 6, 4, 2, 1778, 1779, 5, 4, 3, 2, 1779, 1780, 7, 133, 2, 2, 1780, 1781, 5, 418, 210, 2, 1781, 1788, 3, 2, 2, 2, 1782, 1788, 5, 424, 213, 2, 1783, 1788, 5, 414, 208, 2, 1784, 1788, 5, 418, 210, 2, 1785, 1788, 5, 428, 215, 2, 1786, 1788, 5, 412, 207, 2, 1787, 1778, 3, 2, 2, 2, 1787, 1782, 3, 2, 2, 2, 1787, 1783, 3, 2, 2, 2, 1787, 1784, 3, 2, 2, 2, 1787, 1785, 3, 2, 2, 2, 1787, 1786, 3, 2, 2, 2, 1788, 265, 3, 2, 2, 2, 1789, 1794, 5, 268, 135, 2, 1790, 1791, 7, 134, 2, 2, 1791, 1793, 5, 268, 135, 2, 1792, 1790, 3, 2, 2, 2, 1793, 1796, 3, 2, 2, 2, 1794, 1792, 3, 2, 2, 2, 1794, 1795, 3, 2, 2, 2, 1795, 267, 3, 2, 2, 2, 1796, 1794, 3, 2, 2, 2, 1797, 1798, 5, 436, 219, 2, 1798, 1799, 7, 147, 2, 2, 1799, 1800, 5, 30, 16, 2, 1800, 269, 3, 2, 2, 2, 1801, 1806, 5, 272, 137, 2, 1802, 1803, 7, 134, 2, 2, 1803, 1805, 5, 272, 137, 2, 1804, 1802, 3, 2, 2, 2, 1805, 1808, 3, 2, 2, 2, 1806, 1804, 3, 2, 2, 2, 1806, 1807, 3, 2, 2, 2, 1807, 271, 3, 2, 2, 2, 1808, 1806, 3, 2, 2, 2, 1809, 1812, 5, 436, 219, 2, 1810, 1811, 7, 147, 2, 2, 1811, 1813, 5, 274, 138, 2, 1812, 1810, 3, 2, 2, 2, 1812, 1813, 3, 2, 2, 2, 1813, 273, 3, 2, 2, 2, 1814, 1817, 5, 30, 16, 2, 1815, 1817, 5, 326, 164, 2, 1816, 1814, 3, 2, 2, 2, 1816, 1815, 3, 2, 2, 2, 1817, 275, 3, 2, 2, 2, 1818, 1821, 5, 6, 4, 2, 1819, 1821, 7, 110, 2, 2, 1820, 1818, 3, 2, 2, 2, 1820, 1819, 3, 2, 2, 2, 1821, 277, 3, 2, 2, 2, 1822, 1823, 5, 4, 3, 2, 1823, 279, 3, 2, 2, 2, 1824, 1827, 5, 172, 87, 2, 1825, 1827, 7, 136, 2, 2, 1826, 1824, 3, 2, 2, 2, 1826, 1825, 3, 2, 2, 2, 1827, 281, 3, 2, 2, 2, 1828, 1835, 5, 290, 146, 2, 1829, 1832, 5, 284, 143, 2, 1830, 1831, 7, 134, 2, 2, 1831, 1833, 5, 290, 146, 2, 1832, 1830, 3, 2, 2, 2, 1832, 1833, 3, 2, 2, 2, 1833, 1835, 3, 2, 2, 2, 1834, 1828, 3, 2, 2, 2, 1834, 1829, 3, 2, 2, 2, 1835, 283, 3, 2, 2, 2, 1836, 1841, 5, 286, 144, 2, 1837, 1838, 7, 134, 2, 2, 1838, 1840, 5, 286, 144, 2, 1839, 1837, 3, 2, 2, 2, 1840, 1843, 3, 2, 2, 2, 1841, 1839, 3, 2, 2, 2, 1841, 1842, 3, 2, 2, 2, 1842, 285, 3, 2, 2, 2, 1843, 1841, 3, 2, 2, 2, 1844, 1846, 5, 352, 177, 2, 1845, 1844, 3, 2, 2, 2, 1845, 1846, 3, 2, 2, 2, 1846, 1848, 3, 2, 2, 2, 1847, 1849, 5, 288, 145, 2, 1848, 1847, 3, 2, 2, 2, 1848, 1849, 3, 2, 2, 2, 1849, 1850, 3, 2, 2, 2, 1850, 1853, 5, 430, 216, 2, 1851, 1853, 7, 14, 2, 2, 1852, 1845, 3, 2, 2, 2, 1852, 1851, 3, 2, 2, 2, 1853, 287, 3, 2, 2, 2, 1854, 1863, 7, 82, 2, 2, 1855, 1863, 7, 74, 2, 2, 1856, 1863, 7, 56, 2, 2, 1857, 1858, 7, 82, 2, 2, 1858, 1863, 7, 96, 2, 2, 1859, 1860, 7, 56, 2, 2, 1860, 1863, 7, 96, 2, 2, 1861, 1863, 7, 96, 2, 2, 1862, 1854, 3, 2, 2, 2, 1862, 1855, 3, 2, 2, 2, 1862, 1856, 3, 2, 2, 2, 1862, 1857, 3, 2, 2, 2, 1862, 1859, 3, 2, 2, 2, 1862, 1861, 3, 2, 2, 2, 1863, 289, 3, 2, 2, 2, 1864, 1866, 5, 352, 177, 2, 1865, 1864, 3, 2, 2, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1867, 3, 2, 2, 2, 1867, 1868, 7, 76, 2, 2, 1868, 1869, 5, 322, 162, 2, 1869, 1870, 5, 436, 219, 2, 1870, 291, 3, 2, 2, 2, 1871, 1873, 5, 352, 177, 2, 1872, 1871, 3, 2, 2, 2, 1872, 1873, 3, 2, 2, 2, 1873, 1875, 3, 2, 2, 2, 1874, 1876, 5, 298, 150, 2, 1875, 1874, 3, 2, 2, 2, 1875, 1876, 3, 2, 2, 2, 1876, 1887, 3, 2, 2, 2, 1877, 1878, 7, 51, 2, 2, 1878, 1880, 5, 300, 151, 2, 1879, 1881, 5, 296, 149, 2, 1880, 1879, 3, 2, 2, 2, 1880, 1881, 3, 2, 2, 2, 1881, 1888, 3, 2, 2, 2, 1882, 1883, 7, 88, 2, 2, 1883, 1885, 5, 300, 151, 2, 1884, 1886, 5, 294, 148, 2, 1885, 1884, 3, 2, 2, 2, 1885, 1886, 3, 2, 2, 2, 1886, 1888, 3, 2, 2, 2, 1887, 1877, 3, 2, 2, 2, 1887, 1882, 3, 2, 2, 2, 1888, 293, 3, 2, 2, 2, 1889, 1891, 5, 352, 177, 2, 1890, 1889, 3, 2, 2, 2, 1890, 1891, 3, 2, 2, 2, 1891, 1893, 3, 2, 2, 2, 1892, 1894, 5, 298, 150, 2, 1893, 1892, 3, 2, 2, 2, 1893, 1894, 3, 2, 2, 2, 1894, 1895, 3, 2, 2, 2, 1895, 1896, 7, 51, 2, 2, 1896, 1897, 5, 300, 151, 2, 1897, 295, 3, 2, 2, 2, 1898, 1900, 5, 352, 177, 2, 1899, 1898, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1902, 3, 2, 2, 2, 1901, 1903, 5, 298, 150, 2, 1902, 1901, 3, 2, 2, 2, 1902, 1903, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1905, 7, 88, 2, 2, 1905, 1906, 5, 300, 151, 2, 1906, 297, 3, 2, 2, 2, 1907, 1915, 7, 79, 2, 2, 1908, 1915, 7, 59, 2, 2, 1909, 1915, 7, 78, 2, 2, 1910, 1911, 7, 79, 2, 2, 1911, 1915, 7, 59, 2, 2, 1912, 1913, 7, 59, 2, 2, 1913, 1915, 7, 79, 2, 2, 1914, 1907, 3, 2, 2, 2, 1914, 1908, 3, 2, 2, 2, 1914, 1909, 3, 2, 2, 2, 1914, 1910, 3, 2, 2, 2, 1914, 1912, 3, 2, 2, 2, 1915, 299, 3, 2, 2, 2, 1916, 1919, 5, 172, 87, 2, 1917, 1919, 7, 136, 2, 2, 1918, 1916, 3, 2, 2, 2, 1918, 1917, 3, 2, 2, 2, 1919, 301, 3, 2, 2, 2, 1920, 1922, 5, 352, 177, 2, 1921, 1920, 3, 2, 2, 2, 1921, 1922, 3, 2, 2, 2, 1922, 1931, 3, 2, 2, 2, 1923, 1924, 7, 12, 2, 2, 1924, 1925, 5, 172, 87, 2, 1925, 1926, 5, 306, 154, 2, 1926, 1932, 3, 2, 2, 2, 1927, 1928, 7, 83, 2, 2, 1928, 1929, 5, 172, 87, 2, 1929, 1930, 5, 304, 153, 2, 1930, 1932, 3, 2, 2, 2, 1931, 1923, 3, 2, 2, 2, 1931, 1927, 3, 2, 2, 2, 1932, 303, 3, 2, 2, 2, 1933, 1935, 5, 352, 177, 2, 1934, 1933, 3, 2, 2, 2, 1934, 1935, 3, 2, 2, 2, 1935, 1936, 3, 2, 2, 2, 1936, 1937, 7, 12, 2, 2, 1937, 1938, 5, 172, 87, 2, 1938, 305, 3, 2, 2, 2, 1939, 1941, 5, 352, 177, 2, 1940, 1939, 3, 2, 2, 2, 1940, 1941, 3, 2, 2, 2, 1941, 1942, 3, 2, 2, 2, 1942, 1943, 7, 83, 2, 2, 1943, 1944, 5, 172, 87, 2, 1944, 307, 3, 2, 2, 2, 1945, 1968, 7, 137, 2, 2, 1946, 1968, 7, 138, 2, 2, 1947, 1968, 7, 145, 2, 2, 1948, 1968, 7, 146, 2, 2, 1949, 1968, 7, 153, 2, 2, 1950, 1968, 7, 154, 2, 2, 1951, 1968, 7, 98, 2, 2, 1952, 1968, 7, 44, 2, 2, 1953, 1968, 7, 139, 2, 2, 1954, 1968, 7, 140, 2, 2, 1955, 1968, 7, 141, 2, 2, 1956, 1968, 7, 142, 2, 2, 1957, 1968, 7, 143, 2, 2, 1958, 1968, 7, 144, 2, 2, 1959, 1968, 7, 170, 2, 2, 1960, 1968, 5, 378, 190, 2, 1961, 1968, 7, 158, 2, 2, 1962, 1968, 7, 159, 2, 2, 1963, 1968, 7, 149, 2, 2, 1964, 1968, 7, 148, 2, 2, 1965, 1968, 7, 161, 2, 2, 1966, 1968, 7, 160, 2, 2, 1967, 1945, 3, 2, 2, 2, 1967, 1946, 3, 2, 2, 2, 1967, 1947, 3, 2, 2, 2, 1967, 1948, 3, 2, 2, 2, 1967, 1949, 3, 2, 2, 2, 1967, 1950, 3, 2, 2, 2, 1967, 1951, 3, 2, 2, 2, 1967, 1952, 3, 2, 2, 2, 1967, 1953, 3, 2, 2, 2, 1967, 1954, 3, 2, 2, 2, 1967, 1955, 3, 2, 2, 2, 1967, 1956, 3, 2, 2, 2, 1967, 1957, 3, 2, 2, 2, 1967, 1958, 3, 2, 2, 2, 1967, 1959, 3, 2, 2, 2, 1967, 1960, 3, 2, 2, 2, 1967, 1961, 3, 2, 2, 2, 1967, 1962, 3, 2, 2, 2, 1967, 1963, 3, 2, 2, 2, 1967, 1964, 3, 2, 2, 2, 1967, 1965, 3, 2, 2, 2, 1967, 1966, 3, 2, 2, 2, 1968, 309, 3, 2, 2, 2, 1969, 1970, 9, 13, 2, 2, 1970, 1971, 7, 72, 2, 2, 1971, 1972, 5, 6, 4, 2, 1972, 1973, 7, 131, 2, 2, 1973, 1974, 5, 430, 216, 2, 1974, 1975, 7, 132, 2, 2, 1975, 311, 3, 2, 2, 2, 1976, 1977, 7, 135, 2, 2, 1977, 1978, 9, 14, 2, 2, 1978, 1980, 7, 131, 2, 2, 1979, 1981, 5, 26, 14, 2, 1980, 1979, 3, 2, 2, 2, 1980, 1981, 3, 2, 2, 2, 1981, 1982, 3, 2, 2, 2, 1982, 1983, 7, 132, 2, 2, 1983, 313, 3, 2, 2, 2, 1984, 1987, 5, 172, 87, 2, 1985, 1987, 7, 136, 2, 2, 1986, 1984, 3, 2, 2, 2, 1986, 1985, 3, 2, 2, 2, 1987, 315, 3, 2, 2, 2, 1988, 1989, 7, 135, 2, 2, 1989, 1990, 5, 238, 120, 2, 1990, 317, 3, 2, 2, 2, 1991, 1995, 7, 127, 2, 2, 1992, 1994, 5, 320, 161, 2, 1993, 1992, 3, 2, 2, 2, 1994, 1997, 3, 2, 2, 2, 1995, 1993, 3, 2, 2, 2, 1995, 1996, 3, 2, 2, 2, 1996, 1998, 3, 2, 2, 2, 1997, 1995, 3, 2, 2, 2, 1998, 1999, 7, 128, 2, 2, 1999, 319, 3, 2, 2, 2, 2000, 2002, 5, 352, 177, 2, 2001, 2000, 3, 2, 2, 2, 2001, 2002, 3, 2, 2, 2, 2002, 2004, 3, 2, 2, 2, 2003, 2005, 5, 258, 130, 2, 2004, 2003, 3, 2, 2, 2, 2004, 2005, 3, 2, 2, 2, 2005, 2016, 3, 2, 2, 2, 2006, 2017, 5, 262, 132, 2, 2007, 2008, 7, 46, 2, 2, 2008, 2010, 5, 6, 4, 2, 2009, 2011, 5, 372, 187, 2, 2010, 2009, 3, 2, 2, 2, 2011, 2012, 3, 2, 2, 2, 2012, 2010, 3, 2, 2, 2, 2012, 2013, 3, 2, 2, 2, 2013, 2014, 3, 2, 2, 2, 2014, 2015, 7, 136, 2, 2, 2015, 2017, 3, 2, 2, 2, 2016, 2006, 3, 2, 2, 2, 2016, 2007, 3, 2, 2, 2, 2017, 321, 3, 2, 2, 2, 2018, 2026, 5, 8, 5, 2, 2019, 2021, 9, 15, 2, 2, 2020, 2019, 3, 2, 2, 2, 2021, 2024, 3, 2, 2, 2, 2022, 2020, 3, 2, 2, 2, 2022, 2023, 3, 2, 2, 2, 2023, 2025, 3, 2, 2, 2, 2024, 2022, 3, 2, 2, 2, 2025, 2027, 5, 324, 163, 2, 2026, 2022, 3, 2, 2, 2, 2027, 2028, 3, 2, 2, 2, 2028, 2026, 3, 2, 2, 2, 2028, 2029, 3, 2, 2, 2, 2029, 323, 3, 2, 2, 2, 2030, 2034, 7, 129, 2, 2, 2031, 2033, 7, 134, 2, 2, 2032, 2031, 3, 2, 2, 2, 2033, 2036, 3, 2, 2, 2, 2034, 2032, 3, 2, 2, 2, 2034, 2035, 3, 2, 2, 2, 2035, 2037, 3, 2, 2, 2, 2036, 2034, 3, 2, 2, 2, 2037, 2038, 7, 130, 2, 2, 2038, 325, 3, 2, 2, 2, 2039, 2051, 7, 127, 2, 2, 2040, 2045, 5, 274, 138, 2, 2041, 2042, 7, 134, 2, 2, 2042, 2044, 5, 274, 138, 2, 2043, 2041, 3, 2, 2, 2, 2044, 2047, 3, 2, 2, 2, 2045, 2043, 3, 2, 2, 2, 2045, 2046, 3, 2, 2, 2, 2046, 2049, 3, 2, 2, 2, 2047, 2045, 3, 2, 2, 2, 2048, 2050, 7, 134, 2, 2, 2049, 2048, 3, 2, 2, 2, 2049, 2050, 3, 2, 2, 2, 2050, 2052, 3, 2, 2, 2, 2051, 2040, 3, 2, 2, 2, 2051, 2052, 3, 2, 2, 2, 2052, 2053, 3, 2, 2, 2, 2053, 2054, 7, 128, 2, 2, 2054, 327, 3, 2, 2, 2, 2055, 2056, 7, 148, 2, 2, 2056, 2061, 5, 330, 166, 2, 2057, 2058, 7, 134, 2, 2, 2058, 2060, 5, 330, 166, 2, 2059, 2057, 3, 2, 2, 2, 2060, 2063, 3, 2, 2, 2, 2061, 2059, 3, 2, 2, 2, 2061, 2062, 3, 2, 2, 2, 2062, 2064, 3, 2, 2, 2, 2063, 2061, 3, 2, 2, 2, 2064, 2065, 7, 149, 2, 2, 2065, 329, 3, 2, 2, 2, 2066, 2068, 5, 352, 177, 2, 2067, 2066, 3, 2, 2, 2, 2067, 2068, 3, 2, 2, 2, 2068, 2070, 3, 2, 2, 2, 2069, 2071, 5, 332, 167, 2, 2070, 2069, 3, 2, 2, 2, 2070, 2071, 3, 2, 2, 2, 2071, 2072, 3, 2, 2, 2, 2072, 2073, 5, 436, 219, 2, 2073, 331, 3, 2, 2, 2, 2074, 2075, 9, 16, 2, 2, 2075, 333, 3, 2, 2, 2, 2076, 2077, 7, 135, 2, 2, 2077, 2078, 5, 238, 120, 2, 2078, 335, 3, 2, 2, 2, 2079, 2083, 7, 127, 2, 2, 2080, 2082, 5, 338, 170, 2, 2081, 2080, 3, 2, 2, 2, 2082, 2085, 3, 2, 2, 2, 2083, 2081, 3, 2, 2, 2, 2083, 2084, 3, 2, 2, 2, 2084, 2086, 3, 2, 2, 2, 2085, 2083, 3, 2, 2, 2, 2086, 2087, 7, 128, 2, 2, 2087, 337, 3, 2, 2, 2, 2088, 2090, 5, 352, 177, 2, 2089, 2088, 3, 2, 2, 2, 2089, 2090, 3, 2, 2, 2, 2090, 2092, 3, 2, 2, 2, 2091, 2093, 7, 68, 2, 2, 2092, 2091, 3, 2, 2, 2, 2092, 2093, 3, 2, 2, 2, 2093, 2157, 3, 2, 2, 2, 2094, 2096, 7, 105, 2, 2, 2095, 2094, 3, 2, 2, 2, 2095, 2096, 3, 2, 2, 2, 2096, 2102, 3, 2, 2, 2, 2097, 2103, 7, 82, 2, 2, 2098, 2099, 7, 82, 2, 2, 2099, 2103, 7, 81, 2, 2, 2100, 2101, 7, 81, 2, 2, 2101, 2103, 7, 82, 2, 2, 2102, 2097, 3, 2, 2, 2, 2102, 2098, 3, 2, 2, 2, 2102, 2100, 3, 2, 2, 2, 2102, 2103, 3, 2, 2, 2, 2103, 2104, 3, 2, 2, 2, 2104, 2132, 5, 6, 4, 2, 2105, 2107, 5, 436, 219, 2, 2106, 2108, 5, 232, 117, 2, 2107, 2106, 3, 2, 2, 2, 2107, 2108, 3, 2, 2, 2, 2108, 2109, 3, 2, 2, 2, 2109, 2111, 7, 131, 2, 2, 2110, 2112, 5, 282, 142, 2, 2111, 2110, 3, 2, 2, 2, 2111, 2112, 3, 2, 2, 2, 2112, 2113, 3, 2, 2, 2, 2113, 2115, 7, 132, 2, 2, 2114, 2116, 5, 240, 121, 2, 2115, 2114, 3, 2, 2, 2, 2115, 2116, 3, 2, 2, 2, 2116, 2117, 3, 2, 2, 2, 2117, 2118, 7, 136, 2, 2, 2118, 2133, 3, 2, 2, 2, 2119, 2120, 5, 436, 219, 2, 2120, 2121, 7, 127, 2, 2, 2121, 2122, 5, 340, 171, 2, 2122, 2123, 7, 128, 2, 2, 2123, 2133, 3, 2, 2, 2, 2124, 2125, 7, 96, 2, 2, 2125, 2126, 7, 129, 2, 2, 2126, 2127, 5, 282, 142, 2, 2127, 2128, 7, 130, 2, 2, 2128, 2129, 7, 127, 2, 2, 2129, 2130, 5, 340, 171, 2, 2130, 2131, 7, 128, 2, 2, 2131, 2133, 3, 2, 2, 2, 2132, 2105, 3, 2, 2, 2, 2132, 2119, 3, 2, 2, 2, 2132, 2124, 3, 2, 2, 2, 2133, 2158, 3, 2, 2, 2, 2134, 2136, 7, 105, 2, 2, 2135, 2134, 3, 2, 2, 2, 2135, 2136, 3, 2, 2, 2, 2136, 2137, 3, 2, 2, 2, 2137, 2138, 7, 110, 2, 2, 2138, 2140, 5, 436, 219, 2, 2139, 2141, 5, 232, 117, 2, 2140, 2139, 3, 2, 2, 2, 2140, 2141, 3, 2, 2, 2, 2141, 2142, 3, 2, 2, 2, 2142, 2144, 7, 131, 2, 2, 2143, 2145, 5, 282, 142, 2, 2144, 2143, 3, 2, 2, 2, 2144, 2145, 3, 2, 2, 2, 2145, 2146, 3, 2, 2, 2, 2146, 2148, 7, 132, 2, 2, 2147, 2149, 5, 240, 121, 2, 2148, 2147, 3, 2, 2, 2, 2148, 2149, 3, 2, 2, 2, 2149, 2150, 3, 2, 2, 2, 2150, 2151, 7, 136, 2, 2, 2151, 2158, 3, 2, 2, 2, 2152, 2153, 7, 41, 2, 2, 2153, 2154, 5, 6, 4, 2, 2154, 2155, 5, 436, 219, 2, 2155, 2156, 7, 136, 2, 2, 2156, 2158, 3, 2, 2, 2, 2157, 2095, 3, 2, 2, 2, 2157, 2135, 3, 2, 2, 2, 2157, 2152, 3, 2, 2, 2, 2158, 339, 3, 2, 2, 2, 2159, 2161, 5, 352, 177, 2, 2160, 2159, 3, 2, 2, 2, 2160, 2161, 3, 2, 2, 2, 2161, 2180, 3, 2, 2, 2, 2162, 2163, 7, 51, 2, 2, 2163, 2169, 7, 136, 2, 2, 2164, 2166, 5, 352, 177, 2, 2165, 2164, 3, 2, 2, 2, 2165, 2166, 3, 2, 2, 2, 2166, 2167, 3, 2, 2, 2, 2167, 2168, 7, 88, 2, 2, 2168, 2170, 7, 136, 2, 2, 2169, 2165, 3, 2, 2, 2, 2169, 2170, 3, 2, 2, 2, 2170, 2181, 3, 2, 2, 2, 2171, 2172, 7, 88, 2, 2, 2172, 2178, 7, 136, 2, 2, 2173, 2175, 5, 352, 177, 2, 2174, 2173, 3, 2, 2, 2, 2174, 2175, 3, 2, 2, 2, 2175, 2176, 3, 2, 2, 2, 2176, 2177, 7, 51, 2, 2, 2177, 2179, 7, 136, 2, 2, 2178, 2174, 3, 2, 2, 2, 2178, 2179, 3, 2, 2, 2, 2179, 2181, 3, 2, 2, 2, 2180, 2162, 3, 2, 2, 2, 2180, 2171, 3, 2, 2, 2, 2181, 341, 3, 2, 2, 2, 2182, 2183, 7, 135, 2, 2, 2183, 2184, 5, 6, 4, 2, 2184, 343, 3, 2, 2, 2, 2185, 2197, 7, 127, 2, 2, 2186, 2191, 5, 346, 174, 2, 2187, 2188, 7, 134, 2, 2, 2188, 2190, 5, 346, 174, 2, 2189, 2187, 3, 2, 2, 2, 2190, 2193, 3, 2, 2, 2, 2191, 2189, 3, 2, 2, 2, 2191, 2192, 3, 2, 2, 2, 2192, 2195, 3, 2, 2, 2, 2193, 2191, 3, 2, 2, 2, 2194, 2196, 7, 134, 2, 2, 2195, 2194, 3, 2, 2, 2, 2195, 2196, 3, 2, 2, 2, 2196, 2198, 3, 2, 2, 2, 2197, 2186, 3, 2, 2, 2, 2197, 2198, 3, 2, 2, 2, 2198, 2199, 3, 2, 2, 2, 2199, 2200, 7, 128, 2, 2, 2200, 345, 3, 2, 2, 2, 2201, 2203, 5, 352, 177, 2, 2202, 2201, 3, 2, 2, 2, 2202, 2203, 3, 2, 2, 2, 2203, 2204, 3, 2, 2, 2, 2204, 2207, 5, 436, 219, 2, 2205, 2206, 7, 147, 2, 2, 2206, 2208, 5, 30, 16, 2, 2207, 2205, 3, 2, 2, 2, 2207, 2208, 3, 2, 2, 2, 2208, 347, 3, 2, 2, 2, 2209, 2210, 7, 129, 2, 2, 2210, 2211, 5, 350, 176, 2, 2211, 2212, 7, 135, 2, 2, 2212, 2214, 5, 358, 180, 2, 2213, 2215, 7, 134, 2, 2, 2214, 2213, 3, 2, 2, 2, 2214, 2215, 3, 2, 2, 2, 2215, 2216, 3, 2, 2, 2, 2216, 2217, 7, 130, 2, 2, 2217, 349, 3, 2, 2, 2, 2218, 2221, 5, 398, 200, 2, 2219, 2221, 5, 436, 219, 2, 2220, 2218, 3, 2, 2, 2, 2220, 2219, 3, 2, 2, 2, 2221, 351, 3, 2, 2, 2, 2222, 2224, 5, 354, 178, 2, 2223, 2222, 3, 2, 2, 2, 2224, 2225, 3, 2, 2, 2, 2225, 2223, 3, 2, 2, 2, 2225, 2226, 3, 2, 2, 2, 2226, 353, 3, 2, 2, 2, 2227, 2231, 7, 129, 2, 2, 2228, 2229, 5, 356, 179, 2, 2229, 2230, 7, 135, 2, 2, 2230, 2232, 3, 2, 2, 2, 2231, 2228, 3, 2, 2, 2, 2231, 2232, 3, 2, 2, 2, 2232, 2233, 3, 2, 2, 2, 2233, 2235, 5, 358, 180, 2, 2234, 2236, 7, 134, 2, 2, 2235, 2234, 3, 2, 2, 2, 2235, 2236, 3, 2, 2, 2, 2236, 2237, 3, 2, 2, 2, 2237, 2238, 7, 130, 2, 2, 2238, 355, 3, 2, 2, 2, 2239, 2242, 5, 398, 200, 2, 2240, 2242, 5, 436, 219, 2, 2241, 2239, 3, 2, 2, 2, 2241, 2240, 3, 2, 2, 2, 2242, 357, 3, 2, 2, 2, 2243, 2248, 5, 360, 181, 2, 2244, 2245, 7, 134, 2, 2, 2245, 2247, 5, 360, 181, 2, 2246, 2244, 3, 2, 2, 2, 2247, 2250, 3, 2, 2, 2, 2248, 2246, 3, 2, 2, 2, 2248, 2249, 3, 2, 2, 2, 2249, 359, 3, 2, 2, 2, 2250, 2248, 3, 2, 2, 2, 2251, 2264, 5, 4, 3, 2, 2252, 2261, 7, 131, 2, 2, 2253, 2258, 5, 362, 182, 2, 2254, 2255, 7, 134, 2, 2, 2255, 2257, 5, 362, 182, 2, 2256, 2254, 3, 2, 2, 2, 2257, 2260, 3, 2, 2, 2, 2258, 2256, 3, 2, 2, 2, 2258, 2259, 3, 2, 2, 2, 2259, 2262, 3, 2, 2, 2, 2260, 2258, 3, 2, 2, 2, 2261, 2253, 3, 2, 2, 2, 2261, 2262, 3, 2, 2, 2, 2262, 2263, 3, 2, 2, 2, 2263, 2265, 7, 132, 2, 2, 2264, 2252, 3, 2, 2, 2, 2264, 2265, 3, 2, 2, 2, 2265, 361, 3, 2, 2, 2, 2266, 2267, 5, 436, 219, 2, 2267, 2268, 7, 135, 2, 2, 2268, 2270, 3, 2, 2, 2, 2269, 2266, 3, 2, 2, 2, 2269, 2270, 3, 2, 2, 2, 2270, 2271, 3, 2, 2, 2, 2271, 2272, 5, 30, 16, 2, 2272, 363, 3, 2, 2, 2, 2273, 2276, 5, 14, 8, 2, 2274, 2276, 5, 22, 12, 2, 2275, 2273, 3, 2, 2, 2, 2275, 2274, 3, 2, 2, 2, 2276, 2281, 3, 2, 2, 2, 2277, 2280, 5, 324, 163, 2, 2278, 2280, 7, 150, 2, 2, 2279, 2277, 3, 2, 2, 2, 2279, 2278, 3, 2, 2, 2, 2280, 2283, 3, 2, 2, 2, 2281, 2279, 3, 2, 2, 2, 2281, 2282, 3, 2, 2, 2, 2282, 2284, 3, 2, 2, 2, 2283, 2281, 3, 2, 2, 2, 2284, 2285, 7, 139, 2, 2, 2285, 2289, 3, 2, 2, 2, 2286, 2287, 7, 110, 2, 2, 2287, 2289, 7, 139, 2, 2, 2288, 2275, 3, 2, 2, 2, 2288, 2286, 3, 2, 2, 2, 2289, 365, 3, 2, 2, 2, 2290, 2295, 5, 368, 185, 2, 2291, 2292, 7, 134, 2, 2, 2292, 2294, 5, 368, 185, 2, 2293, 2291, 3, 2, 2, 2, 2294, 2297, 3, 2, 2, 2, 2295, 2293, 3, 2, 2, 2, 2295, 2296, 3, 2, 2, 2, 2296, 367, 3, 2, 2, 2, 2297, 2295, 3, 2, 2, 2, 2298, 2299, 5, 436, 219, 2, 2299, 2300, 7, 147, 2, 2, 2300, 2301, 5, 370, 186, 2, 2301, 369, 3, 2, 2, 2, 2302, 2304, 7, 142, 2, 2, 2303, 2302, 3, 2, 2, 2, 2303, 2304, 3, 2, 2, 2, 2304, 2305, 3, 2, 2, 2, 2305, 2308, 5, 30, 16, 2, 2306, 2308, 5, 374, 188, 2, 2307, 2303, 3, 2, 2, 2, 2307, 2306, 3, 2, 2, 2, 2308, 371, 3, 2, 2, 2, 2309, 2310, 5, 436, 219, 2, 2310, 2311, 7, 129, 2, 2, 2311, 2312, 5, 30, 16, 2, 2312, 2313, 7, 130, 2, 2, 2313, 373, 3, 2, 2, 2, 2314, 2315, 7, 91, 2, 2, 2315, 2316, 5, 6, 4, 2, 2316, 2317, 7, 129, 2, 2, 2317, 2318, 5, 30, 16, 2, 2318, 2319, 7, 130, 2, 2, 2319, 2344, 3, 2, 2, 2, 2320, 2322, 7, 91, 2, 2, 2321, 2323, 5, 6, 4, 2, 2322, 2321, 3, 2, 2, 2, 2322, 2323, 3, 2, 2, 2, 2323, 2324, 3, 2, 2, 2, 2324, 2326, 7, 129, 2, 2, 2325, 2327, 5, 30, 16, 2, 2326, 2325, 3, 2, 2, 2, 2326, 2327, 3, 2, 2, 2, 2327, 2328, 3, 2, 2, 2, 2328, 2329, 7, 130, 2, 2, 2329, 2330, 7, 127, 2, 2, 2330, 2335, 5, 30, 16, 2, 2331, 2332, 7, 134, 2, 2, 2332, 2334, 5, 30, 16, 2, 2333, 2331, 3, 2, 2, 2, 2334, 2337, 3, 2, 2, 2, 2335, 2333, 3, 2, 2, 2, 2335, 2336, 3, 2, 2, 2, 2336, 2339, 3, 2, 2, 2, 2337, 2335, 3, 2, 2, 2, 2338, 2340, 7, 134, 2, 2, 2339, 2338, 3, 2, 2, 2, 2339, 2340, 3, 2, 2, 2, 2340, 2341, 3, 2, 2, 2, 2341, 2342, 7, 128, 2, 2, 2342, 2344, 3, 2, 2, 2, 2343, 2314, 3, 2, 2, 2, 2343, 2320, 3, 2, 2, 2, 2344, 375, 3, 2, 2, 2, 2345, 2346, 7, 147, 2, 2, 2346, 2347, 7, 149, 2, 2, 2347, 2348, 6, 189, 2, 3, 2348, 377, 3, 2, 2, 2, 2349, 2350, 7, 149, 2, 2, 2350, 2351, 7, 149, 2, 2, 2351, 2352, 6, 190, 3, 3, 2352, 379, 3, 2, 2, 2, 2353, 2354, 7, 149, 2, 2, 2354, 2355, 7, 161, 2, 2, 2355, 2356, 6, 191, 4, 3, 2356, 381, 3, 2, 2, 2, 2357, 2366, 5, 384, 193, 2, 2358, 2366, 5, 386, 194, 2, 2359, 2366, 7, 118, 2, 2, 2360, 2366, 7, 119, 2, 2, 2361, 2366, 7, 120, 2, 2, 2362, 2366, 7, 121, 2, 2, 2363, 2366, 7, 122, 2, 2, 2364, 2366, 7, 69, 2, 2, 2365, 2357, 3, 2, 2, 2, 2365, 2358, 3, 2, 2, 2, 2365, 2359, 3, 2, 2, 2, 2365, 2360, 3, 2, 2, 2, 2365, 2361, 3, 2, 2, 2, 2365, 2362, 3, 2, 2, 2, 2365, 2363, 3, 2, 2, 2, 2365, 2364, 3, 2, 2, 2, 2366, 383, 3, 2, 2, 2, 2367, 2368, 9, 17, 2, 2, 2368, 385, 3, 2, 2, 2, 2369, 2374, 5, 388, 195, 2, 2370, 2374, 5, 390, 196, 2, 2371, 2374, 7, 123, 2, 2, 2372, 2374, 7, 124, 2, 2, 2373, 2369, 3, 2, 2, 2, 2373, 2370, 3, 2, 2, 2, 2373, 2371, 3, 2, 2, 2, 2373, 2372, 3, 2, 2, 2, 2374, 387, 3, 2, 2, 2, 2375, 2379, 7, 125, 2, 2, 2376, 2378, 5, 392, 197, 2, 2377, 2376, 3, 2, 2, 2, 2378, 2381, 3, 2, 2, 2, 2379, 2377, 3, 2, 2, 2, 2379, 2380, 3, 2, 2, 2, 2380, 2382, 3, 2, 2, 2, 2381, 2379, 3, 2, 2, 2, 2382, 2383, 7, 178, 2, 2, 2383, 389, 3, 2, 2, 2, 2384, 2388, 7, 126, 2, 2, 2385, 2387, 5, 394, 198, 2, 2386, 2385, 3, 2, 2, 2, 2387, 2390, 3, 2, 2, 2, 2388, 2386, 3, 2, 2, 2, 2388, 2389, 3, 2, 2, 2, 2389, 2391, 3, 2, 2, 2, 2390, 2388, 3, 2, 2, 2, 2391, 2392, 7, 178, 2, 2, 2392, 391, 3, 2, 2, 2, 2393, 2398, 5, 396, 199, 2, 2394, 2398, 7, 174, 2, 2, 2395, 2398, 7, 176, 2, 2, 2396, 2398, 7, 179, 2, 2, 2397, 2393, 3, 2, 2, 2, 2397, 2394, 3, 2, 2, 2, 2397, 2395, 3, 2, 2, 2, 2397, 2396, 3, 2, 2, 2, 2398, 393, 3, 2, 2, 2, 2399, 2404, 5, 396, 199, 2, 2400, 2404, 7, 174, 2, 2, 2401, 2404, 7, 177, 2, 2, 2402, 2404, 7, 180, 2, 2, 2403, 2399, 3, 2, 2, 2, 2403, 2400, 3, 2, 2, 2, 2403, 2401, 3, 2, 2, 2, 2403, 2402, 3, 2, 2, 2, 2404, 395, 3, 2, 2, 2, 2405, 2410, 5, 30, 16, 2, 2406, 2407, 7, 134, 2, 2, 2407, 2409, 5, 30, 16, 2, 2408, 2406, 3, 2, 2, 2, 2409, 2412, 3, 2, 2, 2, 2410, 2408, 3, 2, 2, 2, 2410, 2411, 3, 2, 2, 2, 2411, 2419, 3, 2, 2, 2, 2412, 2410, 3, 2, 2, 2, 2413, 2415, 7, 135, 2, 2, 2414, 2416, 7, 182, 2, 2, 2415, 2414, 3, 2, 2, 2, 2416, 2417, 3, 2, 2, 2, 2417, 2415, 3, 2, 2, 2, 2417, 2418, 3, 2, 2, 2, 2418, 2420, 3, 2, 2, 2, 2419, 2413, 3, 2, 2, 2, 2419, 2420, 3, 2, 2, 2, 2420, 397, 3, 2, 2, 2, 2421, 2422, 9, 18, 2, 2, 2422, 399, 3, 2, 2, 2, 2423, 2424, 7, 28, 2, 2, 2424, 2426, 5, 436, 219, 2, 2425, 2427, 5, 232, 117, 2, 2426, 2425, 3, 2, 2, 2, 2426, 2427, 3, 2, 2, 2, 2427, 2429, 3, 2, 2, 2, 2428, 2430, 5, 236, 119, 2, 2429, 2428, 3, 2, 2, 2, 2429, 2430, 3, 2, 2, 2, 2430, 2432, 3, 2, 2, 2, 2431, 2433, 5, 240, 121, 2, 2432, 2431, 3, 2, 2, 2, 2432, 2433, 3, 2, 2, 2, 2433, 2434, 3, 2, 2, 2, 2434, 2436, 5, 252, 127, 2, 2435, 2437, 7, 136, 2, 2, 2436, 2435, 3, 2, 2, 2, 2436, 2437, 3, 2, 2, 2, 2437, 401, 3, 2, 2, 2, 2438, 2440, 9, 19, 2, 2, 2439, 2438, 3, 2, 2, 2, 2439, 2440, 3, 2, 2, 2, 2440, 2441, 3, 2, 2, 2, 2441, 2442, 7, 94, 2, 2, 2442, 2444, 5, 436, 219, 2, 2443, 2445, 5, 232, 117, 2, 2444, 2443, 3, 2, 2, 2, 2444, 2445, 3, 2, 2, 2, 2445, 2447, 3, 2, 2, 2, 2446, 2448, 5, 316, 159, 2, 2447, 2446, 3, 2, 2, 2, 2447, 2448, 3, 2, 2, 2, 2448, 2450, 3, 2, 2, 2, 2449, 2451, 5, 240, 121, 2, 2450, 2449, 3, 2, 2, 2, 2450, 2451, 3, 2, 2, 2, 2451, 2452, 3, 2, 2, 2, 2452, 2454, 5, 318, 160, 2, 2453, 2455, 7, 136, 2, 2, 2454, 2453, 3, 2, 2, 2, 2454, 2455, 3, 2, 2, 2, 2455, 403, 3, 2, 2, 2, 2456, 2457, 7, 58, 2, 2, 2457, 2459, 5, 436, 219, 2, 2458, 2460, 5, 328, 165, 2, 2459, 2458, 3, 2, 2, 2, 2459, 2460, 3, 2, 2, 2, 2460, 2462, 3, 2, 2, 2, 2461, 2463, 5, 334, 168, 2, 2462, 2461, 3, 2, 2, 2, 2462, 2463, 3, 2, 2, 2, 2463, 2465, 3, 2, 2, 2, 2464, 2466, 5, 240, 121, 2, 2465, 2464, 3, 2, 2, 2, 2465, 2466, 3, 2, 2, 2, 2466, 2467, 3, 2, 2, 2, 2467, 2469, 5, 252, 127, 2, 2468, 2470, 7, 136, 2, 2, 2469, 2468, 3, 2, 2, 2, 2469, 2470, 3, 2, 2, 2, 2470, 405, 3, 2, 2, 2, 2471, 2472, 7, 39, 2, 2, 2472, 2474, 5, 436, 219, 2, 2473, 2475, 5, 342, 172, 2, 2474, 2473, 3, 2, 2, 2, 2474, 2475, 3, 2, 2, 2, 2475, 2476, 3, 2, 2, 2, 2476, 2478, 5, 344, 173, 2, 2477, 2479, 7, 136, 2, 2, 2478, 2477, 3, 2, 2, 2, 2478, 2479, 3, 2, 2, 2, 2479, 407, 3, 2, 2, 2, 2480, 2481, 7, 33, 2, 2, 2481, 2482, 5, 276, 139, 2, 2482, 2484, 5, 436, 219, 2, 2483, 2485, 5, 328, 165, 2, 2484, 2483, 3, 2, 2, 2, 2484, 2485, 3, 2, 2, 2, 2485, 2486, 3, 2, 2, 2, 2486, 2488, 7, 131, 2, 2, 2487, 2489, 5, 282, 142, 2, 2488, 2487, 3, 2, 2, 2, 2488, 2489, 3, 2, 2, 2, 2489, 2490, 3, 2, 2, 2, 2490, 2492, 7, 132, 2, 2, 2491, 2493, 5, 240, 121, 2, 2492, 2491, 3, 2, 2, 2, 2492, 2493, 3, 2, 2, 2, 2493, 2494, 3, 2, 2, 2, 2494, 2495, 7, 136, 2, 2, 2495, 409, 3, 2, 2, 2, 2496, 2497, 7, 41, 2, 2, 2497, 2506, 5, 6, 4, 2, 2498, 2499, 5, 270, 136, 2, 2499, 2500, 7, 136, 2, 2, 2500, 2507, 3, 2, 2, 2, 2501, 2502, 5, 278, 140, 2, 2502, 2503, 7, 127, 2, 2, 2503, 2504, 5, 302, 152, 2, 2504, 2505, 7, 128, 2, 2, 2505, 2507, 3, 2, 2, 2, 2506, 2498, 3, 2, 2, 2, 2506, 2501, 3, 2, 2, 2, 2507, 411, 3, 2, 2, 2, 2508, 2509, 5, 270, 136, 2, 2509, 2510, 7, 136, 2, 2, 2510, 413, 3, 2, 2, 2, 2511, 2525, 5, 278, 140, 2, 2512, 2513, 7, 127, 2, 2, 2513, 2514, 5, 292, 147, 2, 2514, 2519, 7, 128, 2, 2, 2515, 2516, 7, 147, 2, 2, 2516, 2517, 5, 274, 138, 2, 2517, 2518, 7, 136, 2, 2, 2518, 2520, 3, 2, 2, 2, 2519, 2515, 3, 2, 2, 2, 2519, 2520, 3, 2, 2, 2, 2520, 2526, 3, 2, 2, 2, 2521, 2522, 5, 376, 189, 2, 2522, 2523, 5, 76, 39, 2, 2523, 2524, 7, 136, 2, 2, 2524, 2526, 3, 2, 2, 2, 2525, 2512, 3, 2, 2, 2, 2525, 2521, 3, 2, 2, 2, 2526, 415, 3, 2, 2, 2, 2527, 2528, 7, 29, 2, 2, 2528, 2529, 5, 6, 4, 2, 2529, 2530, 5, 266, 134, 2, 2530, 2531, 7, 136, 2, 2, 2531, 417, 3, 2, 2, 2, 2532, 2533, 7, 96, 2, 2, 2533, 2534, 7, 129, 2, 2, 2534, 2535, 5, 282, 142, 2, 2535, 2544, 7, 130, 2, 2, 2536, 2537, 7, 127, 2, 2, 2537, 2538, 5, 292, 147, 2, 2538, 2539, 7, 128, 2, 2, 2539, 2545, 3, 2, 2, 2, 2540, 2541, 5, 376, 189, 2, 2541, 2542, 5, 76, 39, 2, 2542, 2543, 7, 136, 2, 2, 2543, 2545, 3, 2, 2, 2, 2544, 2536, 3, 2, 2, 2, 2544, 2540, 3, 2, 2, 2, 2545, 419, 3, 2, 2, 2, 2546, 2547, 7, 146, 2, 2, 2547, 2548, 5, 436, 219, 2, 2548, 2549, 7, 131, 2, 2, 2549, 2550, 7, 132, 2, 2, 2550, 2551, 5, 314, 158, 2, 2551, 421, 3, 2, 2, 2, 2552, 2553, 5, 436, 219, 2, 2553, 2555, 7, 131, 2, 2, 2554, 2556, 5, 282, 142, 2, 2555, 2554, 3, 2, 2, 2, 2555, 2556, 3, 2, 2, 2, 2556, 2557, 3, 2, 2, 2, 2557, 2559, 7, 132, 2, 2, 2558, 2560, 5, 312, 157, 2, 2559, 2558, 3, 2, 2, 2, 2559, 2560, 3, 2, 2, 2, 2560, 2561, 3, 2, 2, 2, 2561, 2562, 5, 314, 158, 2, 2562, 423, 3, 2, 2, 2, 2563, 2565, 5, 426, 214, 2, 2564, 2566, 5, 232, 117, 2, 2565, 2564, 3, 2, 2, 2, 2565, 2566, 3, 2, 2, 2, 2566, 2567, 3, 2, 2, 2, 2567, 2569, 7, 131, 2, 2, 2568, 2570, 5, 282, 142, 2, 2569, 2568, 3, 2, 2, 2, 2569, 2570, 3, 2, 2, 2, 2570, 2571, 3, 2, 2, 2, 2571, 2573, 7, 132, 2, 2, 2572, 2574, 5, 240, 121, 2, 2573, 2572, 3, 2, 2, 2, 2573, 2574, 3, 2, 2, 2, 2574, 2580, 3, 2, 2, 2, 2575, 2581, 5, 280, 141, 2, 2576, 2577, 5, 376, 189, 2, 2577, 2578, 5, 76, 39, 2, 2578, 2579, 7, 136, 2, 2, 2579, 2581, 3, 2, 2, 2, 2580, 2575, 3, 2, 2, 2, 2580, 2576, 3, 2, 2, 2, 2581, 425, 3, 2, 2, 2, 2582, 2588, 5, 436, 219, 2, 2583, 2584, 5, 436, 219, 2, 2584, 2585, 7, 151, 2, 2, 2585, 2586, 5, 436, 219, 2, 2586, 2588, 3, 2, 2, 2, 2587, 2582, 3, 2, 2, 2, 2587, 2583, 3, 2, 2, 2, 2588, 2596, 3, 2, 2, 2, 2589, 2591, 5, 24, 13, 2, 2590, 2589, 3, 2, 2, 2, 2590, 2591, 3, 2, 2, 2, 2591, 2592, 3, 2, 2, 2, 2592, 2593, 7, 133, 2, 2, 2593, 2595, 5, 436, 219, 2, 2594, 2590, 3, 2, 2, 2, 2595, 2598, 3, 2, 2, 2, 2596, 2594, 3, 2, 2, 2, 2596, 2597, 3, 2, 2, 2, 2597, 427, 3, 2, 2, 2, 2598, 2596, 3, 2, 2, 2, 2599, 2600, 7, 72, 2, 2, 2600, 2601, 5, 308, 155, 2, 2601, 2603, 7, 131, 2, 2, 2602, 2604, 7, 56, 2, 2, 2603, 2602, 3, 2, 2, 2, 2603, 2604, 3, 2, 2, 2, 2604, 2605, 3, 2, 2, 2, 2605, 2611, 5, 430, 216, 2, 2606, 2608, 7, 134, 2, 2, 2607, 2609, 7, 56, 2, 2, 2608, 2607, 3, 2, 2, 2, 2608, 2609, 3, 2, 2, 2, 2609, 2610, 3, 2, 2, 2, 2610, 2612, 5, 430, 216, 2, 2611, 2606, 3, 2, 2, 2, 2611, 2612, 3, 2, 2, 2, 2612, 2613, 3, 2, 2, 2, 2613, 2619, 7, 132, 2, 2, 2614, 2620, 5, 314, 158, 2, 2615, 2616, 5, 376, 189, 2, 2616, 2617, 5, 76, 39, 2, 2617, 2618, 7, 136, 2, 2, 2618, 2620, 3, 2, 2, 2, 2619, 2614, 3, 2, 2, 2, 2619, 2615, 3, 2, 2, 2, 2620, 429, 3, 2, 2, 2, 2621, 2622, 5, 6, 4, 2, 2622, 2625, 5, 436, 219, 2, 2623, 2624, 7, 147, 2, 2, 2624, 2626, 5, 30, 16, 2, 2625, 2623, 3, 2, 2, 2, 2625, 2626, 3, 2, 2, 2, 2626, 431, 3, 2, 2, 2, 2627, 2629, 7, 131, 2, 2, 2628, 2630, 5, 26, 14, 2, 2629, 2628, 3, 2, 2, 2, 2629, 2630, 3, 2, 2, 2, 2630, 2631, 3, 2, 2, 2, 2631, 2632, 7, 132, 2, 2, 2632, 433, 3, 2, 2, 2, 2633, 2635, 7, 131, 2, 2, 2634, 2636, 5, 26, 14, 2, 2635, 2634, 3, 2, 2, 2, 2635, 2636, 3, 2, 2, 2, 2636, 2637, 3, 2, 2, 2, 2637, 2639, 7, 132, 2, 2, 2638, 2640, 5, 90, 46, 2, 2639, 2638, 3, 2, 2, 2, 2639, 2640, 3, 2, 2, 2, 2640, 435, 3, 2, 2, 2, 2641, 2642, 9, 20, 2, 2, 2642, 437, 3, 2, 2, 2, 346, 439, 442, 445, 450, 454, 460, 463, 468, 472, 479, 481, 489, 497, 503, 507, 512, 522, 530, 540, 546, 549, 553, 561, 566, 576, 589, 597, 603, 605, 612, 620, 628, 636, 644, 652, 662, 664, 670, 675, 683, 691, 699, 701, 704, 711, 716, 723, 727, 729, 757, 761, 766, 770, 778, 781, 786, 790, 794, 800, 814, 820, 832, 836, 841, 845, 851, 859, 868, 886, 889, 894, 897, 912, 918, 922, 928, 933, 936, 944, 952, 963, 968, 973, 975, 984, 992, 999, 1007, 1011, 1020, 1025, 1027, 1036, 1044, 1048, 1053, 1055, 1060, 1064, 1071, 1079, 1081, 1085, 1088, 1091, 1099, 1109, 1126, 1133, 1137, 1147, 1152, 1159, 1168, 1173, 1180, 1192, 1203, 1211, 1216, 1225, 1234, 1243, 1249, 1254, 1258, 1262, 1266, 1270, 1277, 1285, 1298, 1308, 1330, 1334, 1338, 1343, 1363, 1368, 1373, 1380, 1383, 1405, 1417, 1421, 1429, 1437, 1444, 1448, 1453, 1456, 1461, 1469, 1474, 1481, 1487, 1495, 1503, 1506, 1513, 1520, 1524, 1527, 1533, 1537, 1543, 1557, 1563, 1570, 1575, 1578, 1581, 1588, 1598, 1615, 1620, 1624, 1627, 1630, 1637, 1643, 1651, 1657, 1667, 1675, 1681, 1692, 1696, 1698, 1703, 1707, 1714, 1723, 1730, 1733, 1736, 1740, 1745, 1758, 1768, 1775, 1787, 1794, 1806, 1812, 1816, 1820, 1826, 1832, 1834, 1841, 1845, 1848, 1852, 1862, 1865, 1872, 1875, 1880, 1885, 1887, 1890, 1893, 1899, 1902, 1914, 1918, 1921, 1931, 1934, 1940, 1967, 1980, 1986, 1995, 2001, 2004, 2012, 2016, 2022, 2028, 2034, 2045, 2049, 2051, 2061, 2067, 2070, 2083, 2089, 2092, 2095, 2102, 2107, 2111, 2115, 2132, 2135, 2140, 2144, 2148, 2157, 2160, 2165, 2169, 2174, 2178, 2180, 2191, 2195, 2197, 2202, 2207, 2214, 2220, 2225, 2231, 2235, 2241, 2248, 2258, 2261, 2264, 2269, 2275, 2279, 2281, 2288, 2295, 2303, 2307, 2322, 2326, 2335, 2339, 2343, 2365, 2373, 2379, 2388, 2397, 2403, 2410, 2417, 2419, 2426, 2429, 2432, 2436, 2439, 2444, 2447, 2450, 2454, 2459, 2462, 2465, 2469, 2474, 2478, 2484, 2488, 2492, 2506, 2519, 2525, 2544, 2555, 2559, 2565, 2569, 2573, 2580, 2587, 2590, 2596, 2603, 2608, 2611, 2619, 2625, 2629, 2635, 2639] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.java deleted file mode 100644 index ebf2eeb..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/cs/CSharpParser.java +++ /dev/null @@ -1,20418 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.cs;// Generated from CSharpParser.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.FailedPredicateException; -import org.antlr.v4.runtime.NoViableAltException; -import org.antlr.v4.runtime.Parser; -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.RecognitionException; -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.ParserATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.Utils; -import org.antlr.v4.runtime.tree.ParseTreeListener; -import org.antlr.v4.runtime.tree.TerminalNode; - -import java.util.List; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class CSharpParser extends Parser { - static { RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - BYTE_ORDER_MARK=1, SINGLE_LINE_DOC_COMMENT=2, EMPTY_DELIMITED_DOC_COMMENT=3, - DELIMITED_DOC_COMMENT=4, SINGLE_LINE_COMMENT=5, DELIMITED_COMMENT=6, WHITESPACES=7, - SHARP=8, ABSTRACT=9, ADD=10, ALIAS=11, ARGLIST=12, AS=13, ASCENDING=14, - ASYNC=15, AWAIT=16, BASE=17, BOOL=18, BREAK=19, BY=20, BYTE=21, CASE=22, - CATCH=23, CHAR=24, CHECKED=25, CLASS=26, CONST=27, CONTINUE=28, DECIMAL=29, - DEFAULT=30, DELEGATE=31, DESCENDING=32, DO=33, DOUBLE=34, DYNAMIC=35, - ELSE=36, ENUM=37, EQUALS=38, EVENT=39, EXPLICIT=40, EXTERN=41, FALSE=42, - FINALLY=43, FIXED=44, FLOAT=45, FOR=46, FOREACH=47, FROM=48, GET=49, GOTO=50, - GROUP=51, IF=52, IMPLICIT=53, IN=54, INT=55, INTERFACE=56, INTERNAL=57, - INTO=58, IS=59, JOIN=60, LET=61, LOCK=62, LONG=63, NAMEOF=64, NAMESPACE=65, - NEW=66, NULL=67, OBJECT=68, ON=69, OPERATOR=70, ORDERBY=71, OUT=72, OVERRIDE=73, - PARAMS=74, PARTIAL=75, PRIVATE=76, PROTECTED=77, PUBLIC=78, READONLY=79, - REF=80, REMOVE=81, RETURN=82, SBYTE=83, SEALED=84, SELECT=85, SET=86, - SHORT=87, SIZEOF=88, STACKALLOC=89, STATIC=90, STRING=91, STRUCT=92, SWITCH=93, - THIS=94, THROW=95, TRUE=96, TRY=97, TYPEOF=98, UINT=99, ULONG=100, UNCHECKED=101, - UNMANAGED=102, UNSAFE=103, USHORT=104, USING=105, VAR=106, VIRTUAL=107, - VOID=108, VOLATILE=109, WHEN=110, WHERE=111, WHILE=112, YIELD=113, IDENTIFIER=114, - LITERAL_ACCESS=115, INTEGER_LITERAL=116, HEX_INTEGER_LITERAL=117, BIN_INTEGER_LITERAL=118, - REAL_LITERAL=119, CHARACTER_LITERAL=120, REGULAR_STRING=121, VERBATIUM_STRING=122, - INTERPOLATED_REGULAR_STRING_START=123, INTERPOLATED_VERBATIUM_STRING_START=124, - OPEN_BRACE=125, CLOSE_BRACE=126, OPEN_BRACKET=127, CLOSE_BRACKET=128, - OPEN_PARENS=129, CLOSE_PARENS=130, DOT=131, COMMA=132, COLON=133, SEMICOLON=134, - PLUS=135, MINUS=136, STAR=137, DIV=138, PERCENT=139, AMP=140, BITWISE_OR=141, - CARET=142, BANG=143, TILDE=144, ASSIGNMENT=145, LT=146, GT=147, INTERR=148, - DOUBLE_COLON=149, OP_COALESCING=150, OP_INC=151, OP_DEC=152, OP_AND=153, - OP_OR=154, OP_PTR=155, OP_EQ=156, OP_NE=157, OP_LE=158, OP_GE=159, OP_ADD_ASSIGNMENT=160, - OP_SUB_ASSIGNMENT=161, OP_MULT_ASSIGNMENT=162, OP_DIV_ASSIGNMENT=163, - OP_MOD_ASSIGNMENT=164, OP_AND_ASSIGNMENT=165, OP_OR_ASSIGNMENT=166, OP_XOR_ASSIGNMENT=167, - OP_LEFT_SHIFT=168, OP_LEFT_SHIFT_ASSIGNMENT=169, OP_COALESCING_ASSIGNMENT=170, - OP_RANGE=171, DOUBLE_CURLY_INSIDE=172, OPEN_BRACE_INSIDE=173, REGULAR_CHAR_INSIDE=174, - VERBATIUM_DOUBLE_QUOTE_INSIDE=175, DOUBLE_QUOTE_INSIDE=176, REGULAR_STRING_INSIDE=177, - VERBATIUM_INSIDE_STRING=178, CLOSE_BRACE_INSIDE=179, FORMAT_STRING=180, - DIRECTIVE_WHITESPACES=181, DIGITS=182, DEFINE=183, UNDEF=184, ELIF=185, - ENDIF=186, LINE=187, ERROR=188, WARNING=189, REGION=190, ENDREGION=191, - PRAGMA=192, NULLABLE=193, DIRECTIVE_HIDDEN=194, CONDITIONAL_SYMBOL=195, - DIRECTIVE_NEW_LINE=196, TEXT=197, DOUBLE_CURLY_CLOSE_INSIDE=198; - public static final int - RULE_compilation_unit = 0, RULE_namespace_or_type_name = 1, RULE_type_ = 2, - RULE_base_type = 3, RULE_tuple_type = 4, RULE_tuple_element = 5, RULE_simple_type = 6, - RULE_numeric_type = 7, RULE_integral_type = 8, RULE_floating_point_type = 9, - RULE_class_type = 10, RULE_type_argument_list = 11, RULE_argument_list = 12, - RULE_argument = 13, RULE_expression = 14, RULE_non_assignment_expression = 15, - RULE_assignment = 16, RULE_assignment_operator = 17, RULE_conditional_expression = 18, - RULE_null_coalescing_expression = 19, RULE_conditional_or_expression = 20, - RULE_conditional_and_expression = 21, RULE_inclusive_or_expression = 22, - RULE_exclusive_or_expression = 23, RULE_and_expression = 24, RULE_equality_expression = 25, - RULE_relational_expression = 26, RULE_shift_expression = 27, RULE_additive_expression = 28, - RULE_multiplicative_expression = 29, RULE_switch_expression = 30, RULE_switch_expression_arms = 31, - RULE_switch_expression_arm = 32, RULE_range_expression = 33, RULE_unary_expression = 34, - RULE_primary_expression = 35, RULE_primary_expression_start = 36, RULE_throwable_expression = 37, - RULE_throw_expression = 38, RULE_member_access = 39, RULE_bracket_expression = 40, - RULE_indexer_argument = 41, RULE_predefined_type = 42, RULE_expression_list = 43, - RULE_object_or_collection_initializer = 44, RULE_object_initializer = 45, - RULE_member_initializer_list = 46, RULE_member_initializer = 47, RULE_initializer_value = 48, - RULE_collection_initializer = 49, RULE_element_initializer = 50, RULE_anonymous_object_initializer = 51, - RULE_member_declarator_list = 52, RULE_member_declarator = 53, RULE_unbound_type_name = 54, - RULE_generic_dimension_specifier = 55, RULE_isType = 56, RULE_isTypePatternArms = 57, - RULE_isTypePatternArm = 58, RULE_lambda_expression = 59, RULE_anonymous_function_signature = 60, - RULE_explicit_anonymous_function_parameter_list = 61, RULE_explicit_anonymous_function_parameter = 62, - RULE_implicit_anonymous_function_parameter_list = 63, RULE_anonymous_function_body = 64, - RULE_query_expression = 65, RULE_from_clause = 66, RULE_query_body = 67, - RULE_query_body_clause = 68, RULE_let_clause = 69, RULE_where_clause = 70, - RULE_combined_join_clause = 71, RULE_orderby_clause = 72, RULE_ordering = 73, - RULE_select_or_group_clause = 74, RULE_query_continuation = 75, RULE_statement = 76, - RULE_declarationStatement = 77, RULE_local_function_declaration = 78, - RULE_local_function_header = 79, RULE_local_function_modifiers = 80, RULE_local_function_body = 81, - RULE_labeled_Statement = 82, RULE_embedded_statement = 83, RULE_simple_embedded_statement = 84, - RULE_block = 85, RULE_local_variable_declaration = 86, RULE_local_variable_type = 87, - RULE_local_variable_declarator = 88, RULE_local_variable_initializer = 89, - RULE_local_constant_declaration = 90, RULE_if_body = 91, RULE_switch_section = 92, - RULE_switch_label = 93, RULE_case_guard = 94, RULE_statement_list = 95, - RULE_for_initializer = 96, RULE_for_iterator = 97, RULE_catch_clauses = 98, - RULE_specific_catch_clause = 99, RULE_general_catch_clause = 100, RULE_exception_filter = 101, - RULE_finally_clause = 102, RULE_resource_acquisition = 103, RULE_namespace_declaration = 104, - RULE_qualified_identifier = 105, RULE_namespace_body = 106, RULE_extern_alias_directives = 107, - RULE_extern_alias_directive = 108, RULE_using_directives = 109, RULE_using_directive = 110, - RULE_namespace_member_declarations = 111, RULE_namespace_member_declaration = 112, - RULE_type_declaration = 113, RULE_qualified_alias_member = 114, RULE_type_parameter_list = 115, - RULE_type_parameter = 116, RULE_class_base = 117, RULE_interface_type_list = 118, - RULE_type_parameter_constraints_clauses = 119, RULE_type_parameter_constraints_clause = 120, - RULE_type_parameter_constraints = 121, RULE_primary_constraint = 122, - RULE_secondary_constraints = 123, RULE_constructor_constraint = 124, RULE_class_body = 125, - RULE_class_member_declarations = 126, RULE_class_member_declaration = 127, - RULE_all_member_modifiers = 128, RULE_all_member_modifier = 129, RULE_common_member_declaration = 130, - RULE_typed_member_declaration = 131, RULE_constant_declarators = 132, - RULE_constant_declarator = 133, RULE_variable_declarators = 134, RULE_variable_declarator = 135, - RULE_variable_initializer = 136, RULE_return_type = 137, RULE_member_name = 138, - RULE_method_body = 139, RULE_formal_parameter_list = 140, RULE_fixed_parameters = 141, - RULE_fixed_parameter = 142, RULE_parameter_modifier = 143, RULE_parameter_array = 144, - RULE_accessor_declarations = 145, RULE_get_accessor_declaration = 146, - RULE_set_accessor_declaration = 147, RULE_accessor_modifier = 148, RULE_accessor_body = 149, - RULE_event_accessor_declarations = 150, RULE_add_accessor_declaration = 151, - RULE_remove_accessor_declaration = 152, RULE_overloadable_operator = 153, - RULE_conversion_operator_declarator = 154, RULE_constructor_initializer = 155, - RULE_body = 156, RULE_struct_interfaces = 157, RULE_struct_body = 158, - RULE_struct_member_declaration = 159, RULE_array_type = 160, RULE_rank_specifier = 161, - RULE_array_initializer = 162, RULE_variant_type_parameter_list = 163, - RULE_variant_type_parameter = 164, RULE_variance_annotation = 165, RULE_interface_base = 166, - RULE_interface_body = 167, RULE_interface_member_declaration = 168, RULE_interface_accessors = 169, - RULE_enum_base = 170, RULE_enum_body = 171, RULE_enum_member_declaration = 172, - RULE_global_attribute_section = 173, RULE_global_attribute_target = 174, - RULE_attributes = 175, RULE_attribute_section = 176, RULE_attribute_target = 177, - RULE_attribute_list = 178, RULE_attribute = 179, RULE_attribute_argument = 180, - RULE_pointer_type = 181, RULE_fixed_pointer_declarators = 182, RULE_fixed_pointer_declarator = 183, - RULE_fixed_pointer_initializer = 184, RULE_fixed_size_buffer_declarator = 185, - RULE_stackalloc_initializer = 186, RULE_right_arrow = 187, RULE_right_shift = 188, - RULE_right_shift_assignment = 189, RULE_literal = 190, RULE_boolean_literal = 191, - RULE_string_literal = 192, RULE_interpolated_regular_string = 193, RULE_interpolated_verbatium_string = 194, - RULE_interpolated_regular_string_part = 195, RULE_interpolated_verbatium_string_part = 196, - RULE_interpolated_string_expression = 197, RULE_keyword = 198, RULE_class_definition = 199, - RULE_struct_definition = 200, RULE_interface_definition = 201, RULE_enum_definition = 202, - RULE_delegate_definition = 203, RULE_event_declaration = 204, RULE_field_declaration = 205, - RULE_property_declaration = 206, RULE_constant_declaration = 207, RULE_indexer_declaration = 208, - RULE_destructor_definition = 209, RULE_constructor_declaration = 210, - RULE_method_declaration = 211, RULE_method_member_name = 212, RULE_operator_declaration = 213, - RULE_arg_declaration = 214, RULE_method_invocation = 215, RULE_object_creation_expression = 216, - RULE_identifier = 217; - private static String[] makeRuleNames() { - return new String[] { - "compilation_unit", "namespace_or_type_name", "type_", "base_type", "tuple_type", - "tuple_element", "simple_type", "numeric_type", "integral_type", "floating_point_type", - "class_type", "type_argument_list", "argument_list", "argument", "expression", - "non_assignment_expression", "assignment", "assignment_operator", "conditional_expression", - "null_coalescing_expression", "conditional_or_expression", "conditional_and_expression", - "inclusive_or_expression", "exclusive_or_expression", "and_expression", - "equality_expression", "relational_expression", "shift_expression", "additive_expression", - "multiplicative_expression", "switch_expression", "switch_expression_arms", - "switch_expression_arm", "range_expression", "unary_expression", "primary_expression", - "primary_expression_start", "throwable_expression", "throw_expression", - "member_access", "bracket_expression", "indexer_argument", "predefined_type", - "expression_list", "object_or_collection_initializer", "object_initializer", - "member_initializer_list", "member_initializer", "initializer_value", - "collection_initializer", "element_initializer", "anonymous_object_initializer", - "member_declarator_list", "member_declarator", "unbound_type_name", "generic_dimension_specifier", - "isType", "isTypePatternArms", "isTypePatternArm", "lambda_expression", - "anonymous_function_signature", "explicit_anonymous_function_parameter_list", - "explicit_anonymous_function_parameter", "implicit_anonymous_function_parameter_list", - "anonymous_function_body", "query_expression", "from_clause", "query_body", - "query_body_clause", "let_clause", "where_clause", "combined_join_clause", - "orderby_clause", "ordering", "select_or_group_clause", "query_continuation", - "statement", "declarationStatement", "local_function_declaration", "local_function_header", - "local_function_modifiers", "local_function_body", "labeled_Statement", - "embedded_statement", "simple_embedded_statement", "block", "local_variable_declaration", - "local_variable_type", "local_variable_declarator", "local_variable_initializer", - "local_constant_declaration", "if_body", "switch_section", "switch_label", - "case_guard", "statement_list", "for_initializer", "for_iterator", "catch_clauses", - "specific_catch_clause", "general_catch_clause", "exception_filter", - "finally_clause", "resource_acquisition", "namespace_declaration", "qualified_identifier", - "namespace_body", "extern_alias_directives", "extern_alias_directive", - "using_directives", "using_directive", "namespace_member_declarations", - "namespace_member_declaration", "type_declaration", "qualified_alias_member", - "type_parameter_list", "type_parameter", "class_base", "interface_type_list", - "type_parameter_constraints_clauses", "type_parameter_constraints_clause", - "type_parameter_constraints", "primary_constraint", "secondary_constraints", - "constructor_constraint", "class_body", "class_member_declarations", - "class_member_declaration", "all_member_modifiers", "all_member_modifier", - "common_member_declaration", "typed_member_declaration", "constant_declarators", - "constant_declarator", "variable_declarators", "variable_declarator", - "variable_initializer", "return_type", "member_name", "method_body", - "formal_parameter_list", "fixed_parameters", "fixed_parameter", "parameter_modifier", - "parameter_array", "accessor_declarations", "get_accessor_declaration", - "set_accessor_declaration", "accessor_modifier", "accessor_body", "event_accessor_declarations", - "add_accessor_declaration", "remove_accessor_declaration", "overloadable_operator", - "conversion_operator_declarator", "constructor_initializer", "body", - "struct_interfaces", "struct_body", "struct_member_declaration", "array_type", - "rank_specifier", "array_initializer", "variant_type_parameter_list", - "variant_type_parameter", "variance_annotation", "interface_base", "interface_body", - "interface_member_declaration", "interface_accessors", "enum_base", "enum_body", - "enum_member_declaration", "global_attribute_section", "global_attribute_target", - "attributes", "attribute_section", "attribute_target", "attribute_list", - "attribute", "attribute_argument", "pointer_type", "fixed_pointer_declarators", - "fixed_pointer_declarator", "fixed_pointer_initializer", "fixed_size_buffer_declarator", - "stackalloc_initializer", "right_arrow", "right_shift", "right_shift_assignment", - "literal", "boolean_literal", "string_literal", "interpolated_regular_string", - "interpolated_verbatium_string", "interpolated_regular_string_part", - "interpolated_verbatium_string_part", "interpolated_string_expression", - "keyword", "class_definition", "struct_definition", "interface_definition", - "enum_definition", "delegate_definition", "event_declaration", "field_declaration", - "property_declaration", "constant_declaration", "indexer_declaration", - "destructor_definition", "constructor_declaration", "method_declaration", - "method_member_name", "operator_declaration", "arg_declaration", "method_invocation", - "object_creation_expression", "identifier" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, "'\u00EF\u00BB\u00BF'", null, "'/***/'", null, null, null, null, - "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", - "'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", - "'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", - "'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", - "'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", - "'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", - "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", - "'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", - "'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", - "'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", - "'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", - "'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", - "'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", - "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", - "'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", - "'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", - "'yield'", null, null, null, null, null, null, null, null, null, null, - null, "'{'", "'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", - "';'", "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", - "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", - "'||'", "'->'", "'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", - "'/='", "'%='", "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", - "'{{'", null, null, null, null, null, null, null, null, null, null, "'define'", - "'undef'", "'elif'", "'endif'", "'line'", null, null, null, null, null, - null, "'hidden'", null, null, null, "'}}'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", - "DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", - "WHITESPACES", "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", - "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", - "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", - "DEFAULT", "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", - "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", "FALSE", "FINALLY", - "FIXED", "FLOAT", "FOR", "FOREACH", "FROM", "GET", "GOTO", "GROUP", "IF", - "IMPLICIT", "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", "JOIN", - "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", "NEW", "NULL", "OBJECT", - "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", "PARAMS", "PARTIAL", - "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", "RETURN", - "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", "STACKALLOC", - "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", - "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", "USHORT", - "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", "WHILE", - "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", - "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", - "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", - "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", - "STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", - "ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", - "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", - "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", - "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", - "OP_XOR_ASSIGNMENT", "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", - "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", - "VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", - "VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", - "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", - "REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", - "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - @Override - public String getGrammarFileName() { return "CSharpParser.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public ATN getATN() { return _ATN; } - - public CSharpParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - public static class Compilation_unitContext extends ParserRuleContext { - public TerminalNode EOF() { return getToken(CSharpParser.EOF, 0); } - public TerminalNode BYTE_ORDER_MARK() { return getToken(CSharpParser.BYTE_ORDER_MARK, 0); } - public Extern_alias_directivesContext extern_alias_directives() { - return getRuleContext(Extern_alias_directivesContext.class,0); - } - public Using_directivesContext using_directives() { - return getRuleContext(Using_directivesContext.class,0); - } - public List global_attribute_section() { - return getRuleContexts(Global_attribute_sectionContext.class); - } - public Global_attribute_sectionContext global_attribute_section(int i) { - return getRuleContext(Global_attribute_sectionContext.class,i); - } - public Namespace_member_declarationsContext namespace_member_declarations() { - return getRuleContext(Namespace_member_declarationsContext.class,0); - } - public Compilation_unitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_compilation_unit; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCompilation_unit(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCompilation_unit(this); - } - } - - public final Compilation_unitContext compilation_unit() throws RecognitionException { - Compilation_unitContext _localctx = new Compilation_unitContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_compilation_unit); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(437); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==BYTE_ORDER_MARK) { - { - setState(436); - match(BYTE_ORDER_MARK); - } - } - - setState(440); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { - case 1: - { - setState(439); - extern_alias_directives(); - } - break; - } - setState(443); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(442); - using_directives(); - } - } - - setState(448); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,3,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(445); - global_attribute_section(); - } - } - } - setState(450); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,3,_ctx); - } - setState(452); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0)) { - { - setState(451); - namespace_member_declarations(); - } - } - - setState(454); - match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Namespace_or_type_nameContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Qualified_alias_memberContext qualified_alias_member() { - return getRuleContext(Qualified_alias_memberContext.class,0); - } - public List DOT() { return getTokens(CSharpParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(CSharpParser.DOT, i); - } - public List type_argument_list() { - return getRuleContexts(Type_argument_listContext.class); - } - public Type_argument_listContext type_argument_list(int i) { - return getRuleContext(Type_argument_listContext.class,i); - } - public Namespace_or_type_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_namespace_or_type_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNamespace_or_type_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNamespace_or_type_name(this); - } - } - - public final Namespace_or_type_nameContext namespace_or_type_name() throws RecognitionException { - Namespace_or_type_nameContext _localctx = new Namespace_or_type_nameContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_namespace_or_type_name); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(461); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { - case 1: - { - setState(456); - identifier(); - setState(458); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { - case 1: - { - setState(457); - type_argument_list(); - } - break; - } - } - break; - case 2: - { - setState(460); - qualified_alias_member(); - } - break; - } - setState(470); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,8,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(463); - match(DOT); - setState(464); - identifier(); - setState(466); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { - case 1: - { - setState(465); - type_argument_list(); - } - break; - } - } - } - } - setState(472); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,8,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_Context extends ParserRuleContext { - public Base_typeContext base_type() { - return getRuleContext(Base_typeContext.class,0); - } - public List INTERR() { return getTokens(CSharpParser.INTERR); } - public TerminalNode INTERR(int i) { - return getToken(CSharpParser.INTERR, i); - } - public List rank_specifier() { - return getRuleContexts(Rank_specifierContext.class); - } - public Rank_specifierContext rank_specifier(int i) { - return getRuleContext(Rank_specifierContext.class,i); - } - public List STAR() { return getTokens(CSharpParser.STAR); } - public TerminalNode STAR(int i) { - return getToken(CSharpParser.STAR, i); - } - public Type_Context(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_(this); - } - } - - public final Type_Context type_() throws RecognitionException { - Type_Context _localctx = new Type_Context(_ctx, getState()); - enterRule(_localctx, 4, RULE_type_); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(473); - base_type(); - setState(479); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,10,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(477); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INTERR: - { - setState(474); - match(INTERR); - } - break; - case OPEN_BRACKET: - { - setState(475); - rank_specifier(); - } - break; - case STAR: - { - setState(476); - match(STAR); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(481); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,10,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Base_typeContext extends ParserRuleContext { - public Simple_typeContext simple_type() { - return getRuleContext(Simple_typeContext.class,0); - } - public Class_typeContext class_type() { - return getRuleContext(Class_typeContext.class,0); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } - public Tuple_typeContext tuple_type() { - return getRuleContext(Tuple_typeContext.class,0); - } - public Base_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_base_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBase_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBase_type(this); - } - } - - public final Base_typeContext base_type() throws RecognitionException { - Base_typeContext _localctx = new Base_typeContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_base_type); - try { - setState(487); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BOOL: - case BYTE: - case CHAR: - case DECIMAL: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SBYTE: - case SHORT: - case UINT: - case ULONG: - case USHORT: - enterOuterAlt(_localctx, 1); - { - setState(482); - simple_type(); - } - break; - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BY: - case DESCENDING: - case DYNAMIC: - case EQUALS: - case FROM: - case GET: - case GROUP: - case INTO: - case JOIN: - case LET: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SELECT: - case SET: - case STRING: - case UNMANAGED: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - enterOuterAlt(_localctx, 2); - { - setState(483); - class_type(); - } - break; - case VOID: - enterOuterAlt(_localctx, 3); - { - setState(484); - match(VOID); - setState(485); - match(STAR); - } - break; - case OPEN_PARENS: - enterOuterAlt(_localctx, 4); - { - setState(486); - tuple_type(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Tuple_typeContext extends ParserRuleContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public List tuple_element() { - return getRuleContexts(Tuple_elementContext.class); - } - public Tuple_elementContext tuple_element(int i) { - return getRuleContext(Tuple_elementContext.class,i); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Tuple_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_tuple_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTuple_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTuple_type(this); - } - } - - public final Tuple_typeContext tuple_type() throws RecognitionException { - Tuple_typeContext _localctx = new Tuple_typeContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_tuple_type); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(489); - match(OPEN_PARENS); - setState(490); - tuple_element(); - setState(493); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(491); - match(COMMA); - setState(492); - tuple_element(); - } - } - setState(495); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==COMMA ); - setState(497); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Tuple_elementContext extends ParserRuleContext { - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Tuple_elementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_tuple_element; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTuple_element(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTuple_element(this); - } - } - - public final Tuple_elementContext tuple_element() throws RecognitionException { - Tuple_elementContext _localctx = new Tuple_elementContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_tuple_element); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(499); - type_(); - setState(501); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { - { - setState(500); - identifier(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Simple_typeContext extends ParserRuleContext { - public Numeric_typeContext numeric_type() { - return getRuleContext(Numeric_typeContext.class,0); - } - public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } - public Simple_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simple_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSimple_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSimple_type(this); - } - } - - public final Simple_typeContext simple_type() throws RecognitionException { - Simple_typeContext _localctx = new Simple_typeContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_simple_type); - try { - setState(505); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BYTE: - case CHAR: - case DECIMAL: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SBYTE: - case SHORT: - case UINT: - case ULONG: - case USHORT: - enterOuterAlt(_localctx, 1); - { - setState(503); - numeric_type(); - } - break; - case BOOL: - enterOuterAlt(_localctx, 2); - { - setState(504); - match(BOOL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Numeric_typeContext extends ParserRuleContext { - public Integral_typeContext integral_type() { - return getRuleContext(Integral_typeContext.class,0); - } - public Floating_point_typeContext floating_point_type() { - return getRuleContext(Floating_point_typeContext.class,0); - } - public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } - public Numeric_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_numeric_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNumeric_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNumeric_type(this); - } - } - - public final Numeric_typeContext numeric_type() throws RecognitionException { - Numeric_typeContext _localctx = new Numeric_typeContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_numeric_type); - try { - setState(510); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BYTE: - case CHAR: - case INT: - case LONG: - case SBYTE: - case SHORT: - case UINT: - case ULONG: - case USHORT: - enterOuterAlt(_localctx, 1); - { - setState(507); - integral_type(); - } - break; - case DOUBLE: - case FLOAT: - enterOuterAlt(_localctx, 2); - { - setState(508); - floating_point_type(); - } - break; - case DECIMAL: - enterOuterAlt(_localctx, 3); - { - setState(509); - match(DECIMAL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Integral_typeContext extends ParserRuleContext { - public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } - public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } - public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } - public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } - public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } - public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } - public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } - public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } - public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } - public Integral_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_integral_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIntegral_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIntegral_type(this); - } - } - - public final Integral_typeContext integral_type() throws RecognitionException { - Integral_typeContext _localctx = new Integral_typeContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_integral_type); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(512); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG))) != 0) || ((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (SBYTE - 83)) | (1L << (SHORT - 83)) | (1L << (UINT - 83)) | (1L << (ULONG - 83)) | (1L << (USHORT - 83)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Floating_point_typeContext extends ParserRuleContext { - public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } - public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } - public Floating_point_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_floating_point_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFloating_point_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFloating_point_type(this); - } - } - - public final Floating_point_typeContext floating_point_type() throws RecognitionException { - Floating_point_typeContext _localctx = new Floating_point_typeContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_floating_point_type); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(514); - _la = _input.LA(1); - if ( !(_la==DOUBLE || _la==FLOAT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_typeContext extends ParserRuleContext { - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } - public TerminalNode DYNAMIC() { return getToken(CSharpParser.DYNAMIC, 0); } - public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } - public Class_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_type(this); - } - } - - public final Class_typeContext class_type() throws RecognitionException { - Class_typeContext _localctx = new Class_typeContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_class_type); - try { - setState(520); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(516); - namespace_or_type_name(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(517); - match(OBJECT); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(518); - match(DYNAMIC); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(519); - match(STRING); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_argument_listContext extends ParserRuleContext { - public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } - public List type_() { - return getRuleContexts(Type_Context.class); - } - public Type_Context type_(int i) { - return getRuleContext(Type_Context.class,i); - } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Type_argument_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_argument_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_argument_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_argument_list(this); - } - } - - public final Type_argument_listContext type_argument_list() throws RecognitionException { - Type_argument_listContext _localctx = new Type_argument_listContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_type_argument_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(522); - match(LT); - setState(523); - type_(); - setState(528); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(524); - match(COMMA); - setState(525); - type_(); - } - } - setState(530); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(531); - match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Argument_listContext extends ParserRuleContext { - public List argument() { - return getRuleContexts(ArgumentContext.class); - } - public ArgumentContext argument(int i) { - return getRuleContext(ArgumentContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Argument_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_argument_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterArgument_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitArgument_list(this); - } - } - - public final Argument_listContext argument_list() throws RecognitionException { - Argument_listContext _localctx = new Argument_listContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_argument_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(533); - argument(); - setState(538); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(534); - match(COMMA); - setState(535); - argument(); - } - } - setState(540); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ArgumentContext extends ParserRuleContext { - public Token refout; - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public ArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_argument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterArgument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitArgument(this); - } - } - - public final ArgumentContext argument() throws RecognitionException { - ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_argument); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(544); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { - case 1: - { - setState(541); - identifier(); - setState(542); - match(COLON); - } - break; - } - setState(547); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { - case 1: - { - setState(546); - ((ArgumentContext)_localctx).refout = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) ) { - ((ArgumentContext)_localctx).refout = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(551); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) { - case 1: - { - setState(549); - match(VAR); - } - break; - case 2: - { - setState(550); - type_(); - } - break; - } - setState(553); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionContext extends ParserRuleContext { - public AssignmentContext assignment() { - return getRuleContext(AssignmentContext.class,0); - } - public Non_assignment_expressionContext non_assignment_expression() { - return getRuleContext(Non_assignment_expressionContext.class,0); - } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public ExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExpression(this); - } - } - - public final ExpressionContext expression() throws RecognitionException { - ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_expression); - try { - setState(559); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(555); - assignment(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(556); - non_assignment_expression(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(557); - match(REF); - setState(558); - non_assignment_expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Non_assignment_expressionContext extends ParserRuleContext { - public Lambda_expressionContext lambda_expression() { - return getRuleContext(Lambda_expressionContext.class,0); - } - public Query_expressionContext query_expression() { - return getRuleContext(Query_expressionContext.class,0); - } - public Conditional_expressionContext conditional_expression() { - return getRuleContext(Conditional_expressionContext.class,0); - } - public Non_assignment_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_non_assignment_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNon_assignment_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNon_assignment_expression(this); - } - } - - public final Non_assignment_expressionContext non_assignment_expression() throws RecognitionException { - Non_assignment_expressionContext _localctx = new Non_assignment_expressionContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_non_assignment_expression); - try { - setState(564); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(561); - lambda_expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(562); - query_expression(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(563); - conditional_expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentContext extends ParserRuleContext { - public Unary_expressionContext unary_expression() { - return getRuleContext(Unary_expressionContext.class,0); - } - public Assignment_operatorContext assignment_operator() { - return getRuleContext(Assignment_operatorContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode OP_COALESCING_ASSIGNMENT() { return getToken(CSharpParser.OP_COALESCING_ASSIGNMENT, 0); } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public AssignmentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignment; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAssignment(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAssignment(this); - } - } - - public final AssignmentContext assignment() throws RecognitionException { - AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_assignment); - try { - setState(574); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(566); - unary_expression(); - setState(567); - assignment_operator(); - setState(568); - expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(570); - unary_expression(); - setState(571); - match(OP_COALESCING_ASSIGNMENT); - setState(572); - throwable_expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Assignment_operatorContext extends ParserRuleContext { - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public TerminalNode OP_ADD_ASSIGNMENT() { return getToken(CSharpParser.OP_ADD_ASSIGNMENT, 0); } - public TerminalNode OP_SUB_ASSIGNMENT() { return getToken(CSharpParser.OP_SUB_ASSIGNMENT, 0); } - public TerminalNode OP_MULT_ASSIGNMENT() { return getToken(CSharpParser.OP_MULT_ASSIGNMENT, 0); } - public TerminalNode OP_DIV_ASSIGNMENT() { return getToken(CSharpParser.OP_DIV_ASSIGNMENT, 0); } - public TerminalNode OP_MOD_ASSIGNMENT() { return getToken(CSharpParser.OP_MOD_ASSIGNMENT, 0); } - public TerminalNode OP_AND_ASSIGNMENT() { return getToken(CSharpParser.OP_AND_ASSIGNMENT, 0); } - public TerminalNode OP_OR_ASSIGNMENT() { return getToken(CSharpParser.OP_OR_ASSIGNMENT, 0); } - public TerminalNode OP_XOR_ASSIGNMENT() { return getToken(CSharpParser.OP_XOR_ASSIGNMENT, 0); } - public TerminalNode OP_LEFT_SHIFT_ASSIGNMENT() { return getToken(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT, 0); } - public Right_shift_assignmentContext right_shift_assignment() { - return getRuleContext(Right_shift_assignmentContext.class,0); - } - public Assignment_operatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignment_operator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAssignment_operator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAssignment_operator(this); - } - } - - public final Assignment_operatorContext assignment_operator() throws RecognitionException { - Assignment_operatorContext _localctx = new Assignment_operatorContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_assignment_operator); - try { - setState(587); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ASSIGNMENT: - enterOuterAlt(_localctx, 1); - { - setState(576); - match(ASSIGNMENT); - } - break; - case OP_ADD_ASSIGNMENT: - enterOuterAlt(_localctx, 2); - { - setState(577); - match(OP_ADD_ASSIGNMENT); - } - break; - case OP_SUB_ASSIGNMENT: - enterOuterAlt(_localctx, 3); - { - setState(578); - match(OP_SUB_ASSIGNMENT); - } - break; - case OP_MULT_ASSIGNMENT: - enterOuterAlt(_localctx, 4); - { - setState(579); - match(OP_MULT_ASSIGNMENT); - } - break; - case OP_DIV_ASSIGNMENT: - enterOuterAlt(_localctx, 5); - { - setState(580); - match(OP_DIV_ASSIGNMENT); - } - break; - case OP_MOD_ASSIGNMENT: - enterOuterAlt(_localctx, 6); - { - setState(581); - match(OP_MOD_ASSIGNMENT); - } - break; - case OP_AND_ASSIGNMENT: - enterOuterAlt(_localctx, 7); - { - setState(582); - match(OP_AND_ASSIGNMENT); - } - break; - case OP_OR_ASSIGNMENT: - enterOuterAlt(_localctx, 8); - { - setState(583); - match(OP_OR_ASSIGNMENT); - } - break; - case OP_XOR_ASSIGNMENT: - enterOuterAlt(_localctx, 9); - { - setState(584); - match(OP_XOR_ASSIGNMENT); - } - break; - case OP_LEFT_SHIFT_ASSIGNMENT: - enterOuterAlt(_localctx, 10); - { - setState(585); - match(OP_LEFT_SHIFT_ASSIGNMENT); - } - break; - case GT: - enterOuterAlt(_localctx, 11); - { - setState(586); - right_shift_assignment(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Conditional_expressionContext extends ParserRuleContext { - public Null_coalescing_expressionContext null_coalescing_expression() { - return getRuleContext(Null_coalescing_expressionContext.class,0); - } - public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } - public List throwable_expression() { - return getRuleContexts(Throwable_expressionContext.class); - } - public Throwable_expressionContext throwable_expression(int i) { - return getRuleContext(Throwable_expressionContext.class,i); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Conditional_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conditional_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConditional_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConditional_expression(this); - } - } - - public final Conditional_expressionContext conditional_expression() throws RecognitionException { - Conditional_expressionContext _localctx = new Conditional_expressionContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_conditional_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(589); - null_coalescing_expression(); - setState(595); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { - case 1: - { - setState(590); - match(INTERR); - setState(591); - throwable_expression(); - setState(592); - match(COLON); - setState(593); - throwable_expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Null_coalescing_expressionContext extends ParserRuleContext { - public Conditional_or_expressionContext conditional_or_expression() { - return getRuleContext(Conditional_or_expressionContext.class,0); - } - public TerminalNode OP_COALESCING() { return getToken(CSharpParser.OP_COALESCING, 0); } - public Null_coalescing_expressionContext null_coalescing_expression() { - return getRuleContext(Null_coalescing_expressionContext.class,0); - } - public Throw_expressionContext throw_expression() { - return getRuleContext(Throw_expressionContext.class,0); - } - public Null_coalescing_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_null_coalescing_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNull_coalescing_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNull_coalescing_expression(this); - } - } - - public final Null_coalescing_expressionContext null_coalescing_expression() throws RecognitionException { - Null_coalescing_expressionContext _localctx = new Null_coalescing_expressionContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_null_coalescing_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(597); - conditional_or_expression(); - setState(603); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OP_COALESCING) { - { - setState(598); - match(OP_COALESCING); - setState(601); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - { - setState(599); - null_coalescing_expression(); - } - break; - case THROW: - { - setState(600); - throw_expression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Conditional_or_expressionContext extends ParserRuleContext { - public List conditional_and_expression() { - return getRuleContexts(Conditional_and_expressionContext.class); - } - public Conditional_and_expressionContext conditional_and_expression(int i) { - return getRuleContext(Conditional_and_expressionContext.class,i); - } - public List OP_OR() { return getTokens(CSharpParser.OP_OR); } - public TerminalNode OP_OR(int i) { - return getToken(CSharpParser.OP_OR, i); - } - public Conditional_or_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conditional_or_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConditional_or_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConditional_or_expression(this); - } - } - - public final Conditional_or_expressionContext conditional_or_expression() throws RecognitionException { - Conditional_or_expressionContext _localctx = new Conditional_or_expressionContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_conditional_or_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(605); - conditional_and_expression(); - setState(610); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==OP_OR) { - { - { - setState(606); - match(OP_OR); - setState(607); - conditional_and_expression(); - } - } - setState(612); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Conditional_and_expressionContext extends ParserRuleContext { - public List inclusive_or_expression() { - return getRuleContexts(Inclusive_or_expressionContext.class); - } - public Inclusive_or_expressionContext inclusive_or_expression(int i) { - return getRuleContext(Inclusive_or_expressionContext.class,i); - } - public List OP_AND() { return getTokens(CSharpParser.OP_AND); } - public TerminalNode OP_AND(int i) { - return getToken(CSharpParser.OP_AND, i); - } - public Conditional_and_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conditional_and_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConditional_and_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConditional_and_expression(this); - } - } - - public final Conditional_and_expressionContext conditional_and_expression() throws RecognitionException { - Conditional_and_expressionContext _localctx = new Conditional_and_expressionContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_conditional_and_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(613); - inclusive_or_expression(); - setState(618); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==OP_AND) { - { - { - setState(614); - match(OP_AND); - setState(615); - inclusive_or_expression(); - } - } - setState(620); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Inclusive_or_expressionContext extends ParserRuleContext { - public List exclusive_or_expression() { - return getRuleContexts(Exclusive_or_expressionContext.class); - } - public Exclusive_or_expressionContext exclusive_or_expression(int i) { - return getRuleContext(Exclusive_or_expressionContext.class,i); - } - public List BITWISE_OR() { return getTokens(CSharpParser.BITWISE_OR); } - public TerminalNode BITWISE_OR(int i) { - return getToken(CSharpParser.BITWISE_OR, i); - } - public Inclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_inclusive_or_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInclusive_or_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInclusive_or_expression(this); - } - } - - public final Inclusive_or_expressionContext inclusive_or_expression() throws RecognitionException { - Inclusive_or_expressionContext _localctx = new Inclusive_or_expressionContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_inclusive_or_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(621); - exclusive_or_expression(); - setState(626); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==BITWISE_OR) { - { - { - setState(622); - match(BITWISE_OR); - setState(623); - exclusive_or_expression(); - } - } - setState(628); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Exclusive_or_expressionContext extends ParserRuleContext { - public List and_expression() { - return getRuleContexts(And_expressionContext.class); - } - public And_expressionContext and_expression(int i) { - return getRuleContext(And_expressionContext.class,i); - } - public List CARET() { return getTokens(CSharpParser.CARET); } - public TerminalNode CARET(int i) { - return getToken(CSharpParser.CARET, i); - } - public Exclusive_or_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_exclusive_or_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExclusive_or_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExclusive_or_expression(this); - } - } - - public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException { - Exclusive_or_expressionContext _localctx = new Exclusive_or_expressionContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_exclusive_or_expression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(629); - and_expression(); - setState(634); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,32,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(630); - match(CARET); - setState(631); - and_expression(); - } - } - } - setState(636); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,32,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class And_expressionContext extends ParserRuleContext { - public List equality_expression() { - return getRuleContexts(Equality_expressionContext.class); - } - public Equality_expressionContext equality_expression(int i) { - return getRuleContext(Equality_expressionContext.class,i); - } - public List AMP() { return getTokens(CSharpParser.AMP); } - public TerminalNode AMP(int i) { - return getToken(CSharpParser.AMP, i); - } - public And_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_and_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAnd_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAnd_expression(this); - } - } - - public final And_expressionContext and_expression() throws RecognitionException { - And_expressionContext _localctx = new And_expressionContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_and_expression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(637); - equality_expression(); - setState(642); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,33,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(638); - match(AMP); - setState(639); - equality_expression(); - } - } - } - setState(644); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,33,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Equality_expressionContext extends ParserRuleContext { - public List relational_expression() { - return getRuleContexts(Relational_expressionContext.class); - } - public Relational_expressionContext relational_expression(int i) { - return getRuleContext(Relational_expressionContext.class,i); - } - public List OP_EQ() { return getTokens(CSharpParser.OP_EQ); } - public TerminalNode OP_EQ(int i) { - return getToken(CSharpParser.OP_EQ, i); - } - public List OP_NE() { return getTokens(CSharpParser.OP_NE); } - public TerminalNode OP_NE(int i) { - return getToken(CSharpParser.OP_NE, i); - } - public Equality_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_equality_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEquality_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEquality_expression(this); - } - } - - public final Equality_expressionContext equality_expression() throws RecognitionException { - Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_equality_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(645); - relational_expression(); - setState(650); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==OP_EQ || _la==OP_NE) { - { - { - setState(646); - _la = _input.LA(1); - if ( !(_la==OP_EQ || _la==OP_NE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(647); - relational_expression(); - } - } - setState(652); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Relational_expressionContext extends ParserRuleContext { - public List shift_expression() { - return getRuleContexts(Shift_expressionContext.class); - } - public Shift_expressionContext shift_expression(int i) { - return getRuleContext(Shift_expressionContext.class,i); - } - public List IS() { return getTokens(CSharpParser.IS); } - public TerminalNode IS(int i) { - return getToken(CSharpParser.IS, i); - } - public List isType() { - return getRuleContexts(IsTypeContext.class); - } - public IsTypeContext isType(int i) { - return getRuleContext(IsTypeContext.class,i); - } - public List AS() { return getTokens(CSharpParser.AS); } - public TerminalNode AS(int i) { - return getToken(CSharpParser.AS, i); - } - public List type_() { - return getRuleContexts(Type_Context.class); - } - public Type_Context type_(int i) { - return getRuleContext(Type_Context.class,i); - } - public List LT() { return getTokens(CSharpParser.LT); } - public TerminalNode LT(int i) { - return getToken(CSharpParser.LT, i); - } - public List GT() { return getTokens(CSharpParser.GT); } - public TerminalNode GT(int i) { - return getToken(CSharpParser.GT, i); - } - public List OP_LE() { return getTokens(CSharpParser.OP_LE); } - public TerminalNode OP_LE(int i) { - return getToken(CSharpParser.OP_LE, i); - } - public List OP_GE() { return getTokens(CSharpParser.OP_GE); } - public TerminalNode OP_GE(int i) { - return getToken(CSharpParser.OP_GE, i); - } - public Relational_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_relational_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRelational_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRelational_expression(this); - } - } - - public final Relational_expressionContext relational_expression() throws RecognitionException { - Relational_expressionContext _localctx = new Relational_expressionContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_relational_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(653); - shift_expression(); - setState(662); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AS || _la==IS || ((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & ((1L << (LT - 146)) | (1L << (GT - 146)) | (1L << (OP_LE - 146)) | (1L << (OP_GE - 146)))) != 0)) { - { - setState(660); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LT: - case GT: - case OP_LE: - case OP_GE: - { - setState(654); - _la = _input.LA(1); - if ( !(((((_la - 146)) & ~0x3f) == 0 && ((1L << (_la - 146)) & ((1L << (LT - 146)) | (1L << (GT - 146)) | (1L << (OP_LE - 146)) | (1L << (OP_GE - 146)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(655); - shift_expression(); - } - break; - case IS: - { - setState(656); - match(IS); - setState(657); - isType(); - } - break; - case AS: - { - setState(658); - match(AS); - setState(659); - type_(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(664); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Shift_expressionContext extends ParserRuleContext { - public List additive_expression() { - return getRuleContexts(Additive_expressionContext.class); - } - public Additive_expressionContext additive_expression(int i) { - return getRuleContext(Additive_expressionContext.class,i); - } - public List OP_LEFT_SHIFT() { return getTokens(CSharpParser.OP_LEFT_SHIFT); } - public TerminalNode OP_LEFT_SHIFT(int i) { - return getToken(CSharpParser.OP_LEFT_SHIFT, i); - } - public List right_shift() { - return getRuleContexts(Right_shiftContext.class); - } - public Right_shiftContext right_shift(int i) { - return getRuleContext(Right_shiftContext.class,i); - } - public Shift_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_shift_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterShift_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitShift_expression(this); - } - } - - public final Shift_expressionContext shift_expression() throws RecognitionException { - Shift_expressionContext _localctx = new Shift_expressionContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_shift_expression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(665); - additive_expression(); - setState(673); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,38,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(668); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OP_LEFT_SHIFT: - { - setState(666); - match(OP_LEFT_SHIFT); - } - break; - case GT: - { - setState(667); - right_shift(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(670); - additive_expression(); - } - } - } - setState(675); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,38,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Additive_expressionContext extends ParserRuleContext { - public List multiplicative_expression() { - return getRuleContexts(Multiplicative_expressionContext.class); - } - public Multiplicative_expressionContext multiplicative_expression(int i) { - return getRuleContext(Multiplicative_expressionContext.class,i); - } - public List PLUS() { return getTokens(CSharpParser.PLUS); } - public TerminalNode PLUS(int i) { - return getToken(CSharpParser.PLUS, i); - } - public List MINUS() { return getTokens(CSharpParser.MINUS); } - public TerminalNode MINUS(int i) { - return getToken(CSharpParser.MINUS, i); - } - public Additive_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_additive_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAdditive_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAdditive_expression(this); - } - } - - public final Additive_expressionContext additive_expression() throws RecognitionException { - Additive_expressionContext _localctx = new Additive_expressionContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_additive_expression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(676); - multiplicative_expression(); - setState(681); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,39,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(677); - _la = _input.LA(1); - if ( !(_la==PLUS || _la==MINUS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(678); - multiplicative_expression(); - } - } - } - setState(683); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,39,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Multiplicative_expressionContext extends ParserRuleContext { - public List switch_expression() { - return getRuleContexts(Switch_expressionContext.class); - } - public Switch_expressionContext switch_expression(int i) { - return getRuleContext(Switch_expressionContext.class,i); - } - public List STAR() { return getTokens(CSharpParser.STAR); } - public TerminalNode STAR(int i) { - return getToken(CSharpParser.STAR, i); - } - public List DIV() { return getTokens(CSharpParser.DIV); } - public TerminalNode DIV(int i) { - return getToken(CSharpParser.DIV, i); - } - public List PERCENT() { return getTokens(CSharpParser.PERCENT); } - public TerminalNode PERCENT(int i) { - return getToken(CSharpParser.PERCENT, i); - } - public Multiplicative_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiplicative_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMultiplicative_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMultiplicative_expression(this); - } - } - - public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException { - Multiplicative_expressionContext _localctx = new Multiplicative_expressionContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_multiplicative_expression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(684); - switch_expression(); - setState(689); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,40,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(685); - _la = _input.LA(1); - if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (STAR - 137)) | (1L << (DIV - 137)) | (1L << (PERCENT - 137)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(686); - switch_expression(); - } - } - } - setState(691); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,40,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Switch_expressionContext extends ParserRuleContext { - public Range_expressionContext range_expression() { - return getRuleContext(Range_expressionContext.class,0); - } - public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Switch_expression_armsContext switch_expression_arms() { - return getRuleContext(Switch_expression_armsContext.class,0); - } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Switch_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switch_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitch_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitch_expression(this); - } - } - - public final Switch_expressionContext switch_expression() throws RecognitionException { - Switch_expressionContext _localctx = new Switch_expressionContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_switch_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(692); - range_expression(); - setState(702); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SWITCH) { - { - setState(693); - match(SWITCH); - setState(694); - match(OPEN_BRACE); - setState(699); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(695); - switch_expression_arms(); - setState(697); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(696); - match(COMMA); - } - } - - } - } - - setState(701); - match(CLOSE_BRACE); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Switch_expression_armsContext extends ParserRuleContext { - public List switch_expression_arm() { - return getRuleContexts(Switch_expression_armContext.class); - } - public Switch_expression_armContext switch_expression_arm(int i) { - return getRuleContext(Switch_expression_armContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Switch_expression_armsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switch_expression_arms; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitch_expression_arms(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitch_expression_arms(this); - } - } - - public final Switch_expression_armsContext switch_expression_arms() throws RecognitionException { - Switch_expression_armsContext _localctx = new Switch_expression_armsContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_switch_expression_arms); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(704); - switch_expression_arm(); - setState(709); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,44,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(705); - match(COMMA); - setState(706); - switch_expression_arm(); - } - } - } - setState(711); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,44,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Switch_expression_armContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public Case_guardContext case_guard() { - return getRuleContext(Case_guardContext.class,0); - } - public Switch_expression_armContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switch_expression_arm; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitch_expression_arm(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitch_expression_arm(this); - } - } - - public final Switch_expression_armContext switch_expression_arm() throws RecognitionException { - Switch_expression_armContext _localctx = new Switch_expression_armContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_switch_expression_arm); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(712); - expression(); - setState(714); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHEN) { - { - setState(713); - case_guard(); - } - } - - setState(716); - right_arrow(); - setState(717); - throwable_expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Range_expressionContext extends ParserRuleContext { - public List unary_expression() { - return getRuleContexts(Unary_expressionContext.class); - } - public Unary_expressionContext unary_expression(int i) { - return getRuleContext(Unary_expressionContext.class,i); - } - public TerminalNode OP_RANGE() { return getToken(CSharpParser.OP_RANGE, 0); } - public Range_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_range_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRange_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRange_expression(this); - } - } - - public final Range_expressionContext range_expression() throws RecognitionException { - Range_expressionContext _localctx = new Range_expressionContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_range_expression); - int _la; - try { - setState(727); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(719); - unary_expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(721); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)))) != 0)) { - { - setState(720); - unary_expression(); - } - } - - setState(723); - match(OP_RANGE); - setState(725); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { - case 1: - { - setState(724); - unary_expression(); - } - break; - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Unary_expressionContext extends ParserRuleContext { - public Primary_expressionContext primary_expression() { - return getRuleContext(Primary_expressionContext.class,0); - } - public TerminalNode PLUS() { return getToken(CSharpParser.PLUS, 0); } - public Unary_expressionContext unary_expression() { - return getRuleContext(Unary_expressionContext.class,0); - } - public TerminalNode MINUS() { return getToken(CSharpParser.MINUS, 0); } - public TerminalNode BANG() { return getToken(CSharpParser.BANG, 0); } - public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } - public TerminalNode OP_INC() { return getToken(CSharpParser.OP_INC, 0); } - public TerminalNode OP_DEC() { return getToken(CSharpParser.OP_DEC, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } - public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } - public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } - public TerminalNode CARET() { return getToken(CSharpParser.CARET, 0); } - public Unary_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unary_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUnary_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUnary_expression(this); - } - } - - public final Unary_expressionContext unary_expression() throws RecognitionException { - Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_unary_expression); - try { - setState(755); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(729); - primary_expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(730); - match(PLUS); - setState(731); - unary_expression(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(732); - match(MINUS); - setState(733); - unary_expression(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(734); - match(BANG); - setState(735); - unary_expression(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(736); - match(TILDE); - setState(737); - unary_expression(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(738); - match(OP_INC); - setState(739); - unary_expression(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(740); - match(OP_DEC); - setState(741); - unary_expression(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(742); - match(OPEN_PARENS); - setState(743); - type_(); - setState(744); - match(CLOSE_PARENS); - setState(745); - unary_expression(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(747); - match(AWAIT); - setState(748); - unary_expression(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(749); - match(AMP); - setState(750); - unary_expression(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(751); - match(STAR); - setState(752); - unary_expression(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(753); - match(CARET); - setState(754); - unary_expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Primary_expressionContext extends ParserRuleContext { - public Primary_expression_startContext pe; - public Primary_expression_startContext primary_expression_start() { - return getRuleContext(Primary_expression_startContext.class,0); - } - public List BANG() { return getTokens(CSharpParser.BANG); } - public TerminalNode BANG(int i) { - return getToken(CSharpParser.BANG, i); - } - public List bracket_expression() { - return getRuleContexts(Bracket_expressionContext.class); - } - public Bracket_expressionContext bracket_expression(int i) { - return getRuleContext(Bracket_expressionContext.class,i); - } - public List member_access() { - return getRuleContexts(Member_accessContext.class); - } - public Member_accessContext member_access(int i) { - return getRuleContext(Member_accessContext.class,i); - } - public List method_invocation() { - return getRuleContexts(Method_invocationContext.class); - } - public Method_invocationContext method_invocation(int i) { - return getRuleContext(Method_invocationContext.class,i); - } - public List OP_INC() { return getTokens(CSharpParser.OP_INC); } - public TerminalNode OP_INC(int i) { - return getToken(CSharpParser.OP_INC, i); - } - public List OP_DEC() { return getTokens(CSharpParser.OP_DEC); } - public TerminalNode OP_DEC(int i) { - return getToken(CSharpParser.OP_DEC, i); - } - public List OP_PTR() { return getTokens(CSharpParser.OP_PTR); } - public TerminalNode OP_PTR(int i) { - return getToken(CSharpParser.OP_PTR, i); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Primary_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primary_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterPrimary_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitPrimary_expression(this); - } - } - - public final Primary_expressionContext primary_expression() throws RecognitionException { - Primary_expressionContext _localctx = new Primary_expressionContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_primary_expression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(757); - ((Primary_expressionContext)_localctx).pe = primary_expression_start(); - setState(759); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { - case 1: - { - setState(758); - match(BANG); - } - break; - } - setState(764); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(761); - bracket_expression(); - } - } - } - setState(766); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - } - setState(768); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { - case 1: - { - setState(767); - match(BANG); - } - break; - } - setState(792); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,57,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - { - setState(776); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DOT: - case INTERR: - { - setState(770); - member_access(); - } - break; - case OPEN_PARENS: - { - setState(771); - method_invocation(); - } - break; - case OP_INC: - { - setState(772); - match(OP_INC); - } - break; - case OP_DEC: - { - setState(773); - match(OP_DEC); - } - break; - case OP_PTR: - { - setState(774); - match(OP_PTR); - setState(775); - identifier(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(779); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { - case 1: - { - setState(778); - match(BANG); - } - break; - } - } - setState(784); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,55,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(781); - bracket_expression(); - } - } - } - setState(786); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,55,_ctx); - } - setState(788); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) { - case 1: - { - setState(787); - match(BANG); - } - break; - } - } - } - } - setState(794); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,57,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Primary_expression_startContext extends ParserRuleContext { - public Primary_expression_startContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primary_expression_start; } - - public Primary_expression_startContext() { } - public void copyFrom(Primary_expression_startContext ctx) { - super.copyFrom(ctx); - } - } - public static class LiteralAccessExpressionContext extends Primary_expression_startContext { - public TerminalNode LITERAL_ACCESS() { return getToken(CSharpParser.LITERAL_ACCESS, 0); } - public LiteralAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLiteralAccessExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLiteralAccessExpression(this); - } - } - public static class DefaultValueExpressionContext extends Primary_expression_startContext { - public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public DefaultValueExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterDefaultValueExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitDefaultValueExpression(this); - } - } - public static class BaseAccessExpressionContext extends Primary_expression_startContext { - public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } - public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Expression_listContext expression_list() { - return getRuleContext(Expression_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public Type_argument_listContext type_argument_list() { - return getRuleContext(Type_argument_listContext.class,0); - } - public BaseAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBaseAccessExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBaseAccessExpression(this); - } - } - public static class SizeofExpressionContext extends Primary_expression_startContext { - public TerminalNode SIZEOF() { return getToken(CSharpParser.SIZEOF, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public SizeofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSizeofExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSizeofExpression(this); - } - } - public static class ParenthesisExpressionsContext extends Primary_expression_startContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public ParenthesisExpressionsContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterParenthesisExpressions(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitParenthesisExpressions(this); - } - } - public static class ThisReferenceExpressionContext extends Primary_expression_startContext { - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public ThisReferenceExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterThisReferenceExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitThisReferenceExpression(this); - } - } - public static class ObjectCreationExpressionContext extends Primary_expression_startContext { - public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Anonymous_object_initializerContext anonymous_object_initializer() { - return getRuleContext(Anonymous_object_initializerContext.class,0); - } - public List rank_specifier() { - return getRuleContexts(Rank_specifierContext.class); - } - public Rank_specifierContext rank_specifier(int i) { - return getRuleContext(Rank_specifierContext.class,i); - } - public Array_initializerContext array_initializer() { - return getRuleContext(Array_initializerContext.class,0); - } - public Object_creation_expressionContext object_creation_expression() { - return getRuleContext(Object_creation_expressionContext.class,0); - } - public Object_or_collection_initializerContext object_or_collection_initializer() { - return getRuleContext(Object_or_collection_initializerContext.class,0); - } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Expression_listContext expression_list() { - return getRuleContext(Expression_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public ObjectCreationExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterObjectCreationExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitObjectCreationExpression(this); - } - } - public static class AnonymousMethodExpressionContext extends Primary_expression_startContext { - public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { - return getRuleContext(Explicit_anonymous_function_parameter_listContext.class,0); - } - public AnonymousMethodExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAnonymousMethodExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAnonymousMethodExpression(this); - } - } - public static class TypeofExpressionContext extends Primary_expression_startContext { - public TerminalNode TYPEOF() { return getToken(CSharpParser.TYPEOF, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Unbound_type_nameContext unbound_type_name() { - return getRuleContext(Unbound_type_nameContext.class,0); - } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public TypeofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTypeofExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTypeofExpression(this); - } - } - public static class TupleExpressionContext extends Primary_expression_startContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public List argument() { - return getRuleContexts(ArgumentContext.class); - } - public ArgumentContext argument(int i) { - return getRuleContext(ArgumentContext.class,i); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public TupleExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTupleExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTupleExpression(this); - } - } - public static class UncheckedExpressionContext extends Primary_expression_startContext { - public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public UncheckedExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUncheckedExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUncheckedExpression(this); - } - } - public static class SimpleNameExpressionContext extends Primary_expression_startContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Type_argument_listContext type_argument_list() { - return getRuleContext(Type_argument_listContext.class,0); - } - public SimpleNameExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSimpleNameExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSimpleNameExpression(this); - } - } - public static class MemberAccessExpressionContext extends Primary_expression_startContext { - public Predefined_typeContext predefined_type() { - return getRuleContext(Predefined_typeContext.class,0); - } - public Qualified_alias_memberContext qualified_alias_member() { - return getRuleContext(Qualified_alias_memberContext.class,0); - } - public MemberAccessExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMemberAccessExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMemberAccessExpression(this); - } - } - public static class CheckedExpressionContext extends Primary_expression_startContext { - public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public CheckedExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCheckedExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCheckedExpression(this); - } - } - public static class LiteralExpressionContext extends Primary_expression_startContext { - public LiteralContext literal() { - return getRuleContext(LiteralContext.class,0); - } - public LiteralExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLiteralExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLiteralExpression(this); - } - } - public static class NameofExpressionContext extends Primary_expression_startContext { - public TerminalNode NAMEOF() { return getToken(CSharpParser.NAMEOF, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public List DOT() { return getTokens(CSharpParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(CSharpParser.DOT, i); - } - public NameofExpressionContext(Primary_expression_startContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNameofExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNameofExpression(this); - } - } - - public final Primary_expression_startContext primary_expression_start() throws RecognitionException { - Primary_expression_startContext _localctx = new Primary_expression_startContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_primary_expression_start); - int _la; - try { - int _alt; - setState(916); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { - case 1: - _localctx = new LiteralExpressionContext(_localctx); - enterOuterAlt(_localctx, 1); - { - setState(795); - literal(); - } - break; - case 2: - _localctx = new SimpleNameExpressionContext(_localctx); - enterOuterAlt(_localctx, 2); - { - setState(796); - identifier(); - setState(798); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { - case 1: - { - setState(797); - type_argument_list(); - } - break; - } - } - break; - case 3: - _localctx = new ParenthesisExpressionsContext(_localctx); - enterOuterAlt(_localctx, 3); - { - setState(800); - match(OPEN_PARENS); - setState(801); - expression(); - setState(802); - match(CLOSE_PARENS); - } - break; - case 4: - _localctx = new MemberAccessExpressionContext(_localctx); - enterOuterAlt(_localctx, 4); - { - setState(804); - predefined_type(); - } - break; - case 5: - _localctx = new MemberAccessExpressionContext(_localctx); - enterOuterAlt(_localctx, 5); - { - setState(805); - qualified_alias_member(); - } - break; - case 6: - _localctx = new LiteralAccessExpressionContext(_localctx); - enterOuterAlt(_localctx, 6); - { - setState(806); - match(LITERAL_ACCESS); - } - break; - case 7: - _localctx = new ThisReferenceExpressionContext(_localctx); - enterOuterAlt(_localctx, 7); - { - setState(807); - match(THIS); - } - break; - case 8: - _localctx = new BaseAccessExpressionContext(_localctx); - enterOuterAlt(_localctx, 8); - { - setState(808); - match(BASE); - setState(818); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DOT: - { - setState(809); - match(DOT); - setState(810); - identifier(); - setState(812); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) { - case 1: - { - setState(811); - type_argument_list(); - } - break; - } - } - break; - case OPEN_BRACKET: - { - setState(814); - match(OPEN_BRACKET); - setState(815); - expression_list(); - setState(816); - match(CLOSE_BRACKET); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 9: - _localctx = new ObjectCreationExpressionContext(_localctx); - enterOuterAlt(_localctx, 9); - { - setState(820); - match(NEW); - setState(849); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BOOL: - case BY: - case BYTE: - case CHAR: - case DECIMAL: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case STRING: - case UINT: - case ULONG: - case UNMANAGED: - case USHORT: - case VAR: - case VOID: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case OPEN_PARENS: - { - setState(821); - type_(); - setState(843); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { - case 1: - { - setState(822); - object_creation_expression(); - } - break; - case 2: - { - setState(823); - object_or_collection_initializer(); - } - break; - case 3: - { - setState(824); - match(OPEN_BRACKET); - setState(825); - expression_list(); - setState(826); - match(CLOSE_BRACKET); - setState(830); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,61,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(827); - rank_specifier(); - } - } - } - setState(832); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,61,_ctx); - } - setState(834); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACE) { - { - setState(833); - array_initializer(); - } - } - - } - break; - case 4: - { - setState(837); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(836); - rank_specifier(); - } - } - setState(839); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==OPEN_BRACKET ); - setState(841); - array_initializer(); - } - break; - } - } - break; - case OPEN_BRACE: - { - setState(845); - anonymous_object_initializer(); - } - break; - case OPEN_BRACKET: - { - setState(846); - rank_specifier(); - setState(847); - array_initializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 10: - _localctx = new TupleExpressionContext(_localctx); - enterOuterAlt(_localctx, 10); - { - setState(851); - match(OPEN_PARENS); - setState(852); - argument(); - setState(855); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(853); - match(COMMA); - setState(854); - argument(); - } - } - setState(857); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==COMMA ); - setState(859); - match(CLOSE_PARENS); - } - break; - case 11: - _localctx = new TypeofExpressionContext(_localctx); - enterOuterAlt(_localctx, 11); - { - setState(861); - match(TYPEOF); - setState(862); - match(OPEN_PARENS); - setState(866); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { - case 1: - { - setState(863); - unbound_type_name(); - } - break; - case 2: - { - setState(864); - type_(); - } - break; - case 3: - { - setState(865); - match(VOID); - } - break; - } - setState(868); - match(CLOSE_PARENS); - } - break; - case 12: - _localctx = new CheckedExpressionContext(_localctx); - enterOuterAlt(_localctx, 12); - { - setState(869); - match(CHECKED); - setState(870); - match(OPEN_PARENS); - setState(871); - expression(); - setState(872); - match(CLOSE_PARENS); - } - break; - case 13: - _localctx = new UncheckedExpressionContext(_localctx); - enterOuterAlt(_localctx, 13); - { - setState(874); - match(UNCHECKED); - setState(875); - match(OPEN_PARENS); - setState(876); - expression(); - setState(877); - match(CLOSE_PARENS); - } - break; - case 14: - _localctx = new DefaultValueExpressionContext(_localctx); - enterOuterAlt(_localctx, 14); - { - setState(879); - match(DEFAULT); - setState(884); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { - case 1: - { - setState(880); - match(OPEN_PARENS); - setState(881); - type_(); - setState(882); - match(CLOSE_PARENS); - } - break; - } - } - break; - case 15: - _localctx = new AnonymousMethodExpressionContext(_localctx); - enterOuterAlt(_localctx, 15); - { - setState(887); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASYNC) { - { - setState(886); - match(ASYNC); - } - } - - setState(889); - match(DELEGATE); - setState(895); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PARENS) { - { - setState(890); - match(OPEN_PARENS); - setState(892); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REF - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { - { - setState(891); - explicit_anonymous_function_parameter_list(); - } - } - - setState(894); - match(CLOSE_PARENS); - } - } - - setState(897); - block(); - } - break; - case 16: - _localctx = new SizeofExpressionContext(_localctx); - enterOuterAlt(_localctx, 16); - { - setState(898); - match(SIZEOF); - setState(899); - match(OPEN_PARENS); - setState(900); - type_(); - setState(901); - match(CLOSE_PARENS); - } - break; - case 17: - _localctx = new NameofExpressionContext(_localctx); - enterOuterAlt(_localctx, 17); - { - setState(903); - match(NAMEOF); - setState(904); - match(OPEN_PARENS); - setState(910); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,72,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(905); - identifier(); - setState(906); - match(DOT); - } - } - } - setState(912); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,72,_ctx); - } - setState(913); - identifier(); - setState(914); - match(CLOSE_PARENS); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Throwable_expressionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Throw_expressionContext throw_expression() { - return getRuleContext(Throw_expressionContext.class,0); - } - public Throwable_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_throwable_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterThrowable_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitThrowable_expression(this); - } - } - - public final Throwable_expressionContext throwable_expression() throws RecognitionException { - Throwable_expressionContext _localctx = new Throwable_expressionContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_throwable_expression); - try { - setState(920); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(918); - expression(); - } - break; - case THROW: - enterOuterAlt(_localctx, 2); - { - setState(919); - throw_expression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Throw_expressionContext extends ParserRuleContext { - public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Throw_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_throw_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterThrow_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitThrow_expression(this); - } - } - - public final Throw_expressionContext throw_expression() throws RecognitionException { - Throw_expressionContext _localctx = new Throw_expressionContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_throw_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(922); - match(THROW); - setState(923); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_accessContext extends ParserRuleContext { - public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } - public Type_argument_listContext type_argument_list() { - return getRuleContext(Type_argument_listContext.class,0); - } - public Member_accessContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_access; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_access(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_access(this); - } - } - - public final Member_accessContext member_access() throws RecognitionException { - Member_accessContext _localctx = new Member_accessContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_member_access); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(926); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTERR) { - { - setState(925); - match(INTERR); - } - } - - setState(928); - match(DOT); - setState(929); - identifier(); - setState(931); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { - case 1: - { - setState(930); - type_argument_list(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Bracket_expressionContext extends ParserRuleContext { - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public List indexer_argument() { - return getRuleContexts(Indexer_argumentContext.class); - } - public Indexer_argumentContext indexer_argument(int i) { - return getRuleContext(Indexer_argumentContext.class,i); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Bracket_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_bracket_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBracket_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBracket_expression(this); - } - } - - public final Bracket_expressionContext bracket_expression() throws RecognitionException { - Bracket_expressionContext _localctx = new Bracket_expressionContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_bracket_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(934); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTERR) { - { - setState(933); - match(INTERR); - } - } - - setState(936); - match(OPEN_BRACKET); - setState(937); - indexer_argument(); - setState(942); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(938); - match(COMMA); - setState(939); - indexer_argument(); - } - } - setState(944); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(945); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Indexer_argumentContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Indexer_argumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_indexer_argument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIndexer_argument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIndexer_argument(this); - } - } - - public final Indexer_argumentContext indexer_argument() throws RecognitionException { - Indexer_argumentContext _localctx = new Indexer_argumentContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_indexer_argument); - try { - enterOuterAlt(_localctx, 1); - { - setState(950); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { - case 1: - { - setState(947); - identifier(); - setState(948); - match(COLON); - } - break; - } - setState(952); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Predefined_typeContext extends ParserRuleContext { - public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } - public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } - public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } - public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } - public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } - public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } - public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } - public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } - public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } - public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } - public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } - public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } - public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } - public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } - public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } - public Predefined_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_predefined_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterPredefined_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitPredefined_type(this); - } - } - - public final Predefined_typeContext predefined_type() throws RecognitionException { - Predefined_typeContext _localctx = new Predefined_typeContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_predefined_type); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(954); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOL) | (1L << BYTE) | (1L << CHAR) | (1L << DECIMAL) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (OBJECT - 68)) | (1L << (SBYTE - 68)) | (1L << (SHORT - 68)) | (1L << (STRING - 68)) | (1L << (UINT - 68)) | (1L << (ULONG - 68)) | (1L << (USHORT - 68)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Expression_listContext extends ParserRuleContext { - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Expression_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_expression_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExpression_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExpression_list(this); - } - } - - public final Expression_listContext expression_list() throws RecognitionException { - Expression_listContext _localctx = new Expression_listContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_expression_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(956); - expression(); - setState(961); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(957); - match(COMMA); - setState(958); - expression(); - } - } - setState(963); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Object_or_collection_initializerContext extends ParserRuleContext { - public Object_initializerContext object_initializer() { - return getRuleContext(Object_initializerContext.class,0); - } - public Collection_initializerContext collection_initializer() { - return getRuleContext(Collection_initializerContext.class,0); - } - public Object_or_collection_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_object_or_collection_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterObject_or_collection_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitObject_or_collection_initializer(this); - } - } - - public final Object_or_collection_initializerContext object_or_collection_initializer() throws RecognitionException { - Object_or_collection_initializerContext _localctx = new Object_or_collection_initializerContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_object_or_collection_initializer); - try { - setState(966); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(964); - object_initializer(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(965); - collection_initializer(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Object_initializerContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Member_initializer_listContext member_initializer_list() { - return getRuleContext(Member_initializer_listContext.class,0); - } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Object_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_object_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterObject_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitObject_initializer(this); - } - } - - public final Object_initializerContext object_initializer() throws RecognitionException { - Object_initializerContext _localctx = new Object_initializerContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_object_initializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(968); - match(OPEN_BRACE); - setState(973); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0)) { - { - setState(969); - member_initializer_list(); - setState(971); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(970); - match(COMMA); - } - } - - } - } - - setState(975); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_initializer_listContext extends ParserRuleContext { - public List member_initializer() { - return getRuleContexts(Member_initializerContext.class); - } - public Member_initializerContext member_initializer(int i) { - return getRuleContext(Member_initializerContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Member_initializer_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_initializer_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_initializer_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_initializer_list(this); - } - } - - public final Member_initializer_listContext member_initializer_list() throws RecognitionException { - Member_initializer_listContext _localctx = new Member_initializer_listContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_member_initializer_list); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(977); - member_initializer(); - setState(982); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,84,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(978); - match(COMMA); - setState(979); - member_initializer(); - } - } - } - setState(984); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,84,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_initializerContext extends ParserRuleContext { - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Initializer_valueContext initializer_value() { - return getRuleContext(Initializer_valueContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public Member_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_initializer(this); - } - } - - public final Member_initializerContext member_initializer() throws RecognitionException { - Member_initializerContext _localctx = new Member_initializerContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_member_initializer); - try { - enterOuterAlt(_localctx, 1); - { - setState(990); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BY: - case DESCENDING: - case DYNAMIC: - case EQUALS: - case FROM: - case GET: - case GROUP: - case INTO: - case JOIN: - case LET: - case NAMEOF: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SELECT: - case SET: - case UNMANAGED: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - { - setState(985); - identifier(); - } - break; - case OPEN_BRACKET: - { - setState(986); - match(OPEN_BRACKET); - setState(987); - expression(); - setState(988); - match(CLOSE_BRACKET); - } - break; - default: - throw new NoViableAltException(this); - } - setState(992); - match(ASSIGNMENT); - setState(993); - initializer_value(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Initializer_valueContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Object_or_collection_initializerContext object_or_collection_initializer() { - return getRuleContext(Object_or_collection_initializerContext.class,0); - } - public Initializer_valueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_initializer_value; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInitializer_value(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInitializer_value(this); - } - } - - public final Initializer_valueContext initializer_value() throws RecognitionException { - Initializer_valueContext _localctx = new Initializer_valueContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_initializer_value); - try { - setState(997); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(995); - expression(); - } - break; - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(996); - object_or_collection_initializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Collection_initializerContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public List element_initializer() { - return getRuleContexts(Element_initializerContext.class); - } - public Element_initializerContext element_initializer(int i) { - return getRuleContext(Element_initializerContext.class,i); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Collection_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_collection_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCollection_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCollection_initializer(this); - } - } - - public final Collection_initializerContext collection_initializer() throws RecognitionException { - Collection_initializerContext _localctx = new Collection_initializerContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_collection_initializer); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(999); - match(OPEN_BRACE); - setState(1000); - element_initializer(); - setState(1005); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,87,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1001); - match(COMMA); - setState(1002); - element_initializer(); - } - } - } - setState(1007); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,87,_ctx); - } - setState(1009); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(1008); - match(COMMA); - } - } - - setState(1011); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Element_initializerContext extends ParserRuleContext { - public Non_assignment_expressionContext non_assignment_expression() { - return getRuleContext(Non_assignment_expressionContext.class,0); - } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public Expression_listContext expression_list() { - return getRuleContext(Expression_listContext.class,0); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Element_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_element_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterElement_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitElement_initializer(this); - } - } - - public final Element_initializerContext element_initializer() throws RecognitionException { - Element_initializerContext _localctx = new Element_initializerContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_element_initializer); - try { - setState(1018); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(1013); - non_assignment_expression(); - } - break; - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(1014); - match(OPEN_BRACE); - setState(1015); - expression_list(); - setState(1016); - match(CLOSE_BRACE); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Anonymous_object_initializerContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Member_declarator_listContext member_declarator_list() { - return getRuleContext(Member_declarator_listContext.class,0); - } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Anonymous_object_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymous_object_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAnonymous_object_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAnonymous_object_initializer(this); - } - } - - public final Anonymous_object_initializerContext anonymous_object_initializer() throws RecognitionException { - Anonymous_object_initializerContext _localctx = new Anonymous_object_initializerContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_anonymous_object_initializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1020); - match(OPEN_BRACE); - setState(1025); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BASE - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (CHECKED - 10)) | (1L << (DECIMAL - 10)) | (1L << (DEFAULT - 10)) | (1L << (DELEGATE - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FALSE - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (NEW - 10)) | (1L << (NULL - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (SIZEOF - 75)) | (1L << (STRING - 75)) | (1L << (THIS - 75)) | (1L << (TRUE - 75)) | (1L << (TYPEOF - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNCHECKED - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (LITERAL_ACCESS - 75)) | (1L << (INTEGER_LITERAL - 75)) | (1L << (HEX_INTEGER_LITERAL - 75)) | (1L << (BIN_INTEGER_LITERAL - 75)) | (1L << (REAL_LITERAL - 75)) | (1L << (CHARACTER_LITERAL - 75)) | (1L << (REGULAR_STRING - 75)) | (1L << (VERBATIUM_STRING - 75)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 75)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { - { - setState(1021); - member_declarator_list(); - setState(1023); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(1022); - match(COMMA); - } - } - - } - } - - setState(1027); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_declarator_listContext extends ParserRuleContext { - public List member_declarator() { - return getRuleContexts(Member_declaratorContext.class); - } - public Member_declaratorContext member_declarator(int i) { - return getRuleContext(Member_declaratorContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Member_declarator_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_declarator_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_declarator_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_declarator_list(this); - } - } - - public final Member_declarator_listContext member_declarator_list() throws RecognitionException { - Member_declarator_listContext _localctx = new Member_declarator_listContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_member_declarator_list); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1029); - member_declarator(); - setState(1034); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,92,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1030); - match(COMMA); - setState(1031); - member_declarator(); - } - } - } - setState(1036); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,92,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_declaratorContext extends ParserRuleContext { - public Primary_expressionContext primary_expression() { - return getRuleContext(Primary_expressionContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Member_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_declarator(this); - } - } - - public final Member_declaratorContext member_declarator() throws RecognitionException { - Member_declaratorContext _localctx = new Member_declaratorContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_member_declarator); - try { - setState(1042); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1037); - primary_expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1038); - identifier(); - setState(1039); - match(ASSIGNMENT); - setState(1040); - expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Unbound_type_nameContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } - public List DOT() { return getTokens(CSharpParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(CSharpParser.DOT, i); - } - public List generic_dimension_specifier() { - return getRuleContexts(Generic_dimension_specifierContext.class); - } - public Generic_dimension_specifierContext generic_dimension_specifier(int i) { - return getRuleContext(Generic_dimension_specifierContext.class,i); - } - public Unbound_type_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unbound_type_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUnbound_type_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUnbound_type_name(this); - } - } - - public final Unbound_type_nameContext unbound_type_name() throws RecognitionException { - Unbound_type_nameContext _localctx = new Unbound_type_nameContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_unbound_type_name); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1044); - identifier(); - setState(1053); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CLOSE_PARENS: - case DOT: - case LT: - { - setState(1046); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1045); - generic_dimension_specifier(); - } - } - - } - break; - case DOUBLE_COLON: - { - setState(1048); - match(DOUBLE_COLON); - setState(1049); - identifier(); - setState(1051); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1050); - generic_dimension_specifier(); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - setState(1062); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==DOT) { - { - { - setState(1055); - match(DOT); - setState(1056); - identifier(); - setState(1058); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1057); - generic_dimension_specifier(); - } - } - - } - } - setState(1064); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Generic_dimension_specifierContext extends ParserRuleContext { - public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Generic_dimension_specifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_generic_dimension_specifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGeneric_dimension_specifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGeneric_dimension_specifier(this); - } - } - - public final Generic_dimension_specifierContext generic_dimension_specifier() throws RecognitionException { - Generic_dimension_specifierContext _localctx = new Generic_dimension_specifierContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_generic_dimension_specifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1065); - match(LT); - setState(1069); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1066); - match(COMMA); - } - } - setState(1071); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1072); - match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IsTypeContext extends ParserRuleContext { - public Base_typeContext base_type() { - return getRuleContext(Base_typeContext.class,0); - } - public List rank_specifier() { - return getRuleContexts(Rank_specifierContext.class); - } - public Rank_specifierContext rank_specifier(int i) { - return getRuleContext(Rank_specifierContext.class,i); - } - public List STAR() { return getTokens(CSharpParser.STAR); } - public TerminalNode STAR(int i) { - return getToken(CSharpParser.STAR, i); - } - public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } - public IsTypePatternArmsContext isTypePatternArms() { - return getRuleContext(IsTypePatternArmsContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public IsTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_isType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIsType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIsType(this); - } - } - - public final IsTypeContext isType() throws RecognitionException { - IsTypeContext _localctx = new IsTypeContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_isType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1074); - base_type(); - setState(1079); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,101,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(1077); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACKET: - { - setState(1075); - rank_specifier(); - } - break; - case STAR: - { - setState(1076); - match(STAR); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(1081); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,101,_ctx); - } - setState(1083); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { - case 1: - { - setState(1082); - match(INTERR); - } - break; - } - setState(1086); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACE) { - { - setState(1085); - isTypePatternArms(); - } - } - - setState(1089); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { - case 1: - { - setState(1088); - identifier(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IsTypePatternArmsContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public List isTypePatternArm() { - return getRuleContexts(IsTypePatternArmContext.class); - } - public IsTypePatternArmContext isTypePatternArm(int i) { - return getRuleContext(IsTypePatternArmContext.class,i); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public IsTypePatternArmsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_isTypePatternArms; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIsTypePatternArms(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIsTypePatternArms(this); - } - } - - public final IsTypePatternArmsContext isTypePatternArms() throws RecognitionException { - IsTypePatternArmsContext _localctx = new IsTypePatternArmsContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_isTypePatternArms); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1091); - match(OPEN_BRACE); - setState(1092); - isTypePatternArm(); - setState(1097); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1093); - match(COMMA); - setState(1094); - isTypePatternArm(); - } - } - setState(1099); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1100); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IsTypePatternArmContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public IsTypePatternArmContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_isTypePatternArm; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIsTypePatternArm(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIsTypePatternArm(this); - } - } - - public final IsTypePatternArmContext isTypePatternArm() throws RecognitionException { - IsTypePatternArmContext _localctx = new IsTypePatternArmContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_isTypePatternArm); - try { - enterOuterAlt(_localctx, 1); - { - setState(1102); - identifier(); - setState(1103); - match(COLON); - setState(1104); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Lambda_expressionContext extends ParserRuleContext { - public Anonymous_function_signatureContext anonymous_function_signature() { - return getRuleContext(Anonymous_function_signatureContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Anonymous_function_bodyContext anonymous_function_body() { - return getRuleContext(Anonymous_function_bodyContext.class,0); - } - public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } - public Lambda_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambda_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLambda_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLambda_expression(this); - } - } - - public final Lambda_expressionContext lambda_expression() throws RecognitionException { - Lambda_expressionContext _localctx = new Lambda_expressionContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_lambda_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1107); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { - case 1: - { - setState(1106); - match(ASYNC); - } - break; - } - setState(1109); - anonymous_function_signature(); - setState(1110); - right_arrow(); - setState(1111); - anonymous_function_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Anonymous_function_signatureContext extends ParserRuleContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() { - return getRuleContext(Explicit_anonymous_function_parameter_listContext.class,0); - } - public Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() { - return getRuleContext(Implicit_anonymous_function_parameter_listContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Anonymous_function_signatureContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymous_function_signature; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAnonymous_function_signature(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAnonymous_function_signature(this); - } - } - - public final Anonymous_function_signatureContext anonymous_function_signature() throws RecognitionException { - Anonymous_function_signatureContext _localctx = new Anonymous_function_signatureContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_anonymous_function_signature); - try { - setState(1124); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1113); - match(OPEN_PARENS); - setState(1114); - match(CLOSE_PARENS); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1115); - match(OPEN_PARENS); - setState(1116); - explicit_anonymous_function_parameter_list(); - setState(1117); - match(CLOSE_PARENS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1119); - match(OPEN_PARENS); - setState(1120); - implicit_anonymous_function_parameter_list(); - setState(1121); - match(CLOSE_PARENS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1123); - identifier(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Explicit_anonymous_function_parameter_listContext extends ParserRuleContext { - public List explicit_anonymous_function_parameter() { - return getRuleContexts(Explicit_anonymous_function_parameterContext.class); - } - public Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter(int i) { - return getRuleContext(Explicit_anonymous_function_parameterContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Explicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicit_anonymous_function_parameter_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExplicit_anonymous_function_parameter_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExplicit_anonymous_function_parameter_list(this); - } - } - - public final Explicit_anonymous_function_parameter_listContext explicit_anonymous_function_parameter_list() throws RecognitionException { - Explicit_anonymous_function_parameter_listContext _localctx = new Explicit_anonymous_function_parameter_listContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_explicit_anonymous_function_parameter_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1126); - explicit_anonymous_function_parameter(); - setState(1131); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1127); - match(COMMA); - setState(1128); - explicit_anonymous_function_parameter(); - } - } - setState(1133); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Explicit_anonymous_function_parameterContext extends ParserRuleContext { - public Token refout; - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public Explicit_anonymous_function_parameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicit_anonymous_function_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExplicit_anonymous_function_parameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExplicit_anonymous_function_parameter(this); - } - } - - public final Explicit_anonymous_function_parameterContext explicit_anonymous_function_parameter() throws RecognitionException { - Explicit_anonymous_function_parameterContext _localctx = new Explicit_anonymous_function_parameterContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_explicit_anonymous_function_parameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1135); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) { - { - setState(1134); - ((Explicit_anonymous_function_parameterContext)_localctx).refout = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)))) != 0)) ) { - ((Explicit_anonymous_function_parameterContext)_localctx).refout = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(1137); - type_(); - setState(1138); - identifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Implicit_anonymous_function_parameter_listContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Implicit_anonymous_function_parameter_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_implicit_anonymous_function_parameter_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterImplicit_anonymous_function_parameter_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitImplicit_anonymous_function_parameter_list(this); - } - } - - public final Implicit_anonymous_function_parameter_listContext implicit_anonymous_function_parameter_list() throws RecognitionException { - Implicit_anonymous_function_parameter_listContext _localctx = new Implicit_anonymous_function_parameter_listContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_implicit_anonymous_function_parameter_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1140); - identifier(); - setState(1145); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1141); - match(COMMA); - setState(1142); - identifier(); - } - } - setState(1147); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Anonymous_function_bodyContext extends ParserRuleContext { - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Anonymous_function_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymous_function_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAnonymous_function_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAnonymous_function_body(this); - } - } - - public final Anonymous_function_bodyContext anonymous_function_body() throws RecognitionException { - Anonymous_function_bodyContext _localctx = new Anonymous_function_bodyContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_anonymous_function_body); - try { - setState(1150); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case THROW: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(1148); - throwable_expression(); - } - break; - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(1149); - block(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Query_expressionContext extends ParserRuleContext { - public From_clauseContext from_clause() { - return getRuleContext(From_clauseContext.class,0); - } - public Query_bodyContext query_body() { - return getRuleContext(Query_bodyContext.class,0); - } - public Query_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_query_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQuery_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQuery_expression(this); - } - } - - public final Query_expressionContext query_expression() throws RecognitionException { - Query_expressionContext _localctx = new Query_expressionContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_query_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1152); - from_clause(); - setState(1153); - query_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class From_clauseContext extends ParserRuleContext { - public TerminalNode FROM() { return getToken(CSharpParser.FROM, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public From_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_from_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFrom_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFrom_clause(this); - } - } - - public final From_clauseContext from_clause() throws RecognitionException { - From_clauseContext _localctx = new From_clauseContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_from_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1155); - match(FROM); - setState(1157); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { - case 1: - { - setState(1156); - type_(); - } - break; - } - setState(1159); - identifier(); - setState(1160); - match(IN); - setState(1161); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Query_bodyContext extends ParserRuleContext { - public Select_or_group_clauseContext select_or_group_clause() { - return getRuleContext(Select_or_group_clauseContext.class,0); - } - public List query_body_clause() { - return getRuleContexts(Query_body_clauseContext.class); - } - public Query_body_clauseContext query_body_clause(int i) { - return getRuleContext(Query_body_clauseContext.class,i); - } - public Query_continuationContext query_continuation() { - return getRuleContext(Query_continuationContext.class,0); - } - public Query_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_query_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQuery_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQuery_body(this); - } - } - - public final Query_bodyContext query_body() throws RecognitionException { - Query_bodyContext _localctx = new Query_bodyContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_query_body); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1166); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 48)) & ~0x3f) == 0 && ((1L << (_la - 48)) & ((1L << (FROM - 48)) | (1L << (JOIN - 48)) | (1L << (LET - 48)) | (1L << (ORDERBY - 48)) | (1L << (WHERE - 48)))) != 0)) { - { - { - setState(1163); - query_body_clause(); - } - } - setState(1168); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1169); - select_or_group_clause(); - setState(1171); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) { - case 1: - { - setState(1170); - query_continuation(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Query_body_clauseContext extends ParserRuleContext { - public From_clauseContext from_clause() { - return getRuleContext(From_clauseContext.class,0); - } - public Let_clauseContext let_clause() { - return getRuleContext(Let_clauseContext.class,0); - } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public Combined_join_clauseContext combined_join_clause() { - return getRuleContext(Combined_join_clauseContext.class,0); - } - public Orderby_clauseContext orderby_clause() { - return getRuleContext(Orderby_clauseContext.class,0); - } - public Query_body_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_query_body_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQuery_body_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQuery_body_clause(this); - } - } - - public final Query_body_clauseContext query_body_clause() throws RecognitionException { - Query_body_clauseContext _localctx = new Query_body_clauseContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_query_body_clause); - try { - setState(1178); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FROM: - enterOuterAlt(_localctx, 1); - { - setState(1173); - from_clause(); - } - break; - case LET: - enterOuterAlt(_localctx, 2); - { - setState(1174); - let_clause(); - } - break; - case WHERE: - enterOuterAlt(_localctx, 3); - { - setState(1175); - where_clause(); - } - break; - case JOIN: - enterOuterAlt(_localctx, 4); - { - setState(1176); - combined_join_clause(); - } - break; - case ORDERBY: - enterOuterAlt(_localctx, 5); - { - setState(1177); - orderby_clause(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Let_clauseContext extends ParserRuleContext { - public TerminalNode LET() { return getToken(CSharpParser.LET, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Let_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_let_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLet_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLet_clause(this); - } - } - - public final Let_clauseContext let_clause() throws RecognitionException { - Let_clauseContext _localctx = new Let_clauseContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_let_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1180); - match(LET); - setState(1181); - identifier(); - setState(1182); - match(ASSIGNMENT); - setState(1183); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Where_clauseContext extends ParserRuleContext { - public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Where_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_where_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterWhere_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitWhere_clause(this); - } - } - - public final Where_clauseContext where_clause() throws RecognitionException { - Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_where_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1185); - match(WHERE); - setState(1186); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Combined_join_clauseContext extends ParserRuleContext { - public TerminalNode JOIN() { return getToken(CSharpParser.JOIN, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode ON() { return getToken(CSharpParser.ON, 0); } - public TerminalNode EQUALS() { return getToken(CSharpParser.EQUALS, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } - public Combined_join_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_combined_join_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCombined_join_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCombined_join_clause(this); - } - } - - public final Combined_join_clauseContext combined_join_clause() throws RecognitionException { - Combined_join_clauseContext _localctx = new Combined_join_clauseContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_combined_join_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1188); - match(JOIN); - setState(1190); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { - case 1: - { - setState(1189); - type_(); - } - break; - } - setState(1192); - identifier(); - setState(1193); - match(IN); - setState(1194); - expression(); - setState(1195); - match(ON); - setState(1196); - expression(); - setState(1197); - match(EQUALS); - setState(1198); - expression(); - setState(1201); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTO) { - { - setState(1199); - match(INTO); - setState(1200); - identifier(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Orderby_clauseContext extends ParserRuleContext { - public TerminalNode ORDERBY() { return getToken(CSharpParser.ORDERBY, 0); } - public List ordering() { - return getRuleContexts(OrderingContext.class); - } - public OrderingContext ordering(int i) { - return getRuleContext(OrderingContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Orderby_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_orderby_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterOrderby_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitOrderby_clause(this); - } - } - - public final Orderby_clauseContext orderby_clause() throws RecognitionException { - Orderby_clauseContext _localctx = new Orderby_clauseContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_orderby_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1203); - match(ORDERBY); - setState(1204); - ordering(); - setState(1209); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1205); - match(COMMA); - setState(1206); - ordering(); - } - } - setState(1211); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class OrderingContext extends ParserRuleContext { - public Token dir; - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode ASCENDING() { return getToken(CSharpParser.ASCENDING, 0); } - public TerminalNode DESCENDING() { return getToken(CSharpParser.DESCENDING, 0); } - public OrderingContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_ordering; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterOrdering(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitOrdering(this); - } - } - - public final OrderingContext ordering() throws RecognitionException { - OrderingContext _localctx = new OrderingContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_ordering); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1212); - expression(); - setState(1214); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASCENDING || _la==DESCENDING) { - { - setState(1213); - ((OrderingContext)_localctx).dir = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==ASCENDING || _la==DESCENDING) ) { - ((OrderingContext)_localctx).dir = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Select_or_group_clauseContext extends ParserRuleContext { - public TerminalNode SELECT() { return getToken(CSharpParser.SELECT, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode GROUP() { return getToken(CSharpParser.GROUP, 0); } - public TerminalNode BY() { return getToken(CSharpParser.BY, 0); } - public Select_or_group_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_select_or_group_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSelect_or_group_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSelect_or_group_clause(this); - } - } - - public final Select_or_group_clauseContext select_or_group_clause() throws RecognitionException { - Select_or_group_clauseContext _localctx = new Select_or_group_clauseContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_select_or_group_clause); - try { - setState(1223); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SELECT: - enterOuterAlt(_localctx, 1); - { - setState(1216); - match(SELECT); - setState(1217); - expression(); - } - break; - case GROUP: - enterOuterAlt(_localctx, 2); - { - setState(1218); - match(GROUP); - setState(1219); - expression(); - setState(1220); - match(BY); - setState(1221); - expression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Query_continuationContext extends ParserRuleContext { - public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Query_bodyContext query_body() { - return getRuleContext(Query_bodyContext.class,0); - } - public Query_continuationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_query_continuation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQuery_continuation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQuery_continuation(this); - } - } - - public final Query_continuationContext query_continuation() throws RecognitionException { - Query_continuationContext _localctx = new Query_continuationContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_query_continuation); - try { - enterOuterAlt(_localctx, 1); - { - setState(1225); - match(INTO); - setState(1226); - identifier(); - setState(1227); - query_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementContext extends ParserRuleContext { - public Labeled_StatementContext labeled_Statement() { - return getRuleContext(Labeled_StatementContext.class,0); - } - public DeclarationStatementContext declarationStatement() { - return getRuleContext(DeclarationStatementContext.class,0); - } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStatement(this); - } - } - - public final StatementContext statement() throws RecognitionException { - StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_statement); - try { - setState(1232); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1229); - labeled_Statement(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1230); - declarationStatement(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1231); - embedded_statement(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DeclarationStatementContext extends ParserRuleContext { - public Local_variable_declarationContext local_variable_declaration() { - return getRuleContext(Local_variable_declarationContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Local_constant_declarationContext local_constant_declaration() { - return getRuleContext(Local_constant_declarationContext.class,0); - } - public Local_function_declarationContext local_function_declaration() { - return getRuleContext(Local_function_declarationContext.class,0); - } - public DeclarationStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_declarationStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterDeclarationStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitDeclarationStatement(this); - } - } - - public final DeclarationStatementContext declarationStatement() throws RecognitionException { - DeclarationStatementContext _localctx = new DeclarationStatementContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_declarationStatement); - try { - setState(1241); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1234); - local_variable_declaration(); - setState(1235); - match(SEMICOLON); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1237); - local_constant_declaration(); - setState(1238); - match(SEMICOLON); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1240); - local_function_declaration(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_function_declarationContext extends ParserRuleContext { - public Local_function_headerContext local_function_header() { - return getRuleContext(Local_function_headerContext.class,0); - } - public Local_function_bodyContext local_function_body() { - return getRuleContext(Local_function_bodyContext.class,0); - } - public Local_function_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_function_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_function_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_function_declaration(this); - } - } - - public final Local_function_declarationContext local_function_declaration() throws RecognitionException { - Local_function_declarationContext _localctx = new Local_function_declarationContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_local_function_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(1243); - local_function_header(); - setState(1244); - local_function_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_function_headerContext extends ParserRuleContext { - public Return_typeContext return_type() { - return getRuleContext(Return_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Local_function_modifiersContext local_function_modifiers() { - return getRuleContext(Local_function_modifiersContext.class,0); - } - public Type_parameter_listContext type_parameter_list() { - return getRuleContext(Type_parameter_listContext.class,0); - } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public Local_function_headerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_function_header; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_function_header(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_function_header(this); - } - } - - public final Local_function_headerContext local_function_header() throws RecognitionException { - Local_function_headerContext _localctx = new Local_function_headerContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_local_function_header); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1247); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { - case 1: - { - setState(1246); - local_function_modifiers(); - } - break; - } - setState(1249); - return_type(); - setState(1250); - identifier(); - setState(1252); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1251); - type_parameter_list(); - } - } - - setState(1254); - match(OPEN_PARENS); - setState(1256); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(1255); - formal_parameter_list(); - } - } - - setState(1258); - match(CLOSE_PARENS); - setState(1260); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(1259); - type_parameter_constraints_clauses(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_function_modifiersContext extends ParserRuleContext { - public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } - public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } - public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } - public Local_function_modifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_function_modifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_function_modifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_function_modifiers(this); - } - } - - public final Local_function_modifiersContext local_function_modifiers() throws RecognitionException { - Local_function_modifiersContext _localctx = new Local_function_modifiersContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_local_function_modifiers); - int _la; - try { - setState(1268); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ASYNC: - case UNSAFE: - enterOuterAlt(_localctx, 1); - { - setState(1262); - _la = _input.LA(1); - if ( !(_la==ASYNC || _la==UNSAFE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1264); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STATIC) { - { - setState(1263); - match(STATIC); - } - } - - } - break; - case STATIC: - enterOuterAlt(_localctx, 2); - { - setState(1266); - match(STATIC); - setState(1267); - _la = _input.LA(1); - if ( !(_la==ASYNC || _la==UNSAFE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_function_bodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Local_function_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_function_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_function_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_function_body(this); - } - } - - public final Local_function_bodyContext local_function_body() throws RecognitionException { - Local_function_bodyContext _localctx = new Local_function_bodyContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_local_function_body); - try { - setState(1275); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1270); - block(); - } - break; - case ASSIGNMENT: - enterOuterAlt(_localctx, 2); - { - setState(1271); - right_arrow(); - setState(1272); - throwable_expression(); - setState(1273); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Labeled_StatementContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public StatementContext statement() { - return getRuleContext(StatementContext.class,0); - } - public Labeled_StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_labeled_Statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLabeled_Statement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLabeled_Statement(this); - } - } - - public final Labeled_StatementContext labeled_Statement() throws RecognitionException { - Labeled_StatementContext _localctx = new Labeled_StatementContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_labeled_Statement); - try { - enterOuterAlt(_localctx, 1); - { - setState(1277); - identifier(); - setState(1278); - match(COLON); - setState(1279); - statement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Embedded_statementContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Simple_embedded_statementContext simple_embedded_statement() { - return getRuleContext(Simple_embedded_statementContext.class,0); - } - public Embedded_statementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_embedded_statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEmbedded_statement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEmbedded_statement(this); - } - } - - public final Embedded_statementContext embedded_statement() throws RecognitionException { - Embedded_statementContext _localctx = new Embedded_statementContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_embedded_statement); - try { - setState(1283); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1281); - block(); - } - break; - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BREAK: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case CONTINUE: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DO: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FIXED: - case FLOAT: - case FOR: - case FOREACH: - case FROM: - case GET: - case GOTO: - case GROUP: - case IF: - case INT: - case INTO: - case JOIN: - case LET: - case LOCK: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case RETURN: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case SWITCH: - case THIS: - case THROW: - case TRUE: - case TRY: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case UNSAFE: - case USHORT: - case USING: - case VAR: - case WHEN: - case WHERE: - case WHILE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case SEMICOLON: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 2); - { - setState(1282); - simple_embedded_statement(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Simple_embedded_statementContext extends ParserRuleContext { - public Simple_embedded_statementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simple_embedded_statement; } - - public Simple_embedded_statementContext() { } - public void copyFrom(Simple_embedded_statementContext ctx) { - super.copyFrom(ctx); - } - } - public static class TryStatementContext extends Simple_embedded_statementContext { - public TerminalNode TRY() { return getToken(CSharpParser.TRY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Catch_clausesContext catch_clauses() { - return getRuleContext(Catch_clausesContext.class,0); - } - public Finally_clauseContext finally_clause() { - return getRuleContext(Finally_clauseContext.class,0); - } - public TryStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTryStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTryStatement(this); - } - } - public static class CheckedStatementContext extends Simple_embedded_statementContext { - public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public CheckedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCheckedStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCheckedStatement(this); - } - } - public static class ThrowStatementContext extends Simple_embedded_statementContext { - public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ThrowStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterThrowStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitThrowStatement(this); - } - } - public static class TheEmptyStatementContext extends Simple_embedded_statementContext { - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public TheEmptyStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTheEmptyStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTheEmptyStatement(this); - } - } - public static class UnsafeStatementContext extends Simple_embedded_statementContext { - public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public UnsafeStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUnsafeStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUnsafeStatement(this); - } - } - public static class ForStatementContext extends Simple_embedded_statementContext { - public TerminalNode FOR() { return getToken(CSharpParser.FOR, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public List SEMICOLON() { return getTokens(CSharpParser.SEMICOLON); } - public TerminalNode SEMICOLON(int i) { - return getToken(CSharpParser.SEMICOLON, i); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public For_initializerContext for_initializer() { - return getRuleContext(For_initializerContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public For_iteratorContext for_iterator() { - return getRuleContext(For_iteratorContext.class,0); - } - public ForStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterForStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitForStatement(this); - } - } - public static class BreakStatementContext extends Simple_embedded_statementContext { - public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public BreakStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBreakStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBreakStatement(this); - } - } - public static class IfStatementContext extends Simple_embedded_statementContext { - public TerminalNode IF() { return getToken(CSharpParser.IF, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public List if_body() { - return getRuleContexts(If_bodyContext.class); - } - public If_bodyContext if_body(int i) { - return getRuleContext(If_bodyContext.class,i); - } - public TerminalNode ELSE() { return getToken(CSharpParser.ELSE, 0); } - public IfStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIfStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIfStatement(this); - } - } - public static class ReturnStatementContext extends Simple_embedded_statementContext { - public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ReturnStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterReturnStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitReturnStatement(this); - } - } - public static class GotoStatementContext extends Simple_embedded_statementContext { - public TerminalNode GOTO() { return getToken(CSharpParser.GOTO, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } - public GotoStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGotoStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGotoStatement(this); - } - } - public static class SwitchStatementContext extends Simple_embedded_statementContext { - public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List switch_section() { - return getRuleContexts(Switch_sectionContext.class); - } - public Switch_sectionContext switch_section(int i) { - return getRuleContext(Switch_sectionContext.class,i); - } - public SwitchStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitchStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitchStatement(this); - } - } - public static class FixedStatementContext extends Simple_embedded_statementContext { - public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Pointer_typeContext pointer_type() { - return getRuleContext(Pointer_typeContext.class,0); - } - public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { - return getRuleContext(Fixed_pointer_declaratorsContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public FixedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixedStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixedStatement(this); - } - } - public static class WhileStatementContext extends Simple_embedded_statementContext { - public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public WhileStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterWhileStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitWhileStatement(this); - } - } - public static class DoStatementContext extends Simple_embedded_statementContext { - public TerminalNode DO() { return getToken(CSharpParser.DO, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public DoStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterDoStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitDoStatement(this); - } - } - public static class ForeachStatementContext extends Simple_embedded_statementContext { - public TerminalNode FOREACH() { return getToken(CSharpParser.FOREACH, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Local_variable_typeContext local_variable_type() { - return getRuleContext(Local_variable_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } - public ForeachStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterForeachStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitForeachStatement(this); - } - } - public static class UncheckedStatementContext extends Simple_embedded_statementContext { - public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public UncheckedStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUncheckedStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUncheckedStatement(this); - } - } - public static class ExpressionStatementContext extends Simple_embedded_statementContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public ExpressionStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExpressionStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExpressionStatement(this); - } - } - public static class ContinueStatementContext extends Simple_embedded_statementContext { - public TerminalNode CONTINUE() { return getToken(CSharpParser.CONTINUE, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public ContinueStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterContinueStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitContinueStatement(this); - } - } - public static class UsingStatementContext extends Simple_embedded_statementContext { - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Resource_acquisitionContext resource_acquisition() { - return getRuleContext(Resource_acquisitionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public UsingStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUsingStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUsingStatement(this); - } - } - public static class LockStatementContext extends Simple_embedded_statementContext { - public TerminalNode LOCK() { return getToken(CSharpParser.LOCK, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Embedded_statementContext embedded_statement() { - return getRuleContext(Embedded_statementContext.class,0); - } - public LockStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLockStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLockStatement(this); - } - } - public static class YieldStatementContext extends Simple_embedded_statementContext { - public TerminalNode YIELD() { return getToken(CSharpParser.YIELD, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } - public YieldStatementContext(Simple_embedded_statementContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterYieldStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitYieldStatement(this); - } - } - - public final Simple_embedded_statementContext simple_embedded_statement() throws RecognitionException { - Simple_embedded_statementContext _localctx = new Simple_embedded_statementContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_simple_embedded_statement); - int _la; - try { - setState(1415); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { - case 1: - _localctx = new TheEmptyStatementContext(_localctx); - enterOuterAlt(_localctx, 1); - { - setState(1285); - match(SEMICOLON); - } - break; - case 2: - _localctx = new ExpressionStatementContext(_localctx); - enterOuterAlt(_localctx, 2); - { - setState(1286); - expression(); - setState(1287); - match(SEMICOLON); - } - break; - case 3: - _localctx = new IfStatementContext(_localctx); - enterOuterAlt(_localctx, 3); - { - setState(1289); - match(IF); - setState(1290); - match(OPEN_PARENS); - setState(1291); - expression(); - setState(1292); - match(CLOSE_PARENS); - setState(1293); - if_body(); - setState(1296); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { - case 1: - { - setState(1294); - match(ELSE); - setState(1295); - if_body(); - } - break; - } - } - break; - case 4: - _localctx = new SwitchStatementContext(_localctx); - enterOuterAlt(_localctx, 4); - { - setState(1298); - match(SWITCH); - setState(1299); - match(OPEN_PARENS); - setState(1300); - expression(); - setState(1301); - match(CLOSE_PARENS); - setState(1302); - match(OPEN_BRACE); - setState(1306); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==CASE || _la==DEFAULT) { - { - { - setState(1303); - switch_section(); - } - } - setState(1308); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1309); - match(CLOSE_BRACE); - } - break; - case 5: - _localctx = new WhileStatementContext(_localctx); - enterOuterAlt(_localctx, 5); - { - setState(1311); - match(WHILE); - setState(1312); - match(OPEN_PARENS); - setState(1313); - expression(); - setState(1314); - match(CLOSE_PARENS); - setState(1315); - embedded_statement(); - } - break; - case 6: - _localctx = new DoStatementContext(_localctx); - enterOuterAlt(_localctx, 6); - { - setState(1317); - match(DO); - setState(1318); - embedded_statement(); - setState(1319); - match(WHILE); - setState(1320); - match(OPEN_PARENS); - setState(1321); - expression(); - setState(1322); - match(CLOSE_PARENS); - setState(1323); - match(SEMICOLON); - } - break; - case 7: - _localctx = new ForStatementContext(_localctx); - enterOuterAlt(_localctx, 7); - { - setState(1325); - match(FOR); - setState(1326); - match(OPEN_PARENS); - setState(1328); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FIXED) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (USING - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1327); - for_initializer(); - } - } - - setState(1330); - match(SEMICOLON); - setState(1332); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1331); - expression(); - } - } - - setState(1334); - match(SEMICOLON); - setState(1336); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1335); - for_iterator(); - } - } - - setState(1338); - match(CLOSE_PARENS); - setState(1339); - embedded_statement(); - } - break; - case 8: - _localctx = new ForeachStatementContext(_localctx); - enterOuterAlt(_localctx, 8); - { - setState(1341); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AWAIT) { - { - setState(1340); - match(AWAIT); - } - } - - setState(1343); - match(FOREACH); - setState(1344); - match(OPEN_PARENS); - setState(1345); - local_variable_type(); - setState(1346); - identifier(); - setState(1347); - match(IN); - setState(1348); - expression(); - setState(1349); - match(CLOSE_PARENS); - setState(1350); - embedded_statement(); - } - break; - case 9: - _localctx = new BreakStatementContext(_localctx); - enterOuterAlt(_localctx, 9); - { - setState(1352); - match(BREAK); - setState(1353); - match(SEMICOLON); - } - break; - case 10: - _localctx = new ContinueStatementContext(_localctx); - enterOuterAlt(_localctx, 10); - { - setState(1354); - match(CONTINUE); - setState(1355); - match(SEMICOLON); - } - break; - case 11: - _localctx = new GotoStatementContext(_localctx); - enterOuterAlt(_localctx, 11); - { - setState(1356); - match(GOTO); - setState(1361); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BY: - case DESCENDING: - case DYNAMIC: - case EQUALS: - case FROM: - case GET: - case GROUP: - case INTO: - case JOIN: - case LET: - case NAMEOF: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SELECT: - case SET: - case UNMANAGED: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - { - setState(1357); - identifier(); - } - break; - case CASE: - { - setState(1358); - match(CASE); - setState(1359); - expression(); - } - break; - case DEFAULT: - { - setState(1360); - match(DEFAULT); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1363); - match(SEMICOLON); - } - break; - case 12: - _localctx = new ReturnStatementContext(_localctx); - enterOuterAlt(_localctx, 12); - { - setState(1364); - match(RETURN); - setState(1366); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1365); - expression(); - } - } - - setState(1368); - match(SEMICOLON); - } - break; - case 13: - _localctx = new ThrowStatementContext(_localctx); - enterOuterAlt(_localctx, 13); - { - setState(1369); - match(THROW); - setState(1371); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1370); - expression(); - } - } - - setState(1373); - match(SEMICOLON); - } - break; - case 14: - _localctx = new TryStatementContext(_localctx); - enterOuterAlt(_localctx, 14); - { - setState(1374); - match(TRY); - setState(1375); - block(); - setState(1381); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CATCH: - { - setState(1376); - catch_clauses(); - setState(1378); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FINALLY) { - { - setState(1377); - finally_clause(); - } - } - - } - break; - case FINALLY: - { - setState(1380); - finally_clause(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 15: - _localctx = new CheckedStatementContext(_localctx); - enterOuterAlt(_localctx, 15); - { - setState(1383); - match(CHECKED); - setState(1384); - block(); - } - break; - case 16: - _localctx = new UncheckedStatementContext(_localctx); - enterOuterAlt(_localctx, 16); - { - setState(1385); - match(UNCHECKED); - setState(1386); - block(); - } - break; - case 17: - _localctx = new LockStatementContext(_localctx); - enterOuterAlt(_localctx, 17); - { - setState(1387); - match(LOCK); - setState(1388); - match(OPEN_PARENS); - setState(1389); - expression(); - setState(1390); - match(CLOSE_PARENS); - setState(1391); - embedded_statement(); - } - break; - case 18: - _localctx = new UsingStatementContext(_localctx); - enterOuterAlt(_localctx, 18); - { - setState(1393); - match(USING); - setState(1394); - match(OPEN_PARENS); - setState(1395); - resource_acquisition(); - setState(1396); - match(CLOSE_PARENS); - setState(1397); - embedded_statement(); - } - break; - case 19: - _localctx = new YieldStatementContext(_localctx); - enterOuterAlt(_localctx, 19); - { - setState(1399); - match(YIELD); - setState(1403); - _errHandler.sync(this); - switch (_input.LA(1)) { - case RETURN: - { - setState(1400); - match(RETURN); - setState(1401); - expression(); - } - break; - case BREAK: - { - setState(1402); - match(BREAK); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1405); - match(SEMICOLON); - } - break; - case 20: - _localctx = new UnsafeStatementContext(_localctx); - enterOuterAlt(_localctx, 20); - { - setState(1406); - match(UNSAFE); - setState(1407); - block(); - } - break; - case 21: - _localctx = new FixedStatementContext(_localctx); - enterOuterAlt(_localctx, 21); - { - setState(1408); - match(FIXED); - setState(1409); - match(OPEN_PARENS); - setState(1410); - pointer_type(); - setState(1411); - fixed_pointer_declarators(); - setState(1412); - match(CLOSE_PARENS); - setState(1413); - embedded_statement(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BlockContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Statement_listContext statement_list() { - return getRuleContext(Statement_listContext.class,0); - } - public BlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_block; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBlock(this); - } - } - - public final BlockContext block() throws RecognitionException { - BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_block); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1417); - match(OPEN_BRACE); - setState(1419); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BREAK) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << CONST) | (1L << CONTINUE) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DO) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FIXED) | (1L << FLOAT) | (1L << FOR) | (1L << FOREACH) | (1L << FROM) | (1L << GET) | (1L << GOTO) | (1L << GROUP) | (1L << IF) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LOCK) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (RETURN - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (SWITCH - 64)) | (1L << (THIS - 64)) | (1L << (THROW - 64)) | (1L << (TRUE - 64)) | (1L << (TRY - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (USING - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WHILE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1L << (OPEN_BRACE - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (SEMICOLON - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1418); - statement_list(); - } - } - - setState(1421); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_variable_declarationContext extends ParserRuleContext { - public Local_variable_typeContext local_variable_type() { - return getRuleContext(Local_variable_typeContext.class,0); - } - public List local_variable_declarator() { - return getRuleContexts(Local_variable_declaratorContext.class); - } - public Local_variable_declaratorContext local_variable_declarator(int i) { - return getRuleContext(Local_variable_declaratorContext.class,i); - } - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } - public Pointer_typeContext pointer_type() { - return getRuleContext(Pointer_typeContext.class,0); - } - public Fixed_pointer_declaratorsContext fixed_pointer_declarators() { - return getRuleContext(Fixed_pointer_declaratorsContext.class,0); - } - public Local_variable_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_variable_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_variable_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_variable_declaration(this); - } - } - - public final Local_variable_declarationContext local_variable_declaration() throws RecognitionException { - Local_variable_declarationContext _localctx = new Local_variable_declarationContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_local_variable_declaration); - int _la; - try { - setState(1442); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BOOL: - case BY: - case BYTE: - case CHAR: - case DECIMAL: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case STRING: - case UINT: - case ULONG: - case UNMANAGED: - case USHORT: - case USING: - case VAR: - case VOID: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case OPEN_PARENS: - enterOuterAlt(_localctx, 1); - { - setState(1427); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { - case 1: - { - setState(1423); - match(USING); - } - break; - case 2: - { - setState(1424); - match(REF); - } - break; - case 3: - { - setState(1425); - match(REF); - setState(1426); - match(READONLY); - } - break; - } - setState(1429); - local_variable_type(); - setState(1430); - local_variable_declarator(); - setState(1435); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1431); - match(COMMA); - setState(1432); - local_variable_declarator(); - } - } - setState(1437); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case FIXED: - enterOuterAlt(_localctx, 2); - { - setState(1438); - match(FIXED); - setState(1439); - pointer_type(); - setState(1440); - fixed_pointer_declarators(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_variable_typeContext extends ParserRuleContext { - public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Local_variable_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_variable_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_variable_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_variable_type(this); - } - } - - public final Local_variable_typeContext local_variable_type() throws RecognitionException { - Local_variable_typeContext _localctx = new Local_variable_typeContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_local_variable_type); - try { - setState(1446); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1444); - match(VAR); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1445); - type_(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_variable_declaratorContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Local_variable_initializerContext local_variable_initializer() { - return getRuleContext(Local_variable_initializerContext.class,0); - } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public Local_variable_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_variable_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_variable_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_variable_declarator(this); - } - } - - public final Local_variable_declaratorContext local_variable_declarator() throws RecognitionException { - Local_variable_declaratorContext _localctx = new Local_variable_declaratorContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_local_variable_declarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1448); - identifier(); - setState(1454); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASSIGNMENT) { - { - setState(1449); - match(ASSIGNMENT); - setState(1451); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { - case 1: - { - setState(1450); - match(REF); - } - break; - } - setState(1453); - local_variable_initializer(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_variable_initializerContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Array_initializerContext array_initializer() { - return getRuleContext(Array_initializerContext.class,0); - } - public Stackalloc_initializerContext stackalloc_initializer() { - return getRuleContext(Stackalloc_initializerContext.class,0); - } - public Local_variable_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_variable_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_variable_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_variable_initializer(this); - } - } - - public final Local_variable_initializerContext local_variable_initializer() throws RecognitionException { - Local_variable_initializerContext _localctx = new Local_variable_initializerContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_local_variable_initializer); - try { - setState(1459); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(1456); - expression(); - } - break; - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(1457); - array_initializer(); - } - break; - case STACKALLOC: - enterOuterAlt(_localctx, 3); - { - setState(1458); - stackalloc_initializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Local_constant_declarationContext extends ParserRuleContext { - public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Constant_declaratorsContext constant_declarators() { - return getRuleContext(Constant_declaratorsContext.class,0); - } - public Local_constant_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_local_constant_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLocal_constant_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLocal_constant_declaration(this); - } - } - - public final Local_constant_declarationContext local_constant_declaration() throws RecognitionException { - Local_constant_declarationContext _localctx = new Local_constant_declarationContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_local_constant_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(1461); - match(CONST); - setState(1462); - type_(); - setState(1463); - constant_declarators(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class If_bodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Simple_embedded_statementContext simple_embedded_statement() { - return getRuleContext(Simple_embedded_statementContext.class,0); - } - public If_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_if_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIf_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIf_body(this); - } - } - - public final If_bodyContext if_body() throws RecognitionException { - If_bodyContext _localctx = new If_bodyContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_if_body); - try { - setState(1467); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1465); - block(); - } - break; - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BREAK: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case CONTINUE: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DO: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FIXED: - case FLOAT: - case FOR: - case FOREACH: - case FROM: - case GET: - case GOTO: - case GROUP: - case IF: - case INT: - case INTO: - case JOIN: - case LET: - case LOCK: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case RETURN: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case SWITCH: - case THIS: - case THROW: - case TRUE: - case TRY: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case UNSAFE: - case USHORT: - case USING: - case VAR: - case WHEN: - case WHERE: - case WHILE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case SEMICOLON: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 2); - { - setState(1466); - simple_embedded_statement(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Switch_sectionContext extends ParserRuleContext { - public Statement_listContext statement_list() { - return getRuleContext(Statement_listContext.class,0); - } - public List switch_label() { - return getRuleContexts(Switch_labelContext.class); - } - public Switch_labelContext switch_label(int i) { - return getRuleContext(Switch_labelContext.class,i); - } - public Switch_sectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switch_section; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitch_section(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitch_section(this); - } - } - - public final Switch_sectionContext switch_section() throws RecognitionException { - Switch_sectionContext _localctx = new Switch_sectionContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_switch_section); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1470); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1469); - switch_label(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1472); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,153,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - setState(1474); - statement_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Switch_labelContext extends ParserRuleContext { - public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Case_guardContext case_guard() { - return getRuleContext(Case_guardContext.class,0); - } - public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } - public Switch_labelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switch_label; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSwitch_label(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSwitch_label(this); - } - } - - public final Switch_labelContext switch_label() throws RecognitionException { - Switch_labelContext _localctx = new Switch_labelContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_switch_label); - int _la; - try { - setState(1485); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CASE: - enterOuterAlt(_localctx, 1); - { - setState(1476); - match(CASE); - setState(1477); - expression(); - setState(1479); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHEN) { - { - setState(1478); - case_guard(); - } - } - - setState(1481); - match(COLON); - } - break; - case DEFAULT: - enterOuterAlt(_localctx, 2); - { - setState(1483); - match(DEFAULT); - setState(1484); - match(COLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Case_guardContext extends ParserRuleContext { - public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Case_guardContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_case_guard; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCase_guard(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCase_guard(this); - } - } - - public final Case_guardContext case_guard() throws RecognitionException { - Case_guardContext _localctx = new Case_guardContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_case_guard); - try { - enterOuterAlt(_localctx, 1); - { - setState(1487); - match(WHEN); - setState(1488); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Statement_listContext extends ParserRuleContext { - public List statement() { - return getRuleContexts(StatementContext.class); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public Statement_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statement_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStatement_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStatement_list(this); - } - } - - public final Statement_listContext statement_list() throws RecognitionException { - Statement_listContext _localctx = new Statement_listContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_statement_list); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1491); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1490); - statement(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1493); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,156,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class For_initializerContext extends ParserRuleContext { - public Local_variable_declarationContext local_variable_declaration() { - return getRuleContext(Local_variable_declarationContext.class,0); - } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public For_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_for_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFor_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFor_initializer(this); - } - } - - public final For_initializerContext for_initializer() throws RecognitionException { - For_initializerContext _localctx = new For_initializerContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_for_initializer); - int _la; - try { - setState(1504); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1495); - local_variable_declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1496); - expression(); - setState(1501); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1497); - match(COMMA); - setState(1498); - expression(); - } - } - setState(1503); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class For_iteratorContext extends ParserRuleContext { - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public For_iteratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_for_iterator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFor_iterator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFor_iterator(this); - } - } - - public final For_iteratorContext for_iterator() throws RecognitionException { - For_iteratorContext _localctx = new For_iteratorContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_for_iterator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1506); - expression(); - setState(1511); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1507); - match(COMMA); - setState(1508); - expression(); - } - } - setState(1513); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Catch_clausesContext extends ParserRuleContext { - public List specific_catch_clause() { - return getRuleContexts(Specific_catch_clauseContext.class); - } - public Specific_catch_clauseContext specific_catch_clause(int i) { - return getRuleContext(Specific_catch_clauseContext.class,i); - } - public General_catch_clauseContext general_catch_clause() { - return getRuleContext(General_catch_clauseContext.class,0); - } - public Catch_clausesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_catch_clauses; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCatch_clauses(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCatch_clauses(this); - } - } - - public final Catch_clausesContext catch_clauses() throws RecognitionException { - Catch_clausesContext _localctx = new Catch_clausesContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_catch_clauses); - int _la; - try { - int _alt; - setState(1525); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1514); - specific_catch_clause(); - setState(1518); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,160,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1515); - specific_catch_clause(); - } - } - } - setState(1520); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,160,_ctx); - } - setState(1522); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CATCH) { - { - setState(1521); - general_catch_clause(); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1524); - general_catch_clause(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Specific_catch_clauseContext extends ParserRuleContext { - public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Class_typeContext class_type() { - return getRuleContext(Class_typeContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Exception_filterContext exception_filter() { - return getRuleContext(Exception_filterContext.class,0); - } - public Specific_catch_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_specific_catch_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSpecific_catch_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSpecific_catch_clause(this); - } - } - - public final Specific_catch_clauseContext specific_catch_clause() throws RecognitionException { - Specific_catch_clauseContext _localctx = new Specific_catch_clauseContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_specific_catch_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1527); - match(CATCH); - setState(1528); - match(OPEN_PARENS); - setState(1529); - class_type(); - setState(1531); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { - { - setState(1530); - identifier(); - } - } - - setState(1533); - match(CLOSE_PARENS); - setState(1535); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHEN) { - { - setState(1534); - exception_filter(); - } - } - - setState(1537); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class General_catch_clauseContext extends ParserRuleContext { - public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Exception_filterContext exception_filter() { - return getRuleContext(Exception_filterContext.class,0); - } - public General_catch_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_general_catch_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGeneral_catch_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGeneral_catch_clause(this); - } - } - - public final General_catch_clauseContext general_catch_clause() throws RecognitionException { - General_catch_clauseContext _localctx = new General_catch_clauseContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_general_catch_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1539); - match(CATCH); - setState(1541); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHEN) { - { - setState(1540); - exception_filter(); - } - } - - setState(1543); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Exception_filterContext extends ParserRuleContext { - public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Exception_filterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_exception_filter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterException_filter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitException_filter(this); - } - } - - public final Exception_filterContext exception_filter() throws RecognitionException { - Exception_filterContext _localctx = new Exception_filterContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_exception_filter); - try { - enterOuterAlt(_localctx, 1); - { - setState(1545); - match(WHEN); - setState(1546); - match(OPEN_PARENS); - setState(1547); - expression(); - setState(1548); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Finally_clauseContext extends ParserRuleContext { - public TerminalNode FINALLY() { return getToken(CSharpParser.FINALLY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Finally_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_finally_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFinally_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFinally_clause(this); - } - } - - public final Finally_clauseContext finally_clause() throws RecognitionException { - Finally_clauseContext _localctx = new Finally_clauseContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_finally_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1550); - match(FINALLY); - setState(1551); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Resource_acquisitionContext extends ParserRuleContext { - public Local_variable_declarationContext local_variable_declaration() { - return getRuleContext(Local_variable_declarationContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Resource_acquisitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_resource_acquisition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterResource_acquisition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitResource_acquisition(this); - } - } - - public final Resource_acquisitionContext resource_acquisition() throws RecognitionException { - Resource_acquisitionContext _localctx = new Resource_acquisitionContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_resource_acquisition); - try { - setState(1555); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1553); - local_variable_declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1554); - expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Namespace_declarationContext extends ParserRuleContext { - public Qualified_identifierContext qi; - public TerminalNode NAMESPACE() { return getToken(CSharpParser.NAMESPACE, 0); } - public Namespace_bodyContext namespace_body() { - return getRuleContext(Namespace_bodyContext.class,0); - } - public Qualified_identifierContext qualified_identifier() { - return getRuleContext(Qualified_identifierContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Namespace_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_namespace_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNamespace_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNamespace_declaration(this); - } - } - - public final Namespace_declarationContext namespace_declaration() throws RecognitionException { - Namespace_declarationContext _localctx = new Namespace_declarationContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_namespace_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1557); - match(NAMESPACE); - setState(1558); - ((Namespace_declarationContext)_localctx).qi = qualified_identifier(); - setState(1559); - namespace_body(); - setState(1561); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(1560); - match(SEMICOLON); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Qualified_identifierContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List DOT() { return getTokens(CSharpParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(CSharpParser.DOT, i); - } - public Qualified_identifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_qualified_identifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQualified_identifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQualified_identifier(this); - } - } - - public final Qualified_identifierContext qualified_identifier() throws RecognitionException { - Qualified_identifierContext _localctx = new Qualified_identifierContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_qualified_identifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1563); - identifier(); - setState(1568); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==DOT) { - { - { - setState(1564); - match(DOT); - setState(1565); - identifier(); - } - } - setState(1570); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Namespace_bodyContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Extern_alias_directivesContext extern_alias_directives() { - return getRuleContext(Extern_alias_directivesContext.class,0); - } - public Using_directivesContext using_directives() { - return getRuleContext(Using_directivesContext.class,0); - } - public Namespace_member_declarationsContext namespace_member_declarations() { - return getRuleContext(Namespace_member_declarationsContext.class,0); - } - public Namespace_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_namespace_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNamespace_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNamespace_body(this); - } - } - - public final Namespace_bodyContext namespace_body() throws RecognitionException { - Namespace_bodyContext _localctx = new Namespace_bodyContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_namespace_body); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1571); - match(OPEN_BRACE); - setState(1573); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { - case 1: - { - setState(1572); - extern_alias_directives(); - } - break; - } - setState(1576); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(1575); - using_directives(); - } - } - - setState(1579); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0)) { - { - setState(1578); - namespace_member_declarations(); - } - } - - setState(1581); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Extern_alias_directivesContext extends ParserRuleContext { - public List extern_alias_directive() { - return getRuleContexts(Extern_alias_directiveContext.class); - } - public Extern_alias_directiveContext extern_alias_directive(int i) { - return getRuleContext(Extern_alias_directiveContext.class,i); - } - public Extern_alias_directivesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_extern_alias_directives; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExtern_alias_directives(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExtern_alias_directives(this); - } - } - - public final Extern_alias_directivesContext extern_alias_directives() throws RecognitionException { - Extern_alias_directivesContext _localctx = new Extern_alias_directivesContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_extern_alias_directives); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1584); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1583); - extern_alias_directive(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1586); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,172,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Extern_alias_directiveContext extends ParserRuleContext { - public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } - public TerminalNode ALIAS() { return getToken(CSharpParser.ALIAS, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Extern_alias_directiveContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_extern_alias_directive; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterExtern_alias_directive(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitExtern_alias_directive(this); - } - } - - public final Extern_alias_directiveContext extern_alias_directive() throws RecognitionException { - Extern_alias_directiveContext _localctx = new Extern_alias_directiveContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_extern_alias_directive); - try { - enterOuterAlt(_localctx, 1); - { - setState(1588); - match(EXTERN); - setState(1589); - match(ALIAS); - setState(1590); - identifier(); - setState(1591); - match(SEMICOLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Using_directivesContext extends ParserRuleContext { - public List using_directive() { - return getRuleContexts(Using_directiveContext.class); - } - public Using_directiveContext using_directive(int i) { - return getRuleContext(Using_directiveContext.class,i); - } - public Using_directivesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_using_directives; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUsing_directives(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUsing_directives(this); - } - } - - public final Using_directivesContext using_directives() throws RecognitionException { - Using_directivesContext _localctx = new Using_directivesContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_using_directives); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1594); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1593); - using_directive(); - } - } - setState(1596); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==USING ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Using_directiveContext extends ParserRuleContext { - public Using_directiveContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_using_directive; } - - public Using_directiveContext() { } - public void copyFrom(Using_directiveContext ctx) { - super.copyFrom(ctx); - } - } - public static class UsingAliasDirectiveContext extends Using_directiveContext { - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public UsingAliasDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUsingAliasDirective(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUsingAliasDirective(this); - } - } - public static class UsingNamespaceDirectiveContext extends Using_directiveContext { - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public UsingNamespaceDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUsingNamespaceDirective(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUsingNamespaceDirective(this); - } - } - public static class UsingStaticDirectiveContext extends Using_directiveContext { - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public UsingStaticDirectiveContext(Using_directiveContext ctx) { copyFrom(ctx); } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterUsingStaticDirective(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitUsingStaticDirective(this); - } - } - - public final Using_directiveContext using_directive() throws RecognitionException { - Using_directiveContext _localctx = new Using_directiveContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_using_directive); - try { - setState(1613); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { - case 1: - _localctx = new UsingAliasDirectiveContext(_localctx); - enterOuterAlt(_localctx, 1); - { - setState(1598); - match(USING); - setState(1599); - identifier(); - setState(1600); - match(ASSIGNMENT); - setState(1601); - namespace_or_type_name(); - setState(1602); - match(SEMICOLON); - } - break; - case 2: - _localctx = new UsingNamespaceDirectiveContext(_localctx); - enterOuterAlt(_localctx, 2); - { - setState(1604); - match(USING); - setState(1605); - namespace_or_type_name(); - setState(1606); - match(SEMICOLON); - } - break; - case 3: - _localctx = new UsingStaticDirectiveContext(_localctx); - enterOuterAlt(_localctx, 3); - { - setState(1608); - match(USING); - setState(1609); - match(STATIC); - setState(1610); - namespace_or_type_name(); - setState(1611); - match(SEMICOLON); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Namespace_member_declarationsContext extends ParserRuleContext { - public List namespace_member_declaration() { - return getRuleContexts(Namespace_member_declarationContext.class); - } - public Namespace_member_declarationContext namespace_member_declaration(int i) { - return getRuleContext(Namespace_member_declarationContext.class,i); - } - public Namespace_member_declarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_namespace_member_declarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNamespace_member_declarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNamespace_member_declarations(this); - } - } - - public final Namespace_member_declarationsContext namespace_member_declarations() throws RecognitionException { - Namespace_member_declarationsContext _localctx = new Namespace_member_declarationsContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_namespace_member_declarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1616); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1615); - namespace_member_declaration(); - } - } - setState(1618); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << CLASS) | (1L << DELEGATE) | (1L << ENUM) | (1L << EXTERN) | (1L << INTERFACE) | (1L << INTERNAL))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARTIAL - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (SEALED - 65)) | (1L << (STATIC - 65)) | (1L << (STRUCT - 65)) | (1L << (UNSAFE - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOLATILE - 65)) | (1L << (OPEN_BRACKET - 65)))) != 0) ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Namespace_member_declarationContext extends ParserRuleContext { - public Namespace_declarationContext namespace_declaration() { - return getRuleContext(Namespace_declarationContext.class,0); - } - public Type_declarationContext type_declaration() { - return getRuleContext(Type_declarationContext.class,0); - } - public Namespace_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_namespace_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterNamespace_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitNamespace_member_declaration(this); - } - } - - public final Namespace_member_declarationContext namespace_member_declaration() throws RecognitionException { - Namespace_member_declarationContext _localctx = new Namespace_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_namespace_member_declaration); - try { - setState(1622); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NAMESPACE: - enterOuterAlt(_localctx, 1); - { - setState(1620); - namespace_declaration(); - } - break; - case ABSTRACT: - case ASYNC: - case CLASS: - case DELEGATE: - case ENUM: - case EXTERN: - case INTERFACE: - case INTERNAL: - case NEW: - case OVERRIDE: - case PARTIAL: - case PRIVATE: - case PROTECTED: - case PUBLIC: - case READONLY: - case REF: - case SEALED: - case STATIC: - case STRUCT: - case UNSAFE: - case VIRTUAL: - case VOLATILE: - case OPEN_BRACKET: - enterOuterAlt(_localctx, 2); - { - setState(1621); - type_declaration(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_declarationContext extends ParserRuleContext { - public Class_definitionContext class_definition() { - return getRuleContext(Class_definitionContext.class,0); - } - public Struct_definitionContext struct_definition() { - return getRuleContext(Struct_definitionContext.class,0); - } - public Interface_definitionContext interface_definition() { - return getRuleContext(Interface_definitionContext.class,0); - } - public Enum_definitionContext enum_definition() { - return getRuleContext(Enum_definitionContext.class,0); - } - public Delegate_definitionContext delegate_definition() { - return getRuleContext(Delegate_definitionContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public All_member_modifiersContext all_member_modifiers() { - return getRuleContext(All_member_modifiersContext.class,0); - } - public Type_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_declaration(this); - } - } - - public final Type_declarationContext type_declaration() throws RecognitionException { - Type_declarationContext _localctx = new Type_declarationContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_type_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1625); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1624); - attributes(); - } - } - - setState(1628); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { - case 1: - { - setState(1627); - all_member_modifiers(); - } - break; - } - setState(1635); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CLASS: - { - setState(1630); - class_definition(); - } - break; - case READONLY: - case REF: - case STRUCT: - { - setState(1631); - struct_definition(); - } - break; - case INTERFACE: - { - setState(1632); - interface_definition(); - } - break; - case ENUM: - { - setState(1633); - enum_definition(); - } - break; - case DELEGATE: - { - setState(1634); - delegate_definition(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Qualified_alias_memberContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } - public Type_argument_listContext type_argument_list() { - return getRuleContext(Type_argument_listContext.class,0); - } - public Qualified_alias_memberContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_qualified_alias_member; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterQualified_alias_member(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitQualified_alias_member(this); - } - } - - public final Qualified_alias_memberContext qualified_alias_member() throws RecognitionException { - Qualified_alias_memberContext _localctx = new Qualified_alias_memberContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_qualified_alias_member); - try { - enterOuterAlt(_localctx, 1); - { - setState(1637); - identifier(); - setState(1638); - match(DOUBLE_COLON); - setState(1639); - identifier(); - setState(1641); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { - case 1: - { - setState(1640); - type_argument_list(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_parameter_listContext extends ParserRuleContext { - public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } - public List type_parameter() { - return getRuleContexts(Type_parameterContext.class); - } - public Type_parameterContext type_parameter(int i) { - return getRuleContext(Type_parameterContext.class,i); - } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Type_parameter_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_parameter_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_parameter_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_parameter_list(this); - } - } - - public final Type_parameter_listContext type_parameter_list() throws RecognitionException { - Type_parameter_listContext _localctx = new Type_parameter_listContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_type_parameter_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1643); - match(LT); - setState(1644); - type_parameter(); - setState(1649); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1645); - match(COMMA); - setState(1646); - type_parameter(); - } - } - setState(1651); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1652); - match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_parameterContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Type_parameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_parameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_parameter(this); - } - } - - public final Type_parameterContext type_parameter() throws RecognitionException { - Type_parameterContext _localctx = new Type_parameterContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_type_parameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1655); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1654); - attributes(); - } - } - - setState(1657); - identifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_baseContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Class_typeContext class_type() { - return getRuleContext(Class_typeContext.class,0); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public List namespace_or_type_name() { - return getRuleContexts(Namespace_or_type_nameContext.class); - } - public Namespace_or_type_nameContext namespace_or_type_name(int i) { - return getRuleContext(Namespace_or_type_nameContext.class,i); - } - public Class_baseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_base; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_base(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_base(this); - } - } - - public final Class_baseContext class_base() throws RecognitionException { - Class_baseContext _localctx = new Class_baseContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_class_base); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1659); - match(COLON); - setState(1660); - class_type(); - setState(1665); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1661); - match(COMMA); - setState(1662); - namespace_or_type_name(); - } - } - setState(1667); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_type_listContext extends ParserRuleContext { - public List namespace_or_type_name() { - return getRuleContexts(Namespace_or_type_nameContext.class); - } - public Namespace_or_type_nameContext namespace_or_type_name(int i) { - return getRuleContext(Namespace_or_type_nameContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Interface_type_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_type_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_type_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_type_list(this); - } - } - - public final Interface_type_listContext interface_type_list() throws RecognitionException { - Interface_type_listContext _localctx = new Interface_type_listContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_interface_type_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1668); - namespace_or_type_name(); - setState(1673); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1669); - match(COMMA); - setState(1670); - namespace_or_type_name(); - } - } - setState(1675); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_parameter_constraints_clausesContext extends ParserRuleContext { - public List type_parameter_constraints_clause() { - return getRuleContexts(Type_parameter_constraints_clauseContext.class); - } - public Type_parameter_constraints_clauseContext type_parameter_constraints_clause(int i) { - return getRuleContext(Type_parameter_constraints_clauseContext.class,i); - } - public Type_parameter_constraints_clausesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_parameter_constraints_clauses; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_parameter_constraints_clauses(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_parameter_constraints_clauses(this); - } - } - - public final Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() throws RecognitionException { - Type_parameter_constraints_clausesContext _localctx = new Type_parameter_constraints_clausesContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_type_parameter_constraints_clauses); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1677); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1676); - type_parameter_constraints_clause(); - } - } - setState(1679); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==WHERE ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_parameter_constraints_clauseContext extends ParserRuleContext { - public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Type_parameter_constraintsContext type_parameter_constraints() { - return getRuleContext(Type_parameter_constraintsContext.class,0); - } - public Type_parameter_constraints_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_parameter_constraints_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_parameter_constraints_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_parameter_constraints_clause(this); - } - } - - public final Type_parameter_constraints_clauseContext type_parameter_constraints_clause() throws RecognitionException { - Type_parameter_constraints_clauseContext _localctx = new Type_parameter_constraints_clauseContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_type_parameter_constraints_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(1681); - match(WHERE); - setState(1682); - identifier(); - setState(1683); - match(COLON); - setState(1684); - type_parameter_constraints(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Type_parameter_constraintsContext extends ParserRuleContext { - public Constructor_constraintContext constructor_constraint() { - return getRuleContext(Constructor_constraintContext.class,0); - } - public Primary_constraintContext primary_constraint() { - return getRuleContext(Primary_constraintContext.class,0); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Secondary_constraintsContext secondary_constraints() { - return getRuleContext(Secondary_constraintsContext.class,0); - } - public Type_parameter_constraintsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_parameter_constraints; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterType_parameter_constraints(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitType_parameter_constraints(this); - } - } - - public final Type_parameter_constraintsContext type_parameter_constraints() throws RecognitionException { - Type_parameter_constraintsContext _localctx = new Type_parameter_constraintsContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_type_parameter_constraints); - int _la; - try { - setState(1696); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NEW: - enterOuterAlt(_localctx, 1); - { - setState(1686); - constructor_constraint(); - } - break; - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BY: - case CLASS: - case DESCENDING: - case DYNAMIC: - case EQUALS: - case FROM: - case GET: - case GROUP: - case INTO: - case JOIN: - case LET: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SELECT: - case SET: - case STRING: - case STRUCT: - case UNMANAGED: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - enterOuterAlt(_localctx, 2); - { - setState(1687); - primary_constraint(); - setState(1690); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) { - case 1: - { - setState(1688); - match(COMMA); - setState(1689); - secondary_constraints(); - } - break; - } - setState(1694); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(1692); - match(COMMA); - setState(1693); - constructor_constraint(); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Primary_constraintContext extends ParserRuleContext { - public Class_typeContext class_type() { - return getRuleContext(Class_typeContext.class,0); - } - public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } - public TerminalNode INTERR() { return getToken(CSharpParser.INTERR, 0); } - public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } - public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } - public Primary_constraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primary_constraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterPrimary_constraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitPrimary_constraint(this); - } - } - - public final Primary_constraintContext primary_constraint() throws RecognitionException { - Primary_constraintContext _localctx = new Primary_constraintContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_primary_constraint); - int _la; - try { - setState(1705); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1698); - class_type(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1699); - match(CLASS); - setState(1701); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTERR) { - { - setState(1700); - match(INTERR); - } - } - - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1703); - match(STRUCT); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1704); - match(UNMANAGED); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Secondary_constraintsContext extends ParserRuleContext { - public List namespace_or_type_name() { - return getRuleContexts(Namespace_or_type_nameContext.class); - } - public Namespace_or_type_nameContext namespace_or_type_name(int i) { - return getRuleContext(Namespace_or_type_nameContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Secondary_constraintsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_secondary_constraints; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSecondary_constraints(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSecondary_constraints(this); - } - } - - public final Secondary_constraintsContext secondary_constraints() throws RecognitionException { - Secondary_constraintsContext _localctx = new Secondary_constraintsContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_secondary_constraints); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1707); - namespace_or_type_name(); - setState(1712); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,191,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1708); - match(COMMA); - setState(1709); - namespace_or_type_name(); - } - } - } - setState(1714); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,191,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constructor_constraintContext extends ParserRuleContext { - public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Constructor_constraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructor_constraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstructor_constraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstructor_constraint(this); - } - } - - public final Constructor_constraintContext constructor_constraint() throws RecognitionException { - Constructor_constraintContext _localctx = new Constructor_constraintContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_constructor_constraint); - try { - enterOuterAlt(_localctx, 1); - { - setState(1715); - match(NEW); - setState(1716); - match(OPEN_PARENS); - setState(1717); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_bodyContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Class_member_declarationsContext class_member_declarations() { - return getRuleContext(Class_member_declarationsContext.class,0); - } - public Class_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_body(this); - } - } - - public final Class_bodyContext class_body() throws RecognitionException { - Class_bodyContext _localctx = new Class_bodyContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_class_body); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1719); - match(OPEN_BRACE); - setState(1721); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONST) | (1L << DECIMAL) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << ENUM) | (1L << EQUALS) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IMPLICIT) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OVERRIDE - 64)) | (1L << (PARTIAL - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (PUBLIC - 64)) | (1L << (READONLY - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SEALED - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (STRUCT - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VIRTUAL - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0) || _la==OPEN_PARENS || _la==TILDE) { - { - setState(1720); - class_member_declarations(); - } - } - - setState(1723); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_member_declarationsContext extends ParserRuleContext { - public List class_member_declaration() { - return getRuleContexts(Class_member_declarationContext.class); - } - public Class_member_declarationContext class_member_declaration(int i) { - return getRuleContext(Class_member_declarationContext.class,i); - } - public Class_member_declarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_member_declarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_member_declarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_member_declarations(this); - } - } - - public final Class_member_declarationsContext class_member_declarations() throws RecognitionException { - Class_member_declarationsContext _localctx = new Class_member_declarationsContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_class_member_declarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1726); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1725); - class_member_declaration(); - } - } - setState(1728); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONST) | (1L << DECIMAL) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << ENUM) | (1L << EQUALS) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IMPLICIT) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OVERRIDE - 64)) | (1L << (PARTIAL - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (PUBLIC - 64)) | (1L << (READONLY - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SEALED - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRING - 64)) | (1L << (STRUCT - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNMANAGED - 64)) | (1L << (UNSAFE - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VIRTUAL - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0) || _la==OPEN_PARENS || _la==TILDE ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_member_declarationContext extends ParserRuleContext { - public Common_member_declarationContext common_member_declaration() { - return getRuleContext(Common_member_declarationContext.class,0); - } - public Destructor_definitionContext destructor_definition() { - return getRuleContext(Destructor_definitionContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public All_member_modifiersContext all_member_modifiers() { - return getRuleContext(All_member_modifiersContext.class,0); - } - public Class_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_member_declaration(this); - } - } - - public final Class_member_declarationContext class_member_declaration() throws RecognitionException { - Class_member_declarationContext _localctx = new Class_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_class_member_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1731); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1730); - attributes(); - } - } - - setState(1734); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { - case 1: - { - setState(1733); - all_member_modifiers(); - } - break; - } - setState(1738); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CLASS: - case CONST: - case DECIMAL: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case ENUM: - case EQUALS: - case EVENT: - case EXPLICIT: - case FLOAT: - case FROM: - case GET: - case GROUP: - case IMPLICIT: - case INT: - case INTERFACE: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case READONLY: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case STRING: - case STRUCT: - case UINT: - case ULONG: - case UNMANAGED: - case USHORT: - case VAR: - case VOID: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case OPEN_PARENS: - { - setState(1736); - common_member_declaration(); - } - break; - case TILDE: - { - setState(1737); - destructor_definition(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class All_member_modifiersContext extends ParserRuleContext { - public List all_member_modifier() { - return getRuleContexts(All_member_modifierContext.class); - } - public All_member_modifierContext all_member_modifier(int i) { - return getRuleContext(All_member_modifierContext.class,i); - } - public All_member_modifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_all_member_modifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAll_member_modifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAll_member_modifiers(this); - } - } - - public final All_member_modifiersContext all_member_modifiers() throws RecognitionException { - All_member_modifiersContext _localctx = new All_member_modifiersContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_all_member_modifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1741); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1740); - all_member_modifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1743); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,197,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class All_member_modifierContext extends ParserRuleContext { - public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } - public TerminalNode PUBLIC() { return getToken(CSharpParser.PUBLIC, 0); } - public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } - public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } - public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public TerminalNode VOLATILE() { return getToken(CSharpParser.VOLATILE, 0); } - public TerminalNode VIRTUAL() { return getToken(CSharpParser.VIRTUAL, 0); } - public TerminalNode SEALED() { return getToken(CSharpParser.SEALED, 0); } - public TerminalNode OVERRIDE() { return getToken(CSharpParser.OVERRIDE, 0); } - public TerminalNode ABSTRACT() { return getToken(CSharpParser.ABSTRACT, 0); } - public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } - public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } - public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } - public TerminalNode PARTIAL() { return getToken(CSharpParser.PARTIAL, 0); } - public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } - public All_member_modifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_all_member_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAll_member_modifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAll_member_modifier(this); - } - } - - public final All_member_modifierContext all_member_modifier() throws RecognitionException { - All_member_modifierContext _localctx = new All_member_modifierContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_all_member_modifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1745); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASYNC) | (1L << EXTERN) | (1L << INTERNAL))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (NEW - 66)) | (1L << (OVERRIDE - 66)) | (1L << (PARTIAL - 66)) | (1L << (PRIVATE - 66)) | (1L << (PROTECTED - 66)) | (1L << (PUBLIC - 66)) | (1L << (READONLY - 66)) | (1L << (SEALED - 66)) | (1L << (STATIC - 66)) | (1L << (UNSAFE - 66)) | (1L << (VIRTUAL - 66)) | (1L << (VOLATILE - 66)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Common_member_declarationContext extends ParserRuleContext { - public Constant_declarationContext constant_declaration() { - return getRuleContext(Constant_declarationContext.class,0); - } - public Typed_member_declarationContext typed_member_declaration() { - return getRuleContext(Typed_member_declarationContext.class,0); - } - public Event_declarationContext event_declaration() { - return getRuleContext(Event_declarationContext.class,0); - } - public Conversion_operator_declaratorContext conversion_operator_declarator() { - return getRuleContext(Conversion_operator_declaratorContext.class,0); - } - public BodyContext body() { - return getRuleContext(BodyContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Constructor_declarationContext constructor_declaration() { - return getRuleContext(Constructor_declarationContext.class,0); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public Method_declarationContext method_declaration() { - return getRuleContext(Method_declarationContext.class,0); - } - public Class_definitionContext class_definition() { - return getRuleContext(Class_definitionContext.class,0); - } - public Struct_definitionContext struct_definition() { - return getRuleContext(Struct_definitionContext.class,0); - } - public Interface_definitionContext interface_definition() { - return getRuleContext(Interface_definitionContext.class,0); - } - public Enum_definitionContext enum_definition() { - return getRuleContext(Enum_definitionContext.class,0); - } - public Delegate_definitionContext delegate_definition() { - return getRuleContext(Delegate_definitionContext.class,0); - } - public Common_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_common_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterCommon_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitCommon_member_declaration(this); - } - } - - public final Common_member_declarationContext common_member_declaration() throws RecognitionException { - Common_member_declarationContext _localctx = new Common_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_common_member_declaration); - try { - setState(1766); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1747); - constant_declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1748); - typed_member_declaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1749); - event_declaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1750); - conversion_operator_declarator(); - setState(1756); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - case SEMICOLON: - { - setState(1751); - body(); - } - break; - case ASSIGNMENT: - { - setState(1752); - right_arrow(); - setState(1753); - throwable_expression(); - setState(1754); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1758); - constructor_declaration(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1759); - match(VOID); - setState(1760); - method_declaration(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1761); - class_definition(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1762); - struct_definition(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1763); - interface_definition(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1764); - enum_definition(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(1765); - delegate_definition(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Typed_member_declarationContext extends ParserRuleContext { - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode DOT() { return getToken(CSharpParser.DOT, 0); } - public Indexer_declarationContext indexer_declaration() { - return getRuleContext(Indexer_declarationContext.class,0); - } - public Method_declarationContext method_declaration() { - return getRuleContext(Method_declarationContext.class,0); - } - public Property_declarationContext property_declaration() { - return getRuleContext(Property_declarationContext.class,0); - } - public Operator_declarationContext operator_declaration() { - return getRuleContext(Operator_declarationContext.class,0); - } - public Field_declarationContext field_declaration() { - return getRuleContext(Field_declarationContext.class,0); - } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public Typed_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typed_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterTyped_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitTyped_member_declaration(this); - } - } - - public final Typed_member_declarationContext typed_member_declaration() throws RecognitionException { - Typed_member_declarationContext _localctx = new Typed_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_typed_member_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(1773); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { - case 1: - { - setState(1768); - match(REF); - } - break; - case 2: - { - setState(1769); - match(READONLY); - setState(1770); - match(REF); - } - break; - case 3: - { - setState(1771); - match(REF); - setState(1772); - match(READONLY); - } - break; - } - setState(1775); - type_(); - setState(1785); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { - case 1: - { - setState(1776); - namespace_or_type_name(); - setState(1777); - match(DOT); - setState(1778); - indexer_declaration(); - } - break; - case 2: - { - setState(1780); - method_declaration(); - } - break; - case 3: - { - setState(1781); - property_declaration(); - } - break; - case 4: - { - setState(1782); - indexer_declaration(); - } - break; - case 5: - { - setState(1783); - operator_declaration(); - } - break; - case 6: - { - setState(1784); - field_declaration(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constant_declaratorsContext extends ParserRuleContext { - public List constant_declarator() { - return getRuleContexts(Constant_declaratorContext.class); - } - public Constant_declaratorContext constant_declarator(int i) { - return getRuleContext(Constant_declaratorContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Constant_declaratorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constant_declarators; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstant_declarators(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstant_declarators(this); - } - } - - public final Constant_declaratorsContext constant_declarators() throws RecognitionException { - Constant_declaratorsContext _localctx = new Constant_declaratorsContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_constant_declarators); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1787); - constant_declarator(); - setState(1792); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1788); - match(COMMA); - setState(1789); - constant_declarator(); - } - } - setState(1794); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constant_declaratorContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Constant_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constant_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstant_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstant_declarator(this); - } - } - - public final Constant_declaratorContext constant_declarator() throws RecognitionException { - Constant_declaratorContext _localctx = new Constant_declaratorContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_constant_declarator); - try { - enterOuterAlt(_localctx, 1); - { - setState(1795); - identifier(); - setState(1796); - match(ASSIGNMENT); - setState(1797); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variable_declaratorsContext extends ParserRuleContext { - public List variable_declarator() { - return getRuleContexts(Variable_declaratorContext.class); - } - public Variable_declaratorContext variable_declarator(int i) { - return getRuleContext(Variable_declaratorContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Variable_declaratorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variable_declarators; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariable_declarators(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariable_declarators(this); - } - } - - public final Variable_declaratorsContext variable_declarators() throws RecognitionException { - Variable_declaratorsContext _localctx = new Variable_declaratorsContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_variable_declarators); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1799); - variable_declarator(); - setState(1804); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1800); - match(COMMA); - setState(1801); - variable_declarator(); - } - } - setState(1806); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variable_declaratorContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Variable_initializerContext variable_initializer() { - return getRuleContext(Variable_initializerContext.class,0); - } - public Variable_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variable_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariable_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariable_declarator(this); - } - } - - public final Variable_declaratorContext variable_declarator() throws RecognitionException { - Variable_declaratorContext _localctx = new Variable_declaratorContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_variable_declarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1807); - identifier(); - setState(1810); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASSIGNMENT) { - { - setState(1808); - match(ASSIGNMENT); - setState(1809); - variable_initializer(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variable_initializerContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Array_initializerContext array_initializer() { - return getRuleContext(Array_initializerContext.class,0); - } - public Variable_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variable_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariable_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariable_initializer(this); - } - } - - public final Variable_initializerContext variable_initializer() throws RecognitionException { - Variable_initializerContext _localctx = new Variable_initializerContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_variable_initializer); - try { - setState(1814); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(1812); - expression(); - } - break; - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(1813); - array_initializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Return_typeContext extends ParserRuleContext { - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public Return_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_return_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterReturn_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitReturn_type(this); - } - } - - public final Return_typeContext return_type() throws RecognitionException { - Return_typeContext _localctx = new Return_typeContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_return_type); - try { - setState(1818); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1816); - type_(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1817); - match(VOID); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Member_nameContext extends ParserRuleContext { - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public Member_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_member_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMember_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMember_name(this); - } - } - - public final Member_nameContext member_name() throws RecognitionException { - Member_nameContext _localctx = new Member_nameContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_member_name); - try { - enterOuterAlt(_localctx, 1); - { - setState(1820); - namespace_or_type_name(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Method_bodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Method_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_method_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMethod_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMethod_body(this); - } - } - - public final Method_bodyContext method_body() throws RecognitionException { - Method_bodyContext _localctx = new Method_bodyContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_method_body); - try { - setState(1824); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1822); - block(); - } - break; - case SEMICOLON: - enterOuterAlt(_localctx, 2); - { - setState(1823); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Formal_parameter_listContext extends ParserRuleContext { - public Parameter_arrayContext parameter_array() { - return getRuleContext(Parameter_arrayContext.class,0); - } - public Fixed_parametersContext fixed_parameters() { - return getRuleContext(Fixed_parametersContext.class,0); - } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Formal_parameter_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_formal_parameter_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFormal_parameter_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFormal_parameter_list(this); - } - } - - public final Formal_parameter_listContext formal_parameter_list() throws RecognitionException { - Formal_parameter_listContext _localctx = new Formal_parameter_listContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_formal_parameter_list); - int _la; - try { - setState(1832); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1826); - parameter_array(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1827); - fixed_parameters(); - setState(1830); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(1828); - match(COMMA); - setState(1829); - parameter_array(); - } - } - - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_parametersContext extends ParserRuleContext { - public List fixed_parameter() { - return getRuleContexts(Fixed_parameterContext.class); - } - public Fixed_parameterContext fixed_parameter(int i) { - return getRuleContext(Fixed_parameterContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Fixed_parametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_parameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_parameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_parameters(this); - } - } - - public final Fixed_parametersContext fixed_parameters() throws RecognitionException { - Fixed_parametersContext _localctx = new Fixed_parametersContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_fixed_parameters); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1834); - fixed_parameter(); - setState(1839); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,210,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1835); - match(COMMA); - setState(1836); - fixed_parameter(); - } - } - } - setState(1841); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,210,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_parameterContext extends ParserRuleContext { - public Arg_declarationContext arg_declaration() { - return getRuleContext(Arg_declarationContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Parameter_modifierContext parameter_modifier() { - return getRuleContext(Parameter_modifierContext.class,0); - } - public TerminalNode ARGLIST() { return getToken(CSharpParser.ARGLIST, 0); } - public Fixed_parameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_parameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_parameter(this); - } - } - - public final Fixed_parameterContext fixed_parameter() throws RecognitionException { - Fixed_parameterContext _localctx = new Fixed_parameterContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_fixed_parameter); - int _la; - try { - setState(1850); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1843); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1842); - attributes(); - } - } - - setState(1846); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & ((1L << (IN - 54)) | (1L << (OUT - 54)) | (1L << (REF - 54)) | (1L << (THIS - 54)))) != 0)) { - { - setState(1845); - parameter_modifier(); - } - } - - setState(1848); - arg_declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1849); - match(ARGLIST); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Parameter_modifierContext extends ParserRuleContext { - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public Parameter_modifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameter_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterParameter_modifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitParameter_modifier(this); - } - } - - public final Parameter_modifierContext parameter_modifier() throws RecognitionException { - Parameter_modifierContext _localctx = new Parameter_modifierContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_parameter_modifier); - try { - setState(1860); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1852); - match(REF); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1853); - match(OUT); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1854); - match(IN); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1855); - match(REF); - setState(1856); - match(THIS); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1857); - match(IN); - setState(1858); - match(THIS); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1859); - match(THIS); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Parameter_arrayContext extends ParserRuleContext { - public TerminalNode PARAMS() { return getToken(CSharpParser.PARAMS, 0); } - public Array_typeContext array_type() { - return getRuleContext(Array_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Parameter_arrayContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameter_array; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterParameter_array(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitParameter_array(this); - } - } - - public final Parameter_arrayContext parameter_array() throws RecognitionException { - Parameter_arrayContext _localctx = new Parameter_arrayContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_parameter_array); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1863); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1862); - attributes(); - } - } - - setState(1865); - match(PARAMS); - setState(1866); - array_type(); - setState(1867); - identifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Accessor_declarationsContext extends ParserRuleContext { - public AttributesContext attrs; - public Accessor_modifierContext mods; - public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } - public Accessor_bodyContext accessor_body() { - return getRuleContext(Accessor_bodyContext.class,0); - } - public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Accessor_modifierContext accessor_modifier() { - return getRuleContext(Accessor_modifierContext.class,0); - } - public Set_accessor_declarationContext set_accessor_declaration() { - return getRuleContext(Set_accessor_declarationContext.class,0); - } - public Get_accessor_declarationContext get_accessor_declaration() { - return getRuleContext(Get_accessor_declarationContext.class,0); - } - public Accessor_declarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_accessor_declarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAccessor_declarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAccessor_declarations(this); - } - } - - public final Accessor_declarationsContext accessor_declarations() throws RecognitionException { - Accessor_declarationsContext _localctx = new Accessor_declarationsContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_accessor_declarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1870); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1869); - ((Accessor_declarationsContext)_localctx).attrs = attributes(); - } - } - - setState(1873); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { - { - setState(1872); - ((Accessor_declarationsContext)_localctx).mods = accessor_modifier(); - } - } - - setState(1885); - _errHandler.sync(this); - switch (_input.LA(1)) { - case GET: - { - setState(1875); - match(GET); - setState(1876); - accessor_body(); - setState(1878); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (PRIVATE - 76)) | (1L << (PROTECTED - 76)) | (1L << (SET - 76)) | (1L << (OPEN_BRACKET - 76)))) != 0)) { - { - setState(1877); - set_accessor_declaration(); - } - } - - } - break; - case SET: - { - setState(1880); - match(SET); - setState(1881); - accessor_body(); - setState(1883); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==GET || _la==INTERNAL || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (PRIVATE - 76)) | (1L << (PROTECTED - 76)) | (1L << (OPEN_BRACKET - 76)))) != 0)) { - { - setState(1882); - get_accessor_declaration(); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Get_accessor_declarationContext extends ParserRuleContext { - public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } - public Accessor_bodyContext accessor_body() { - return getRuleContext(Accessor_bodyContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Accessor_modifierContext accessor_modifier() { - return getRuleContext(Accessor_modifierContext.class,0); - } - public Get_accessor_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_get_accessor_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGet_accessor_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGet_accessor_declaration(this); - } - } - - public final Get_accessor_declarationContext get_accessor_declaration() throws RecognitionException { - Get_accessor_declarationContext _localctx = new Get_accessor_declarationContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_get_accessor_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1888); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1887); - attributes(); - } - } - - setState(1891); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { - { - setState(1890); - accessor_modifier(); - } - } - - setState(1893); - match(GET); - setState(1894); - accessor_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Set_accessor_declarationContext extends ParserRuleContext { - public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } - public Accessor_bodyContext accessor_body() { - return getRuleContext(Accessor_bodyContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Accessor_modifierContext accessor_modifier() { - return getRuleContext(Accessor_modifierContext.class,0); - } - public Set_accessor_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_set_accessor_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterSet_accessor_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitSet_accessor_declaration(this); - } - } - - public final Set_accessor_declarationContext set_accessor_declaration() throws RecognitionException { - Set_accessor_declarationContext _localctx = new Set_accessor_declarationContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_set_accessor_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1897); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1896); - attributes(); - } - } - - setState(1900); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (INTERNAL - 57)) | (1L << (PRIVATE - 57)) | (1L << (PROTECTED - 57)))) != 0)) { - { - setState(1899); - accessor_modifier(); - } - } - - setState(1902); - match(SET); - setState(1903); - accessor_body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Accessor_modifierContext extends ParserRuleContext { - public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } - public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } - public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } - public Accessor_modifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_accessor_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAccessor_modifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAccessor_modifier(this); - } - } - - public final Accessor_modifierContext accessor_modifier() throws RecognitionException { - Accessor_modifierContext _localctx = new Accessor_modifierContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_accessor_modifier); - try { - setState(1912); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1905); - match(PROTECTED); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1906); - match(INTERNAL); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1907); - match(PRIVATE); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1908); - match(PROTECTED); - setState(1909); - match(INTERNAL); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1910); - match(INTERNAL); - setState(1911); - match(PROTECTED); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Accessor_bodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Accessor_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_accessor_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAccessor_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAccessor_body(this); - } - } - - public final Accessor_bodyContext accessor_body() throws RecognitionException { - Accessor_bodyContext _localctx = new Accessor_bodyContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_accessor_body); - try { - setState(1916); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1914); - block(); - } - break; - case SEMICOLON: - enterOuterAlt(_localctx, 2); - { - setState(1915); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Event_accessor_declarationsContext extends ParserRuleContext { - public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public Remove_accessor_declarationContext remove_accessor_declaration() { - return getRuleContext(Remove_accessor_declarationContext.class,0); - } - public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } - public Add_accessor_declarationContext add_accessor_declaration() { - return getRuleContext(Add_accessor_declarationContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Event_accessor_declarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_event_accessor_declarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEvent_accessor_declarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEvent_accessor_declarations(this); - } - } - - public final Event_accessor_declarationsContext event_accessor_declarations() throws RecognitionException { - Event_accessor_declarationsContext _localctx = new Event_accessor_declarationsContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_event_accessor_declarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1919); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1918); - attributes(); - } - } - - setState(1929); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - { - setState(1921); - match(ADD); - setState(1922); - block(); - setState(1923); - remove_accessor_declaration(); - } - break; - case REMOVE: - { - setState(1925); - match(REMOVE); - setState(1926); - block(); - setState(1927); - add_accessor_declaration(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Add_accessor_declarationContext extends ParserRuleContext { - public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Add_accessor_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_add_accessor_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAdd_accessor_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAdd_accessor_declaration(this); - } - } - - public final Add_accessor_declarationContext add_accessor_declaration() throws RecognitionException { - Add_accessor_declarationContext _localctx = new Add_accessor_declarationContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_add_accessor_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1932); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1931); - attributes(); - } - } - - setState(1934); - match(ADD); - setState(1935); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Remove_accessor_declarationContext extends ParserRuleContext { - public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Remove_accessor_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_remove_accessor_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRemove_accessor_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRemove_accessor_declaration(this); - } - } - - public final Remove_accessor_declarationContext remove_accessor_declaration() throws RecognitionException { - Remove_accessor_declarationContext _localctx = new Remove_accessor_declarationContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_remove_accessor_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1938); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1937); - attributes(); - } - } - - setState(1940); - match(REMOVE); - setState(1941); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Overloadable_operatorContext extends ParserRuleContext { - public TerminalNode PLUS() { return getToken(CSharpParser.PLUS, 0); } - public TerminalNode MINUS() { return getToken(CSharpParser.MINUS, 0); } - public TerminalNode BANG() { return getToken(CSharpParser.BANG, 0); } - public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } - public TerminalNode OP_INC() { return getToken(CSharpParser.OP_INC, 0); } - public TerminalNode OP_DEC() { return getToken(CSharpParser.OP_DEC, 0); } - public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } - public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } - public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } - public TerminalNode DIV() { return getToken(CSharpParser.DIV, 0); } - public TerminalNode PERCENT() { return getToken(CSharpParser.PERCENT, 0); } - public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } - public TerminalNode BITWISE_OR() { return getToken(CSharpParser.BITWISE_OR, 0); } - public TerminalNode CARET() { return getToken(CSharpParser.CARET, 0); } - public TerminalNode OP_LEFT_SHIFT() { return getToken(CSharpParser.OP_LEFT_SHIFT, 0); } - public Right_shiftContext right_shift() { - return getRuleContext(Right_shiftContext.class,0); - } - public TerminalNode OP_EQ() { return getToken(CSharpParser.OP_EQ, 0); } - public TerminalNode OP_NE() { return getToken(CSharpParser.OP_NE, 0); } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } - public TerminalNode OP_GE() { return getToken(CSharpParser.OP_GE, 0); } - public TerminalNode OP_LE() { return getToken(CSharpParser.OP_LE, 0); } - public Overloadable_operatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_overloadable_operator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterOverloadable_operator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitOverloadable_operator(this); - } - } - - public final Overloadable_operatorContext overloadable_operator() throws RecognitionException { - Overloadable_operatorContext _localctx = new Overloadable_operatorContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_overloadable_operator); - try { - setState(1965); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1943); - match(PLUS); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1944); - match(MINUS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1945); - match(BANG); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1946); - match(TILDE); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1947); - match(OP_INC); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1948); - match(OP_DEC); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1949); - match(TRUE); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1950); - match(FALSE); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1951); - match(STAR); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1952); - match(DIV); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(1953); - match(PERCENT); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(1954); - match(AMP); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(1955); - match(BITWISE_OR); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(1956); - match(CARET); - } - break; - case 15: - enterOuterAlt(_localctx, 15); - { - setState(1957); - match(OP_LEFT_SHIFT); - } - break; - case 16: - enterOuterAlt(_localctx, 16); - { - setState(1958); - right_shift(); - } - break; - case 17: - enterOuterAlt(_localctx, 17); - { - setState(1959); - match(OP_EQ); - } - break; - case 18: - enterOuterAlt(_localctx, 18); - { - setState(1960); - match(OP_NE); - } - break; - case 19: - enterOuterAlt(_localctx, 19); - { - setState(1961); - match(GT); - } - break; - case 20: - enterOuterAlt(_localctx, 20); - { - setState(1962); - match(LT); - } - break; - case 21: - enterOuterAlt(_localctx, 21); - { - setState(1963); - match(OP_GE); - } - break; - case 22: - enterOuterAlt(_localctx, 22); - { - setState(1964); - match(OP_LE); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Conversion_operator_declaratorContext extends ParserRuleContext { - public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public Arg_declarationContext arg_declaration() { - return getRuleContext(Arg_declarationContext.class,0); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode IMPLICIT() { return getToken(CSharpParser.IMPLICIT, 0); } - public TerminalNode EXPLICIT() { return getToken(CSharpParser.EXPLICIT, 0); } - public Conversion_operator_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conversion_operator_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConversion_operator_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConversion_operator_declarator(this); - } - } - - public final Conversion_operator_declaratorContext conversion_operator_declarator() throws RecognitionException { - Conversion_operator_declaratorContext _localctx = new Conversion_operator_declaratorContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_conversion_operator_declarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1967); - _la = _input.LA(1); - if ( !(_la==EXPLICIT || _la==IMPLICIT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1968); - match(OPERATOR); - setState(1969); - type_(); - setState(1970); - match(OPEN_PARENS); - setState(1971); - arg_declaration(); - setState(1972); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constructor_initializerContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public Argument_listContext argument_list() { - return getRuleContext(Argument_listContext.class,0); - } - public Constructor_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructor_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstructor_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstructor_initializer(this); - } - } - - public final Constructor_initializerContext constructor_initializer() throws RecognitionException { - Constructor_initializerContext _localctx = new Constructor_initializerContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_constructor_initializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1974); - match(COLON); - setState(1975); - _la = _input.LA(1); - if ( !(_la==BASE || _la==THIS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1976); - match(OPEN_PARENS); - setState(1978); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(1977); - argument_list(); - } - } - - setState(1980); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public BodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBody(this); - } - } - - public final BodyContext body() throws RecognitionException { - BodyContext _localctx = new BodyContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_body); - try { - setState(1984); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(1982); - block(); - } - break; - case SEMICOLON: - enterOuterAlt(_localctx, 2); - { - setState(1983); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Struct_interfacesContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Interface_type_listContext interface_type_list() { - return getRuleContext(Interface_type_listContext.class,0); - } - public Struct_interfacesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_struct_interfaces; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStruct_interfaces(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStruct_interfaces(this); - } - } - - public final Struct_interfacesContext struct_interfaces() throws RecognitionException { - Struct_interfacesContext _localctx = new Struct_interfacesContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_struct_interfaces); - try { - enterOuterAlt(_localctx, 1); - { - setState(1986); - match(COLON); - setState(1987); - interface_type_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Struct_bodyContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List struct_member_declaration() { - return getRuleContexts(Struct_member_declarationContext.class); - } - public Struct_member_declarationContext struct_member_declaration(int i) { - return getRuleContext(Struct_member_declarationContext.class,i); - } - public Struct_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_struct_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStruct_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStruct_body(this); - } - } - - public final Struct_bodyContext struct_body() throws RecognitionException { - Struct_bodyContext _localctx = new Struct_bodyContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_struct_body); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1989); - match(OPEN_BRACE); - setState(1993); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & ((1L << (ABSTRACT - 9)) | (1L << (ADD - 9)) | (1L << (ALIAS - 9)) | (1L << (ARGLIST - 9)) | (1L << (ASCENDING - 9)) | (1L << (ASYNC - 9)) | (1L << (AWAIT - 9)) | (1L << (BOOL - 9)) | (1L << (BY - 9)) | (1L << (BYTE - 9)) | (1L << (CHAR - 9)) | (1L << (CLASS - 9)) | (1L << (CONST - 9)) | (1L << (DECIMAL - 9)) | (1L << (DELEGATE - 9)) | (1L << (DESCENDING - 9)) | (1L << (DOUBLE - 9)) | (1L << (DYNAMIC - 9)) | (1L << (ENUM - 9)) | (1L << (EQUALS - 9)) | (1L << (EVENT - 9)) | (1L << (EXPLICIT - 9)) | (1L << (EXTERN - 9)) | (1L << (FIXED - 9)) | (1L << (FLOAT - 9)) | (1L << (FROM - 9)) | (1L << (GET - 9)) | (1L << (GROUP - 9)) | (1L << (IMPLICIT - 9)) | (1L << (INT - 9)) | (1L << (INTERFACE - 9)) | (1L << (INTERNAL - 9)) | (1L << (INTO - 9)) | (1L << (JOIN - 9)) | (1L << (LET - 9)) | (1L << (LONG - 9)) | (1L << (NAMEOF - 9)) | (1L << (NEW - 9)) | (1L << (OBJECT - 9)) | (1L << (ON - 9)) | (1L << (ORDERBY - 9)))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (OVERRIDE - 73)) | (1L << (PARTIAL - 73)) | (1L << (PRIVATE - 73)) | (1L << (PROTECTED - 73)) | (1L << (PUBLIC - 73)) | (1L << (READONLY - 73)) | (1L << (REF - 73)) | (1L << (REMOVE - 73)) | (1L << (SBYTE - 73)) | (1L << (SEALED - 73)) | (1L << (SELECT - 73)) | (1L << (SET - 73)) | (1L << (SHORT - 73)) | (1L << (STATIC - 73)) | (1L << (STRING - 73)) | (1L << (STRUCT - 73)) | (1L << (UINT - 73)) | (1L << (ULONG - 73)) | (1L << (UNMANAGED - 73)) | (1L << (UNSAFE - 73)) | (1L << (USHORT - 73)) | (1L << (VAR - 73)) | (1L << (VIRTUAL - 73)) | (1L << (VOID - 73)) | (1L << (VOLATILE - 73)) | (1L << (WHEN - 73)) | (1L << (WHERE - 73)) | (1L << (YIELD - 73)) | (1L << (IDENTIFIER - 73)) | (1L << (OPEN_BRACKET - 73)) | (1L << (OPEN_PARENS - 73)))) != 0)) { - { - { - setState(1990); - struct_member_declaration(); - } - } - setState(1995); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1996); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Struct_member_declarationContext extends ParserRuleContext { - public Common_member_declarationContext common_member_declaration() { - return getRuleContext(Common_member_declarationContext.class,0); - } - public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public All_member_modifiersContext all_member_modifiers() { - return getRuleContext(All_member_modifiersContext.class,0); - } - public List fixed_size_buffer_declarator() { - return getRuleContexts(Fixed_size_buffer_declaratorContext.class); - } - public Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator(int i) { - return getRuleContext(Fixed_size_buffer_declaratorContext.class,i); - } - public Struct_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_struct_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStruct_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStruct_member_declaration(this); - } - } - - public final Struct_member_declarationContext struct_member_declaration() throws RecognitionException { - Struct_member_declarationContext _localctx = new Struct_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_struct_member_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1999); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(1998); - attributes(); - } - } - - setState(2002); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) { - case 1: - { - setState(2001); - all_member_modifiers(); - } - break; - } - setState(2014); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CLASS: - case CONST: - case DECIMAL: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case ENUM: - case EQUALS: - case EVENT: - case EXPLICIT: - case FLOAT: - case FROM: - case GET: - case GROUP: - case IMPLICIT: - case INT: - case INTERFACE: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case READONLY: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case STRING: - case STRUCT: - case UINT: - case ULONG: - case UNMANAGED: - case USHORT: - case VAR: - case VOID: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case OPEN_PARENS: - { - setState(2004); - common_member_declaration(); - } - break; - case FIXED: - { - setState(2005); - match(FIXED); - setState(2006); - type_(); - setState(2008); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(2007); - fixed_size_buffer_declarator(); - } - } - setState(2010); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0) ); - setState(2012); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Array_typeContext extends ParserRuleContext { - public Base_typeContext base_type() { - return getRuleContext(Base_typeContext.class,0); - } - public List rank_specifier() { - return getRuleContexts(Rank_specifierContext.class); - } - public Rank_specifierContext rank_specifier(int i) { - return getRuleContext(Rank_specifierContext.class,i); - } - public List STAR() { return getTokens(CSharpParser.STAR); } - public TerminalNode STAR(int i) { - return getToken(CSharpParser.STAR, i); - } - public List INTERR() { return getTokens(CSharpParser.INTERR); } - public TerminalNode INTERR(int i) { - return getToken(CSharpParser.INTERR, i); - } - public Array_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_array_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterArray_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitArray_type(this); - } - } - - public final Array_typeContext array_type() throws RecognitionException { - Array_typeContext _localctx = new Array_typeContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_array_type); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2016); - base_type(); - setState(2024); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(2020); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==STAR || _la==INTERR) { - { - { - setState(2017); - _la = _input.LA(1); - if ( !(_la==STAR || _la==INTERR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - setState(2022); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2023); - rank_specifier(); - } - } - setState(2026); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 127)) & ~0x3f) == 0 && ((1L << (_la - 127)) & ((1L << (OPEN_BRACKET - 127)) | (1L << (STAR - 127)) | (1L << (INTERR - 127)))) != 0) ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Rank_specifierContext extends ParserRuleContext { - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Rank_specifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rank_specifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRank_specifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRank_specifier(this); - } - } - - public final Rank_specifierContext rank_specifier() throws RecognitionException { - Rank_specifierContext _localctx = new Rank_specifierContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_rank_specifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2028); - match(OPEN_BRACKET); - setState(2032); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2029); - match(COMMA); - } - } - setState(2034); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2035); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Array_initializerContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List variable_initializer() { - return getRuleContexts(Variable_initializerContext.class); - } - public Variable_initializerContext variable_initializer(int i) { - return getRuleContext(Variable_initializerContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Array_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_array_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterArray_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitArray_initializer(this); - } - } - - public final Array_initializerContext array_initializer() throws RecognitionException { - Array_initializerContext _localctx = new Array_initializerContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_array_initializer); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2037); - match(OPEN_BRACE); - setState(2049); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1L << (OPEN_BRACE - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(2038); - variable_initializer(); - setState(2043); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,242,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2039); - match(COMMA); - setState(2040); - variable_initializer(); - } - } - } - setState(2045); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,242,_ctx); - } - setState(2047); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2046); - match(COMMA); - } - } - - } - } - - setState(2051); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variant_type_parameter_listContext extends ParserRuleContext { - public TerminalNode LT() { return getToken(CSharpParser.LT, 0); } - public List variant_type_parameter() { - return getRuleContexts(Variant_type_parameterContext.class); - } - public Variant_type_parameterContext variant_type_parameter(int i) { - return getRuleContext(Variant_type_parameterContext.class,i); - } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Variant_type_parameter_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variant_type_parameter_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariant_type_parameter_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariant_type_parameter_list(this); - } - } - - public final Variant_type_parameter_listContext variant_type_parameter_list() throws RecognitionException { - Variant_type_parameter_listContext _localctx = new Variant_type_parameter_listContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_variant_type_parameter_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2053); - match(LT); - setState(2054); - variant_type_parameter(); - setState(2059); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2055); - match(COMMA); - setState(2056); - variant_type_parameter(); - } - } - setState(2061); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2062); - match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variant_type_parameterContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public Variance_annotationContext variance_annotation() { - return getRuleContext(Variance_annotationContext.class,0); - } - public Variant_type_parameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variant_type_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariant_type_parameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariant_type_parameter(this); - } - } - - public final Variant_type_parameterContext variant_type_parameter() throws RecognitionException { - Variant_type_parameterContext _localctx = new Variant_type_parameterContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_variant_type_parameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2065); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2064); - attributes(); - } - } - - setState(2068); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==OUT) { - { - setState(2067); - variance_annotation(); - } - } - - setState(2070); - identifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Variance_annotationContext extends ParserRuleContext { - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } - public Variance_annotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variance_annotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterVariance_annotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitVariance_annotation(this); - } - } - - public final Variance_annotationContext variance_annotation() throws RecognitionException { - Variance_annotationContext _localctx = new Variance_annotationContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_variance_annotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2072); - _la = _input.LA(1); - if ( !(_la==IN || _la==OUT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_baseContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Interface_type_listContext interface_type_list() { - return getRuleContext(Interface_type_listContext.class,0); - } - public Interface_baseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_base; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_base(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_base(this); - } - } - - public final Interface_baseContext interface_base() throws RecognitionException { - Interface_baseContext _localctx = new Interface_baseContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_interface_base); - try { - enterOuterAlt(_localctx, 1); - { - setState(2074); - match(COLON); - setState(2075); - interface_type_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_bodyContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List interface_member_declaration() { - return getRuleContexts(Interface_member_declarationContext.class); - } - public Interface_member_declarationContext interface_member_declaration(int i) { - return getRuleContext(Interface_member_declarationContext.class,i); - } - public Interface_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_body(this); - } - } - - public final Interface_bodyContext interface_body() throws RecognitionException { - Interface_bodyContext _localctx = new Interface_bodyContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_interface_body); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2077); - match(OPEN_BRACE); - setState(2081); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (EVENT - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (NEW - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (READONLY - 75)) | (1L << (REF - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (UNSAFE - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_BRACKET - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { - { - { - setState(2078); - interface_member_declaration(); - } - } - setState(2083); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2084); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_member_declarationContext extends ParserRuleContext { - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public Interface_accessorsContext interface_accessors() { - return getRuleContext(Interface_accessorsContext.class,0); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public Type_parameter_listContext type_parameter_list() { - return getRuleContext(Type_parameter_listContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public Interface_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_member_declaration(this); - } - } - - public final Interface_member_declarationContext interface_member_declaration() throws RecognitionException { - Interface_member_declarationContext _localctx = new Interface_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_interface_member_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2087); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2086); - attributes(); - } - } - - setState(2090); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NEW) { - { - setState(2089); - match(NEW); - } - } - - setState(2155); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) { - case 1: - { - setState(2093); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==UNSAFE) { - { - setState(2092); - match(UNSAFE); - } - } - - setState(2100); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { - case 1: - { - setState(2095); - match(REF); - } - break; - case 2: - { - setState(2096); - match(REF); - setState(2097); - match(READONLY); - } - break; - case 3: - { - setState(2098); - match(READONLY); - setState(2099); - match(REF); - } - break; - } - setState(2102); - type_(); - setState(2130); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,256,_ctx) ) { - case 1: - { - setState(2103); - identifier(); - setState(2105); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2104); - type_parameter_list(); - } - } - - setState(2107); - match(OPEN_PARENS); - setState(2109); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(2108); - formal_parameter_list(); - } - } - - setState(2111); - match(CLOSE_PARENS); - setState(2113); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2112); - type_parameter_constraints_clauses(); - } - } - - setState(2115); - match(SEMICOLON); - } - break; - case 2: - { - setState(2117); - identifier(); - setState(2118); - match(OPEN_BRACE); - setState(2119); - interface_accessors(); - setState(2120); - match(CLOSE_BRACE); - } - break; - case 3: - { - setState(2122); - match(THIS); - setState(2123); - match(OPEN_BRACKET); - setState(2124); - formal_parameter_list(); - setState(2125); - match(CLOSE_BRACKET); - setState(2126); - match(OPEN_BRACE); - setState(2127); - interface_accessors(); - setState(2128); - match(CLOSE_BRACE); - } - break; - } - } - break; - case 2: - { - setState(2133); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==UNSAFE) { - { - setState(2132); - match(UNSAFE); - } - } - - setState(2135); - match(VOID); - setState(2136); - identifier(); - setState(2138); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2137); - type_parameter_list(); - } - } - - setState(2140); - match(OPEN_PARENS); - setState(2142); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(2141); - formal_parameter_list(); - } - } - - setState(2144); - match(CLOSE_PARENS); - setState(2146); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2145); - type_parameter_constraints_clauses(); - } - } - - setState(2148); - match(SEMICOLON); - } - break; - case 3: - { - setState(2150); - match(EVENT); - setState(2151); - type_(); - setState(2152); - identifier(); - setState(2153); - match(SEMICOLON); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_accessorsContext extends ParserRuleContext { - public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } - public List SEMICOLON() { return getTokens(CSharpParser.SEMICOLON); } - public TerminalNode SEMICOLON(int i) { - return getToken(CSharpParser.SEMICOLON, i); - } - public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } - public List attributes() { - return getRuleContexts(AttributesContext.class); - } - public AttributesContext attributes(int i) { - return getRuleContext(AttributesContext.class,i); - } - public Interface_accessorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_accessors; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_accessors(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_accessors(this); - } - } - - public final Interface_accessorsContext interface_accessors() throws RecognitionException { - Interface_accessorsContext _localctx = new Interface_accessorsContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_interface_accessors); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2158); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2157); - attributes(); - } - } - - setState(2178); - _errHandler.sync(this); - switch (_input.LA(1)) { - case GET: - { - setState(2160); - match(GET); - setState(2161); - match(SEMICOLON); - setState(2167); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SET || _la==OPEN_BRACKET) { - { - setState(2163); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2162); - attributes(); - } - } - - setState(2165); - match(SET); - setState(2166); - match(SEMICOLON); - } - } - - } - break; - case SET: - { - setState(2169); - match(SET); - setState(2170); - match(SEMICOLON); - setState(2176); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==GET || _la==OPEN_BRACKET) { - { - setState(2172); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2171); - attributes(); - } - } - - setState(2174); - match(GET); - setState(2175); - match(SEMICOLON); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Enum_baseContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Enum_baseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enum_base; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEnum_base(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEnum_base(this); - } - } - - public final Enum_baseContext enum_base() throws RecognitionException { - Enum_baseContext _localctx = new Enum_baseContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_enum_base); - try { - enterOuterAlt(_localctx, 1); - { - setState(2180); - match(COLON); - setState(2181); - type_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Enum_bodyContext extends ParserRuleContext { - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List enum_member_declaration() { - return getRuleContexts(Enum_member_declarationContext.class); - } - public Enum_member_declarationContext enum_member_declaration(int i) { - return getRuleContext(Enum_member_declarationContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Enum_bodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enum_body; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEnum_body(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEnum_body(this); - } - } - - public final Enum_bodyContext enum_body() throws RecognitionException { - Enum_bodyContext _localctx = new Enum_bodyContext(_ctx, getState()); - enterRule(_localctx, 342, RULE_enum_body); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2183); - match(OPEN_BRACE); - setState(2195); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (OPEN_BRACKET - 64)))) != 0)) { - { - setState(2184); - enum_member_declaration(); - setState(2189); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,268,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2185); - match(COMMA); - setState(2186); - enum_member_declaration(); - } - } - } - setState(2191); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,268,_ctx); - } - setState(2193); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2192); - match(COMMA); - } - } - - } - } - - setState(2197); - match(CLOSE_BRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Enum_member_declarationContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public AttributesContext attributes() { - return getRuleContext(AttributesContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Enum_member_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enum_member_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEnum_member_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEnum_member_declaration(this); - } - } - - public final Enum_member_declarationContext enum_member_declaration() throws RecognitionException { - Enum_member_declarationContext _localctx = new Enum_member_declarationContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_enum_member_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2200); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACKET) { - { - setState(2199); - attributes(); - } - } - - setState(2202); - identifier(); - setState(2205); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASSIGNMENT) { - { - setState(2203); - match(ASSIGNMENT); - setState(2204); - expression(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Global_attribute_sectionContext extends ParserRuleContext { - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Global_attribute_targetContext global_attribute_target() { - return getRuleContext(Global_attribute_targetContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Attribute_listContext attribute_list() { - return getRuleContext(Attribute_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Global_attribute_sectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_global_attribute_section; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGlobal_attribute_section(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGlobal_attribute_section(this); - } - } - - public final Global_attribute_sectionContext global_attribute_section() throws RecognitionException { - Global_attribute_sectionContext _localctx = new Global_attribute_sectionContext(_ctx, getState()); - enterRule(_localctx, 346, RULE_global_attribute_section); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2207); - match(OPEN_BRACKET); - setState(2208); - global_attribute_target(); - setState(2209); - match(COLON); - setState(2210); - attribute_list(); - setState(2212); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2211); - match(COMMA); - } - } - - setState(2214); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Global_attribute_targetContext extends ParserRuleContext { - public KeywordContext keyword() { - return getRuleContext(KeywordContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Global_attribute_targetContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_global_attribute_target; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterGlobal_attribute_target(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitGlobal_attribute_target(this); - } - } - - public final Global_attribute_targetContext global_attribute_target() throws RecognitionException { - Global_attribute_targetContext _localctx = new Global_attribute_targetContext(_ctx, getState()); - enterRule(_localctx, 348, RULE_global_attribute_target); - try { - setState(2218); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2216); - keyword(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2217); - identifier(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AttributesContext extends ParserRuleContext { - public List attribute_section() { - return getRuleContexts(Attribute_sectionContext.class); - } - public Attribute_sectionContext attribute_section(int i) { - return getRuleContext(Attribute_sectionContext.class,i); - } - public AttributesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attributes; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttributes(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttributes(this); - } - } - - public final AttributesContext attributes() throws RecognitionException { - AttributesContext _localctx = new AttributesContext(_ctx, getState()); - enterRule(_localctx, 350, RULE_attributes); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2221); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(2220); - attribute_section(); - } - } - setState(2223); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==OPEN_BRACKET ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Attribute_sectionContext extends ParserRuleContext { - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Attribute_listContext attribute_list() { - return getRuleContext(Attribute_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public Attribute_targetContext attribute_target() { - return getRuleContext(Attribute_targetContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Attribute_sectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attribute_section; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttribute_section(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttribute_section(this); - } - } - - public final Attribute_sectionContext attribute_section() throws RecognitionException { - Attribute_sectionContext _localctx = new Attribute_sectionContext(_ctx, getState()); - enterRule(_localctx, 352, RULE_attribute_section); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2225); - match(OPEN_BRACKET); - setState(2229); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) { - case 1: - { - setState(2226); - attribute_target(); - setState(2227); - match(COLON); - } - break; - } - setState(2231); - attribute_list(); - setState(2233); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2232); - match(COMMA); - } - } - - setState(2235); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Attribute_targetContext extends ParserRuleContext { - public KeywordContext keyword() { - return getRuleContext(KeywordContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Attribute_targetContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attribute_target; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttribute_target(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttribute_target(this); - } - } - - public final Attribute_targetContext attribute_target() throws RecognitionException { - Attribute_targetContext _localctx = new Attribute_targetContext(_ctx, getState()); - enterRule(_localctx, 354, RULE_attribute_target); - try { - setState(2239); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2237); - keyword(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2238); - identifier(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Attribute_listContext extends ParserRuleContext { - public List attribute() { - return getRuleContexts(AttributeContext.class); - } - public AttributeContext attribute(int i) { - return getRuleContext(AttributeContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Attribute_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attribute_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttribute_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttribute_list(this); - } - } - - public final Attribute_listContext attribute_list() throws RecognitionException { - Attribute_listContext _localctx = new Attribute_listContext(_ctx, getState()); - enterRule(_localctx, 356, RULE_attribute_list); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2241); - attribute(); - setState(2246); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,279,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2242); - match(COMMA); - setState(2243); - attribute(); - } - } - } - setState(2248); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,279,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AttributeContext extends ParserRuleContext { - public Namespace_or_type_nameContext namespace_or_type_name() { - return getRuleContext(Namespace_or_type_nameContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public List attribute_argument() { - return getRuleContexts(Attribute_argumentContext.class); - } - public Attribute_argumentContext attribute_argument(int i) { - return getRuleContext(Attribute_argumentContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public AttributeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attribute; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttribute(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttribute(this); - } - } - - public final AttributeContext attribute() throws RecognitionException { - AttributeContext _localctx = new AttributeContext(_ctx, getState()); - enterRule(_localctx, 358, RULE_attribute); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2249); - namespace_or_type_name(); - setState(2262); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PARENS) { - { - setState(2250); - match(OPEN_PARENS); - setState(2259); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(2251); - attribute_argument(); - setState(2256); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2252); - match(COMMA); - setState(2253); - attribute_argument(); - } - } - setState(2258); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(2261); - match(CLOSE_PARENS); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Attribute_argumentContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public Attribute_argumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_attribute_argument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterAttribute_argument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitAttribute_argument(this); - } - } - - public final Attribute_argumentContext attribute_argument() throws RecognitionException { - Attribute_argumentContext _localctx = new Attribute_argumentContext(_ctx, getState()); - enterRule(_localctx, 360, RULE_attribute_argument); - try { - enterOuterAlt(_localctx, 1); - { - setState(2267); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) { - case 1: - { - setState(2264); - identifier(); - setState(2265); - match(COLON); - } - break; - } - setState(2269); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Pointer_typeContext extends ParserRuleContext { - public TerminalNode STAR() { return getToken(CSharpParser.STAR, 0); } - public Simple_typeContext simple_type() { - return getRuleContext(Simple_typeContext.class,0); - } - public Class_typeContext class_type() { - return getRuleContext(Class_typeContext.class,0); - } - public List rank_specifier() { - return getRuleContexts(Rank_specifierContext.class); - } - public Rank_specifierContext rank_specifier(int i) { - return getRuleContext(Rank_specifierContext.class,i); - } - public List INTERR() { return getTokens(CSharpParser.INTERR); } - public TerminalNode INTERR(int i) { - return getToken(CSharpParser.INTERR, i); - } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public Pointer_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_pointer_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterPointer_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitPointer_type(this); - } - } - - public final Pointer_typeContext pointer_type() throws RecognitionException { - Pointer_typeContext _localctx = new Pointer_typeContext(_ctx, getState()); - enterRule(_localctx, 362, RULE_pointer_type); - int _la; - try { - setState(2286); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BOOL: - case BY: - case BYTE: - case CHAR: - case DECIMAL: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case STRING: - case UINT: - case ULONG: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - enterOuterAlt(_localctx, 1); - { - setState(2273); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BOOL: - case BYTE: - case CHAR: - case DECIMAL: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SBYTE: - case SHORT: - case UINT: - case ULONG: - case USHORT: - { - setState(2271); - simple_type(); - } - break; - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BY: - case DESCENDING: - case DYNAMIC: - case EQUALS: - case FROM: - case GET: - case GROUP: - case INTO: - case JOIN: - case LET: - case NAMEOF: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REMOVE: - case SELECT: - case SET: - case STRING: - case UNMANAGED: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - { - setState(2272); - class_type(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(2279); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==OPEN_BRACKET || _la==INTERR) { - { - setState(2277); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACKET: - { - setState(2275); - rank_specifier(); - } - break; - case INTERR: - { - setState(2276); - match(INTERR); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(2281); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2282); - match(STAR); - } - break; - case VOID: - enterOuterAlt(_localctx, 2); - { - setState(2284); - match(VOID); - setState(2285); - match(STAR); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_pointer_declaratorsContext extends ParserRuleContext { - public List fixed_pointer_declarator() { - return getRuleContexts(Fixed_pointer_declaratorContext.class); - } - public Fixed_pointer_declaratorContext fixed_pointer_declarator(int i) { - return getRuleContext(Fixed_pointer_declaratorContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Fixed_pointer_declaratorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_pointer_declarators; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_pointer_declarators(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_pointer_declarators(this); - } - } - - public final Fixed_pointer_declaratorsContext fixed_pointer_declarators() throws RecognitionException { - Fixed_pointer_declaratorsContext _localctx = new Fixed_pointer_declaratorsContext(_ctx, getState()); - enterRule(_localctx, 364, RULE_fixed_pointer_declarators); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2288); - fixed_pointer_declarator(); - setState(2293); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2289); - match(COMMA); - setState(2290); - fixed_pointer_declarator(); - } - } - setState(2295); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_pointer_declaratorContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Fixed_pointer_initializerContext fixed_pointer_initializer() { - return getRuleContext(Fixed_pointer_initializerContext.class,0); - } - public Fixed_pointer_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_pointer_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_pointer_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_pointer_declarator(this); - } - } - - public final Fixed_pointer_declaratorContext fixed_pointer_declarator() throws RecognitionException { - Fixed_pointer_declaratorContext _localctx = new Fixed_pointer_declaratorContext(_ctx, getState()); - enterRule(_localctx, 366, RULE_fixed_pointer_declarator); - try { - enterOuterAlt(_localctx, 1); - { - setState(2296); - identifier(); - setState(2297); - match(ASSIGNMENT); - setState(2298); - fixed_pointer_initializer(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_pointer_initializerContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode AMP() { return getToken(CSharpParser.AMP, 0); } - public Stackalloc_initializerContext stackalloc_initializer() { - return getRuleContext(Stackalloc_initializerContext.class,0); - } - public Fixed_pointer_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_pointer_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_pointer_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_pointer_initializer(this); - } - } - - public final Fixed_pointer_initializerContext fixed_pointer_initializer() throws RecognitionException { - Fixed_pointer_initializerContext _localctx = new Fixed_pointer_initializerContext(_ctx, getState()); - enterRule(_localctx, 368, RULE_fixed_pointer_initializer); - try { - setState(2305); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(2301); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) { - case 1: - { - setState(2300); - match(AMP); - } - break; - } - setState(2303); - expression(); - } - break; - case STACKALLOC: - enterOuterAlt(_localctx, 2); - { - setState(2304); - stackalloc_initializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Fixed_size_buffer_declaratorContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public Fixed_size_buffer_declaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fixed_size_buffer_declarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterFixed_size_buffer_declarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitFixed_size_buffer_declarator(this); - } - } - - public final Fixed_size_buffer_declaratorContext fixed_size_buffer_declarator() throws RecognitionException { - Fixed_size_buffer_declaratorContext _localctx = new Fixed_size_buffer_declaratorContext(_ctx, getState()); - enterRule(_localctx, 370, RULE_fixed_size_buffer_declarator); - try { - enterOuterAlt(_localctx, 1); - { - setState(2307); - identifier(); - setState(2308); - match(OPEN_BRACKET); - setState(2309); - expression(); - setState(2310); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Stackalloc_initializerContext extends ParserRuleContext { - public TerminalNode STACKALLOC() { return getToken(CSharpParser.STACKALLOC, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public Stackalloc_initializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_stackalloc_initializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStackalloc_initializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStackalloc_initializer(this); - } - } - - public final Stackalloc_initializerContext stackalloc_initializer() throws RecognitionException { - Stackalloc_initializerContext _localctx = new Stackalloc_initializerContext(_ctx, getState()); - enterRule(_localctx, 372, RULE_stackalloc_initializer); - int _la; - try { - int _alt; - setState(2341); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2312); - match(STACKALLOC); - setState(2313); - type_(); - setState(2314); - match(OPEN_BRACKET); - setState(2315); - expression(); - setState(2316); - match(CLOSE_BRACKET); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2318); - match(STACKALLOC); - setState(2320); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (PARTIAL - 75)) | (1L << (REMOVE - 75)) | (1L << (SBYTE - 75)) | (1L << (SELECT - 75)) | (1L << (SET - 75)) | (1L << (SHORT - 75)) | (1L << (STRING - 75)) | (1L << (UINT - 75)) | (1L << (ULONG - 75)) | (1L << (UNMANAGED - 75)) | (1L << (USHORT - 75)) | (1L << (VAR - 75)) | (1L << (VOID - 75)) | (1L << (WHEN - 75)) | (1L << (WHERE - 75)) | (1L << (YIELD - 75)) | (1L << (IDENTIFIER - 75)) | (1L << (OPEN_PARENS - 75)))) != 0)) { - { - setState(2319); - type_(); - } - } - - setState(2322); - match(OPEN_BRACKET); - setState(2324); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(2323); - expression(); - } - } - - setState(2326); - match(CLOSE_BRACKET); - setState(2327); - match(OPEN_BRACE); - setState(2328); - expression(); - setState(2333); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,293,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2329); - match(COMMA); - setState(2330); - expression(); - } - } - } - setState(2335); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,293,_ctx); - } - setState(2337); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2336); - match(COMMA); - } - } - - setState(2339); - match(CLOSE_BRACE); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Right_arrowContext extends ParserRuleContext { - public Token first; - public Token second; - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public Right_arrowContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_right_arrow; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRight_arrow(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRight_arrow(this); - } - } - - public final Right_arrowContext right_arrow() throws RecognitionException { - Right_arrowContext _localctx = new Right_arrowContext(_ctx, getState()); - enterRule(_localctx, 374, RULE_right_arrow); - try { - enterOuterAlt(_localctx, 1); - { - setState(2343); - ((Right_arrowContext)_localctx).first = match(ASSIGNMENT); - setState(2344); - ((Right_arrowContext)_localctx).second = match(GT); - setState(2345); - if (!((((Right_arrowContext)_localctx).first!=null?((Right_arrowContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_arrowContext)_localctx).second!=null?((Right_arrowContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Right_shiftContext extends ParserRuleContext { - public Token first; - public Token second; - public List GT() { return getTokens(CSharpParser.GT); } - public TerminalNode GT(int i) { - return getToken(CSharpParser.GT, i); - } - public Right_shiftContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_right_shift; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRight_shift(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRight_shift(this); - } - } - - public final Right_shiftContext right_shift() throws RecognitionException { - Right_shiftContext _localctx = new Right_shiftContext(_ctx, getState()); - enterRule(_localctx, 376, RULE_right_shift); - try { - enterOuterAlt(_localctx, 1); - { - setState(2347); - ((Right_shiftContext)_localctx).first = match(GT); - setState(2348); - ((Right_shiftContext)_localctx).second = match(GT); - setState(2349); - if (!((((Right_shiftContext)_localctx).first!=null?((Right_shiftContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shiftContext)_localctx).second!=null?((Right_shiftContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Right_shift_assignmentContext extends ParserRuleContext { - public Token first; - public Token second; - public TerminalNode GT() { return getToken(CSharpParser.GT, 0); } - public TerminalNode OP_GE() { return getToken(CSharpParser.OP_GE, 0); } - public Right_shift_assignmentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_right_shift_assignment; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterRight_shift_assignment(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitRight_shift_assignment(this); - } - } - - public final Right_shift_assignmentContext right_shift_assignment() throws RecognitionException { - Right_shift_assignmentContext _localctx = new Right_shift_assignmentContext(_ctx, getState()); - enterRule(_localctx, 378, RULE_right_shift_assignment); - try { - enterOuterAlt(_localctx, 1); - { - setState(2351); - ((Right_shift_assignmentContext)_localctx).first = match(GT); - setState(2352); - ((Right_shift_assignmentContext)_localctx).second = match(OP_GE); - setState(2353); - if (!((((Right_shift_assignmentContext)_localctx).first!=null?((Right_shift_assignmentContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shift_assignmentContext)_localctx).second!=null?((Right_shift_assignmentContext)_localctx).second.getTokenIndex():0))) throw new FailedPredicateException(this, "$first.index + 1 == $second.index"); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LiteralContext extends ParserRuleContext { - public Boolean_literalContext boolean_literal() { - return getRuleContext(Boolean_literalContext.class,0); - } - public String_literalContext string_literal() { - return getRuleContext(String_literalContext.class,0); - } - public TerminalNode INTEGER_LITERAL() { return getToken(CSharpParser.INTEGER_LITERAL, 0); } - public TerminalNode HEX_INTEGER_LITERAL() { return getToken(CSharpParser.HEX_INTEGER_LITERAL, 0); } - public TerminalNode BIN_INTEGER_LITERAL() { return getToken(CSharpParser.BIN_INTEGER_LITERAL, 0); } - public TerminalNode REAL_LITERAL() { return getToken(CSharpParser.REAL_LITERAL, 0); } - public TerminalNode CHARACTER_LITERAL() { return getToken(CSharpParser.CHARACTER_LITERAL, 0); } - public TerminalNode NULL() { return getToken(CSharpParser.NULL, 0); } - public LiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_literal; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitLiteral(this); - } - } - - public final LiteralContext literal() throws RecognitionException { - LiteralContext _localctx = new LiteralContext(_ctx, getState()); - enterRule(_localctx, 380, RULE_literal); - try { - setState(2363); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FALSE: - case TRUE: - enterOuterAlt(_localctx, 1); - { - setState(2355); - boolean_literal(); - } - break; - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - enterOuterAlt(_localctx, 2); - { - setState(2356); - string_literal(); - } - break; - case INTEGER_LITERAL: - enterOuterAlt(_localctx, 3); - { - setState(2357); - match(INTEGER_LITERAL); - } - break; - case HEX_INTEGER_LITERAL: - enterOuterAlt(_localctx, 4); - { - setState(2358); - match(HEX_INTEGER_LITERAL); - } - break; - case BIN_INTEGER_LITERAL: - enterOuterAlt(_localctx, 5); - { - setState(2359); - match(BIN_INTEGER_LITERAL); - } - break; - case REAL_LITERAL: - enterOuterAlt(_localctx, 6); - { - setState(2360); - match(REAL_LITERAL); - } - break; - case CHARACTER_LITERAL: - enterOuterAlt(_localctx, 7); - { - setState(2361); - match(CHARACTER_LITERAL); - } - break; - case NULL: - enterOuterAlt(_localctx, 8); - { - setState(2362); - match(NULL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Boolean_literalContext extends ParserRuleContext { - public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } - public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } - public Boolean_literalContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_boolean_literal; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterBoolean_literal(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitBoolean_literal(this); - } - } - - public final Boolean_literalContext boolean_literal() throws RecognitionException { - Boolean_literalContext _localctx = new Boolean_literalContext(_ctx, getState()); - enterRule(_localctx, 382, RULE_boolean_literal); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2365); - _la = _input.LA(1); - if ( !(_la==FALSE || _la==TRUE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class String_literalContext extends ParserRuleContext { - public Interpolated_regular_stringContext interpolated_regular_string() { - return getRuleContext(Interpolated_regular_stringContext.class,0); - } - public Interpolated_verbatium_stringContext interpolated_verbatium_string() { - return getRuleContext(Interpolated_verbatium_stringContext.class,0); - } - public TerminalNode REGULAR_STRING() { return getToken(CSharpParser.REGULAR_STRING, 0); } - public TerminalNode VERBATIUM_STRING() { return getToken(CSharpParser.VERBATIUM_STRING, 0); } - public String_literalContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_string_literal; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterString_literal(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitString_literal(this); - } - } - - public final String_literalContext string_literal() throws RecognitionException { - String_literalContext _localctx = new String_literalContext(_ctx, getState()); - enterRule(_localctx, 384, RULE_string_literal); - try { - setState(2371); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INTERPOLATED_REGULAR_STRING_START: - enterOuterAlt(_localctx, 1); - { - setState(2367); - interpolated_regular_string(); - } - break; - case INTERPOLATED_VERBATIUM_STRING_START: - enterOuterAlt(_localctx, 2); - { - setState(2368); - interpolated_verbatium_string(); - } - break; - case REGULAR_STRING: - enterOuterAlt(_localctx, 3); - { - setState(2369); - match(REGULAR_STRING); - } - break; - case VERBATIUM_STRING: - enterOuterAlt(_localctx, 4); - { - setState(2370); - match(VERBATIUM_STRING); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interpolated_regular_stringContext extends ParserRuleContext { - public TerminalNode INTERPOLATED_REGULAR_STRING_START() { return getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0); } - public TerminalNode DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); } - public List interpolated_regular_string_part() { - return getRuleContexts(Interpolated_regular_string_partContext.class); - } - public Interpolated_regular_string_partContext interpolated_regular_string_part(int i) { - return getRuleContext(Interpolated_regular_string_partContext.class,i); - } - public Interpolated_regular_stringContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interpolated_regular_string; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterpolated_regular_string(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterpolated_regular_string(this); - } - } - - public final Interpolated_regular_stringContext interpolated_regular_string() throws RecognitionException { - Interpolated_regular_stringContext _localctx = new Interpolated_regular_stringContext(_ctx, getState()); - enterRule(_localctx, 386, RULE_interpolated_regular_string); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2373); - match(INTERPOLATED_REGULAR_STRING_START); - setState(2377); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)) | (1L << (DOUBLE_CURLY_INSIDE - 129)) | (1L << (REGULAR_CHAR_INSIDE - 129)) | (1L << (REGULAR_STRING_INSIDE - 129)))) != 0)) { - { - { - setState(2374); - interpolated_regular_string_part(); - } - } - setState(2379); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2380); - match(DOUBLE_QUOTE_INSIDE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interpolated_verbatium_stringContext extends ParserRuleContext { - public TerminalNode INTERPOLATED_VERBATIUM_STRING_START() { return getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0); } - public TerminalNode DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0); } - public List interpolated_verbatium_string_part() { - return getRuleContexts(Interpolated_verbatium_string_partContext.class); - } - public Interpolated_verbatium_string_partContext interpolated_verbatium_string_part(int i) { - return getRuleContext(Interpolated_verbatium_string_partContext.class,i); - } - public Interpolated_verbatium_stringContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interpolated_verbatium_string; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterpolated_verbatium_string(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterpolated_verbatium_string(this); - } - } - - public final Interpolated_verbatium_stringContext interpolated_verbatium_string() throws RecognitionException { - Interpolated_verbatium_stringContext _localctx = new Interpolated_verbatium_stringContext(_ctx, getState()); - enterRule(_localctx, 388, RULE_interpolated_verbatium_string); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2382); - match(INTERPOLATED_VERBATIUM_STRING_START); - setState(2386); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)) | (1L << (DOUBLE_CURLY_INSIDE - 129)) | (1L << (VERBATIUM_DOUBLE_QUOTE_INSIDE - 129)) | (1L << (VERBATIUM_INSIDE_STRING - 129)))) != 0)) { - { - { - setState(2383); - interpolated_verbatium_string_part(); - } - } - setState(2388); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2389); - match(DOUBLE_QUOTE_INSIDE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interpolated_regular_string_partContext extends ParserRuleContext { - public Interpolated_string_expressionContext interpolated_string_expression() { - return getRuleContext(Interpolated_string_expressionContext.class,0); - } - public TerminalNode DOUBLE_CURLY_INSIDE() { return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); } - public TerminalNode REGULAR_CHAR_INSIDE() { return getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0); } - public TerminalNode REGULAR_STRING_INSIDE() { return getToken(CSharpParser.REGULAR_STRING_INSIDE, 0); } - public Interpolated_regular_string_partContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interpolated_regular_string_part; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterpolated_regular_string_part(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterpolated_regular_string_part(this); - } - } - - public final Interpolated_regular_string_partContext interpolated_regular_string_part() throws RecognitionException { - Interpolated_regular_string_partContext _localctx = new Interpolated_regular_string_partContext(_ctx, getState()); - enterRule(_localctx, 390, RULE_interpolated_regular_string_part); - try { - setState(2395); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(2391); - interpolated_string_expression(); - } - break; - case DOUBLE_CURLY_INSIDE: - enterOuterAlt(_localctx, 2); - { - setState(2392); - match(DOUBLE_CURLY_INSIDE); - } - break; - case REGULAR_CHAR_INSIDE: - enterOuterAlt(_localctx, 3); - { - setState(2393); - match(REGULAR_CHAR_INSIDE); - } - break; - case REGULAR_STRING_INSIDE: - enterOuterAlt(_localctx, 4); - { - setState(2394); - match(REGULAR_STRING_INSIDE); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interpolated_verbatium_string_partContext extends ParserRuleContext { - public Interpolated_string_expressionContext interpolated_string_expression() { - return getRuleContext(Interpolated_string_expressionContext.class,0); - } - public TerminalNode DOUBLE_CURLY_INSIDE() { return getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0); } - public TerminalNode VERBATIUM_DOUBLE_QUOTE_INSIDE() { return getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0); } - public TerminalNode VERBATIUM_INSIDE_STRING() { return getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0); } - public Interpolated_verbatium_string_partContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interpolated_verbatium_string_part; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterpolated_verbatium_string_part(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterpolated_verbatium_string_part(this); - } - } - - public final Interpolated_verbatium_string_partContext interpolated_verbatium_string_part() throws RecognitionException { - Interpolated_verbatium_string_partContext _localctx = new Interpolated_verbatium_string_partContext(_ctx, getState()); - enterRule(_localctx, 392, RULE_interpolated_verbatium_string_part); - try { - setState(2401); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case ALIAS: - case ARGLIST: - case ASCENDING: - case ASYNC: - case AWAIT: - case BASE: - case BOOL: - case BY: - case BYTE: - case CHAR: - case CHECKED: - case DECIMAL: - case DEFAULT: - case DELEGATE: - case DESCENDING: - case DOUBLE: - case DYNAMIC: - case EQUALS: - case FALSE: - case FLOAT: - case FROM: - case GET: - case GROUP: - case INT: - case INTO: - case JOIN: - case LET: - case LONG: - case NAMEOF: - case NEW: - case NULL: - case OBJECT: - case ON: - case ORDERBY: - case PARTIAL: - case REF: - case REMOVE: - case SBYTE: - case SELECT: - case SET: - case SHORT: - case SIZEOF: - case STRING: - case THIS: - case TRUE: - case TYPEOF: - case UINT: - case ULONG: - case UNCHECKED: - case UNMANAGED: - case USHORT: - case VAR: - case WHEN: - case WHERE: - case YIELD: - case IDENTIFIER: - case LITERAL_ACCESS: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case BIN_INTEGER_LITERAL: - case REAL_LITERAL: - case CHARACTER_LITERAL: - case REGULAR_STRING: - case VERBATIUM_STRING: - case INTERPOLATED_REGULAR_STRING_START: - case INTERPOLATED_VERBATIUM_STRING_START: - case OPEN_PARENS: - case PLUS: - case MINUS: - case STAR: - case AMP: - case CARET: - case BANG: - case TILDE: - case OP_INC: - case OP_DEC: - case OP_RANGE: - enterOuterAlt(_localctx, 1); - { - setState(2397); - interpolated_string_expression(); - } - break; - case DOUBLE_CURLY_INSIDE: - enterOuterAlt(_localctx, 2); - { - setState(2398); - match(DOUBLE_CURLY_INSIDE); - } - break; - case VERBATIUM_DOUBLE_QUOTE_INSIDE: - enterOuterAlt(_localctx, 3); - { - setState(2399); - match(VERBATIUM_DOUBLE_QUOTE_INSIDE); - } - break; - case VERBATIUM_INSIDE_STRING: - enterOuterAlt(_localctx, 4); - { - setState(2400); - match(VERBATIUM_INSIDE_STRING); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interpolated_string_expressionContext extends ParserRuleContext { - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List COMMA() { return getTokens(CSharpParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(CSharpParser.COMMA, i); - } - public TerminalNode COLON() { return getToken(CSharpParser.COLON, 0); } - public List FORMAT_STRING() { return getTokens(CSharpParser.FORMAT_STRING); } - public TerminalNode FORMAT_STRING(int i) { - return getToken(CSharpParser.FORMAT_STRING, i); - } - public Interpolated_string_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interpolated_string_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterpolated_string_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterpolated_string_expression(this); - } - } - - public final Interpolated_string_expressionContext interpolated_string_expression() throws RecognitionException { - Interpolated_string_expressionContext _localctx = new Interpolated_string_expressionContext(_ctx, getState()); - enterRule(_localctx, 394, RULE_interpolated_string_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2403); - expression(); - setState(2408); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2404); - match(COMMA); - setState(2405); - expression(); - } - } - setState(2410); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2417); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2411); - match(COLON); - setState(2413); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(2412); - match(FORMAT_STRING); - } - } - setState(2415); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==FORMAT_STRING ); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class KeywordContext extends ParserRuleContext { - public TerminalNode ABSTRACT() { return getToken(CSharpParser.ABSTRACT, 0); } - public TerminalNode AS() { return getToken(CSharpParser.AS, 0); } - public TerminalNode BASE() { return getToken(CSharpParser.BASE, 0); } - public TerminalNode BOOL() { return getToken(CSharpParser.BOOL, 0); } - public TerminalNode BREAK() { return getToken(CSharpParser.BREAK, 0); } - public TerminalNode BYTE() { return getToken(CSharpParser.BYTE, 0); } - public TerminalNode CASE() { return getToken(CSharpParser.CASE, 0); } - public TerminalNode CATCH() { return getToken(CSharpParser.CATCH, 0); } - public TerminalNode CHAR() { return getToken(CSharpParser.CHAR, 0); } - public TerminalNode CHECKED() { return getToken(CSharpParser.CHECKED, 0); } - public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } - public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } - public TerminalNode CONTINUE() { return getToken(CSharpParser.CONTINUE, 0); } - public TerminalNode DECIMAL() { return getToken(CSharpParser.DECIMAL, 0); } - public TerminalNode DEFAULT() { return getToken(CSharpParser.DEFAULT, 0); } - public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } - public TerminalNode DO() { return getToken(CSharpParser.DO, 0); } - public TerminalNode DOUBLE() { return getToken(CSharpParser.DOUBLE, 0); } - public TerminalNode ELSE() { return getToken(CSharpParser.ELSE, 0); } - public TerminalNode ENUM() { return getToken(CSharpParser.ENUM, 0); } - public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } - public TerminalNode EXPLICIT() { return getToken(CSharpParser.EXPLICIT, 0); } - public TerminalNode EXTERN() { return getToken(CSharpParser.EXTERN, 0); } - public TerminalNode FALSE() { return getToken(CSharpParser.FALSE, 0); } - public TerminalNode FINALLY() { return getToken(CSharpParser.FINALLY, 0); } - public TerminalNode FIXED() { return getToken(CSharpParser.FIXED, 0); } - public TerminalNode FLOAT() { return getToken(CSharpParser.FLOAT, 0); } - public TerminalNode FOR() { return getToken(CSharpParser.FOR, 0); } - public TerminalNode FOREACH() { return getToken(CSharpParser.FOREACH, 0); } - public TerminalNode GOTO() { return getToken(CSharpParser.GOTO, 0); } - public TerminalNode IF() { return getToken(CSharpParser.IF, 0); } - public TerminalNode IMPLICIT() { return getToken(CSharpParser.IMPLICIT, 0); } - public TerminalNode IN() { return getToken(CSharpParser.IN, 0); } - public TerminalNode INT() { return getToken(CSharpParser.INT, 0); } - public TerminalNode INTERFACE() { return getToken(CSharpParser.INTERFACE, 0); } - public TerminalNode INTERNAL() { return getToken(CSharpParser.INTERNAL, 0); } - public TerminalNode IS() { return getToken(CSharpParser.IS, 0); } - public TerminalNode LOCK() { return getToken(CSharpParser.LOCK, 0); } - public TerminalNode LONG() { return getToken(CSharpParser.LONG, 0); } - public TerminalNode NAMESPACE() { return getToken(CSharpParser.NAMESPACE, 0); } - public TerminalNode NEW() { return getToken(CSharpParser.NEW, 0); } - public TerminalNode NULL() { return getToken(CSharpParser.NULL, 0); } - public TerminalNode OBJECT() { return getToken(CSharpParser.OBJECT, 0); } - public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } - public TerminalNode OUT() { return getToken(CSharpParser.OUT, 0); } - public TerminalNode OVERRIDE() { return getToken(CSharpParser.OVERRIDE, 0); } - public TerminalNode PARAMS() { return getToken(CSharpParser.PARAMS, 0); } - public TerminalNode PRIVATE() { return getToken(CSharpParser.PRIVATE, 0); } - public TerminalNode PROTECTED() { return getToken(CSharpParser.PROTECTED, 0); } - public TerminalNode PUBLIC() { return getToken(CSharpParser.PUBLIC, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public TerminalNode RETURN() { return getToken(CSharpParser.RETURN, 0); } - public TerminalNode SBYTE() { return getToken(CSharpParser.SBYTE, 0); } - public TerminalNode SEALED() { return getToken(CSharpParser.SEALED, 0); } - public TerminalNode SHORT() { return getToken(CSharpParser.SHORT, 0); } - public TerminalNode SIZEOF() { return getToken(CSharpParser.SIZEOF, 0); } - public TerminalNode STACKALLOC() { return getToken(CSharpParser.STACKALLOC, 0); } - public TerminalNode STATIC() { return getToken(CSharpParser.STATIC, 0); } - public TerminalNode STRING() { return getToken(CSharpParser.STRING, 0); } - public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } - public TerminalNode SWITCH() { return getToken(CSharpParser.SWITCH, 0); } - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public TerminalNode THROW() { return getToken(CSharpParser.THROW, 0); } - public TerminalNode TRUE() { return getToken(CSharpParser.TRUE, 0); } - public TerminalNode TRY() { return getToken(CSharpParser.TRY, 0); } - public TerminalNode TYPEOF() { return getToken(CSharpParser.TYPEOF, 0); } - public TerminalNode UINT() { return getToken(CSharpParser.UINT, 0); } - public TerminalNode ULONG() { return getToken(CSharpParser.ULONG, 0); } - public TerminalNode UNCHECKED() { return getToken(CSharpParser.UNCHECKED, 0); } - public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } - public TerminalNode UNSAFE() { return getToken(CSharpParser.UNSAFE, 0); } - public TerminalNode USHORT() { return getToken(CSharpParser.USHORT, 0); } - public TerminalNode USING() { return getToken(CSharpParser.USING, 0); } - public TerminalNode VIRTUAL() { return getToken(CSharpParser.VIRTUAL, 0); } - public TerminalNode VOID() { return getToken(CSharpParser.VOID, 0); } - public TerminalNode VOLATILE() { return getToken(CSharpParser.VOLATILE, 0); } - public TerminalNode WHILE() { return getToken(CSharpParser.WHILE, 0); } - public KeywordContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_keyword; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterKeyword(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitKeyword(this); - } - } - - public final KeywordContext keyword() throws RecognitionException { - KeywordContext _localctx = new KeywordContext(_ctx, getState()); - enterRule(_localctx, 396, RULE_keyword); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2419); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << AS) | (1L << BASE) | (1L << BOOL) | (1L << BREAK) | (1L << BYTE) | (1L << CASE) | (1L << CATCH) | (1L << CHAR) | (1L << CHECKED) | (1L << CLASS) | (1L << CONST) | (1L << CONTINUE) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DO) | (1L << DOUBLE) | (1L << ELSE) | (1L << ENUM) | (1L << EVENT) | (1L << EXPLICIT) | (1L << EXTERN) | (1L << FALSE) | (1L << FINALLY) | (1L << FIXED) | (1L << FLOAT) | (1L << FOR) | (1L << FOREACH) | (1L << GOTO) | (1L << IF) | (1L << IMPLICIT) | (1L << IN) | (1L << INT) | (1L << INTERFACE) | (1L << INTERNAL) | (1L << IS) | (1L << LOCK) | (1L << LONG))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (NAMESPACE - 65)) | (1L << (NEW - 65)) | (1L << (NULL - 65)) | (1L << (OBJECT - 65)) | (1L << (OPERATOR - 65)) | (1L << (OUT - 65)) | (1L << (OVERRIDE - 65)) | (1L << (PARAMS - 65)) | (1L << (PRIVATE - 65)) | (1L << (PROTECTED - 65)) | (1L << (PUBLIC - 65)) | (1L << (READONLY - 65)) | (1L << (REF - 65)) | (1L << (RETURN - 65)) | (1L << (SBYTE - 65)) | (1L << (SEALED - 65)) | (1L << (SHORT - 65)) | (1L << (SIZEOF - 65)) | (1L << (STACKALLOC - 65)) | (1L << (STATIC - 65)) | (1L << (STRING - 65)) | (1L << (STRUCT - 65)) | (1L << (SWITCH - 65)) | (1L << (THIS - 65)) | (1L << (THROW - 65)) | (1L << (TRUE - 65)) | (1L << (TRY - 65)) | (1L << (TYPEOF - 65)) | (1L << (UINT - 65)) | (1L << (ULONG - 65)) | (1L << (UNCHECKED - 65)) | (1L << (UNMANAGED - 65)) | (1L << (UNSAFE - 65)) | (1L << (USHORT - 65)) | (1L << (USING - 65)) | (1L << (VIRTUAL - 65)) | (1L << (VOID - 65)) | (1L << (VOLATILE - 65)) | (1L << (WHILE - 65)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Class_definitionContext extends ParserRuleContext { - public TerminalNode CLASS() { return getToken(CSharpParser.CLASS, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Class_bodyContext class_body() { - return getRuleContext(Class_bodyContext.class,0); - } - public Type_parameter_listContext type_parameter_list() { - return getRuleContext(Type_parameter_listContext.class,0); - } - public Class_baseContext class_base() { - return getRuleContext(Class_baseContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Class_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_class_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterClass_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitClass_definition(this); - } - } - - public final Class_definitionContext class_definition() throws RecognitionException { - Class_definitionContext _localctx = new Class_definitionContext(_ctx, getState()); - enterRule(_localctx, 398, RULE_class_definition); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2421); - match(CLASS); - setState(2422); - identifier(); - setState(2424); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2423); - type_parameter_list(); - } - } - - setState(2427); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2426); - class_base(); - } - } - - setState(2430); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2429); - type_parameter_constraints_clauses(); - } - } - - setState(2432); - class_body(); - setState(2434); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2433); - match(SEMICOLON); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Struct_definitionContext extends ParserRuleContext { - public TerminalNode STRUCT() { return getToken(CSharpParser.STRUCT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Struct_bodyContext struct_body() { - return getRuleContext(Struct_bodyContext.class,0); - } - public Type_parameter_listContext type_parameter_list() { - return getRuleContext(Type_parameter_listContext.class,0); - } - public Struct_interfacesContext struct_interfaces() { - return getRuleContext(Struct_interfacesContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public TerminalNode READONLY() { return getToken(CSharpParser.READONLY, 0); } - public TerminalNode REF() { return getToken(CSharpParser.REF, 0); } - public Struct_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_struct_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterStruct_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitStruct_definition(this); - } - } - - public final Struct_definitionContext struct_definition() throws RecognitionException { - Struct_definitionContext _localctx = new Struct_definitionContext(_ctx, getState()); - enterRule(_localctx, 400, RULE_struct_definition); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2437); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==READONLY || _la==REF) { - { - setState(2436); - _la = _input.LA(1); - if ( !(_la==READONLY || _la==REF) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2439); - match(STRUCT); - setState(2440); - identifier(); - setState(2442); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2441); - type_parameter_list(); - } - } - - setState(2445); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2444); - struct_interfaces(); - } - } - - setState(2448); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2447); - type_parameter_constraints_clauses(); - } - } - - setState(2450); - struct_body(); - setState(2452); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2451); - match(SEMICOLON); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Interface_definitionContext extends ParserRuleContext { - public TerminalNode INTERFACE() { return getToken(CSharpParser.INTERFACE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Class_bodyContext class_body() { - return getRuleContext(Class_bodyContext.class,0); - } - public Variant_type_parameter_listContext variant_type_parameter_list() { - return getRuleContext(Variant_type_parameter_listContext.class,0); - } - public Interface_baseContext interface_base() { - return getRuleContext(Interface_baseContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Interface_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interface_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterInterface_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitInterface_definition(this); - } - } - - public final Interface_definitionContext interface_definition() throws RecognitionException { - Interface_definitionContext _localctx = new Interface_definitionContext(_ctx, getState()); - enterRule(_localctx, 402, RULE_interface_definition); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2454); - match(INTERFACE); - setState(2455); - identifier(); - setState(2457); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2456); - variant_type_parameter_list(); - } - } - - setState(2460); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2459); - interface_base(); - } - } - - setState(2463); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2462); - type_parameter_constraints_clauses(); - } - } - - setState(2465); - class_body(); - setState(2467); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2466); - match(SEMICOLON); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Enum_definitionContext extends ParserRuleContext { - public TerminalNode ENUM() { return getToken(CSharpParser.ENUM, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Enum_bodyContext enum_body() { - return getRuleContext(Enum_bodyContext.class,0); - } - public Enum_baseContext enum_base() { - return getRuleContext(Enum_baseContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Enum_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enum_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEnum_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEnum_definition(this); - } - } - - public final Enum_definitionContext enum_definition() throws RecognitionException { - Enum_definitionContext _localctx = new Enum_definitionContext(_ctx, getState()); - enterRule(_localctx, 404, RULE_enum_definition); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2469); - match(ENUM); - setState(2470); - identifier(); - setState(2472); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2471); - enum_base(); - } - } - - setState(2474); - enum_body(); - setState(2476); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2475); - match(SEMICOLON); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Delegate_definitionContext extends ParserRuleContext { - public TerminalNode DELEGATE() { return getToken(CSharpParser.DELEGATE, 0); } - public Return_typeContext return_type() { - return getRuleContext(Return_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Variant_type_parameter_listContext variant_type_parameter_list() { - return getRuleContext(Variant_type_parameter_listContext.class,0); - } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public Delegate_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delegate_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterDelegate_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitDelegate_definition(this); - } - } - - public final Delegate_definitionContext delegate_definition() throws RecognitionException { - Delegate_definitionContext _localctx = new Delegate_definitionContext(_ctx, getState()); - enterRule(_localctx, 406, RULE_delegate_definition); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2478); - match(DELEGATE); - setState(2479); - return_type(); - setState(2480); - identifier(); - setState(2482); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2481); - variant_type_parameter_list(); - } - } - - setState(2484); - match(OPEN_PARENS); - setState(2486); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(2485); - formal_parameter_list(); - } - } - - setState(2488); - match(CLOSE_PARENS); - setState(2490); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2489); - type_parameter_constraints_clauses(); - } - } - - setState(2492); - match(SEMICOLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Event_declarationContext extends ParserRuleContext { - public TerminalNode EVENT() { return getToken(CSharpParser.EVENT, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Variable_declaratorsContext variable_declarators() { - return getRuleContext(Variable_declaratorsContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Member_nameContext member_name() { - return getRuleContext(Member_nameContext.class,0); - } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public Event_accessor_declarationsContext event_accessor_declarations() { - return getRuleContext(Event_accessor_declarationsContext.class,0); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Event_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_event_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterEvent_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitEvent_declaration(this); - } - } - - public final Event_declarationContext event_declaration() throws RecognitionException { - Event_declarationContext _localctx = new Event_declarationContext(_ctx, getState()); - enterRule(_localctx, 408, RULE_event_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(2494); - match(EVENT); - setState(2495); - type_(); - setState(2504); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,323,_ctx) ) { - case 1: - { - setState(2496); - variable_declarators(); - setState(2497); - match(SEMICOLON); - } - break; - case 2: - { - setState(2499); - member_name(); - setState(2500); - match(OPEN_BRACE); - setState(2501); - event_accessor_declarations(); - setState(2502); - match(CLOSE_BRACE); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Field_declarationContext extends ParserRuleContext { - public Variable_declaratorsContext variable_declarators() { - return getRuleContext(Variable_declaratorsContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Field_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_field_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterField_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitField_declaration(this); - } - } - - public final Field_declarationContext field_declaration() throws RecognitionException { - Field_declarationContext _localctx = new Field_declarationContext(_ctx, getState()); - enterRule(_localctx, 410, RULE_field_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(2506); - variable_declarators(); - setState(2507); - match(SEMICOLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Property_declarationContext extends ParserRuleContext { - public Member_nameContext member_name() { - return getRuleContext(Member_nameContext.class,0); - } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public Accessor_declarationsContext accessor_declarations() { - return getRuleContext(Accessor_declarationsContext.class,0); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public Variable_initializerContext variable_initializer() { - return getRuleContext(Variable_initializerContext.class,0); - } - public Property_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_property_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterProperty_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitProperty_declaration(this); - } - } - - public final Property_declarationContext property_declaration() throws RecognitionException { - Property_declarationContext _localctx = new Property_declarationContext(_ctx, getState()); - enterRule(_localctx, 412, RULE_property_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2509); - member_name(); - setState(2523); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - { - setState(2510); - match(OPEN_BRACE); - setState(2511); - accessor_declarations(); - setState(2512); - match(CLOSE_BRACE); - setState(2517); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASSIGNMENT) { - { - setState(2513); - match(ASSIGNMENT); - setState(2514); - variable_initializer(); - setState(2515); - match(SEMICOLON); - } - } - - } - break; - case ASSIGNMENT: - { - setState(2519); - right_arrow(); - setState(2520); - throwable_expression(); - setState(2521); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constant_declarationContext extends ParserRuleContext { - public TerminalNode CONST() { return getToken(CSharpParser.CONST, 0); } - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public Constant_declaratorsContext constant_declarators() { - return getRuleContext(Constant_declaratorsContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Constant_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constant_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstant_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstant_declaration(this); - } - } - - public final Constant_declarationContext constant_declaration() throws RecognitionException { - Constant_declarationContext _localctx = new Constant_declarationContext(_ctx, getState()); - enterRule(_localctx, 414, RULE_constant_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(2525); - match(CONST); - setState(2526); - type_(); - setState(2527); - constant_declarators(); - setState(2528); - match(SEMICOLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Indexer_declarationContext extends ParserRuleContext { - public TerminalNode THIS() { return getToken(CSharpParser.THIS, 0); } - public TerminalNode OPEN_BRACKET() { return getToken(CSharpParser.OPEN_BRACKET, 0); } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public TerminalNode CLOSE_BRACKET() { return getToken(CSharpParser.CLOSE_BRACKET, 0); } - public TerminalNode OPEN_BRACE() { return getToken(CSharpParser.OPEN_BRACE, 0); } - public Accessor_declarationsContext accessor_declarations() { - return getRuleContext(Accessor_declarationsContext.class,0); - } - public TerminalNode CLOSE_BRACE() { return getToken(CSharpParser.CLOSE_BRACE, 0); } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Indexer_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_indexer_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIndexer_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIndexer_declaration(this); - } - } - - public final Indexer_declarationContext indexer_declaration() throws RecognitionException { - Indexer_declarationContext _localctx = new Indexer_declarationContext(_ctx, getState()); - enterRule(_localctx, 416, RULE_indexer_declaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(2530); - match(THIS); - setState(2531); - match(OPEN_BRACKET); - setState(2532); - formal_parameter_list(); - setState(2533); - match(CLOSE_BRACKET); - setState(2542); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - { - setState(2534); - match(OPEN_BRACE); - setState(2535); - accessor_declarations(); - setState(2536); - match(CLOSE_BRACE); - } - break; - case ASSIGNMENT: - { - setState(2538); - right_arrow(); - setState(2539); - throwable_expression(); - setState(2540); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Destructor_definitionContext extends ParserRuleContext { - public TerminalNode TILDE() { return getToken(CSharpParser.TILDE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public BodyContext body() { - return getRuleContext(BodyContext.class,0); - } - public Destructor_definitionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_destructor_definition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterDestructor_definition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitDestructor_definition(this); - } - } - - public final Destructor_definitionContext destructor_definition() throws RecognitionException { - Destructor_definitionContext _localctx = new Destructor_definitionContext(_ctx, getState()); - enterRule(_localctx, 418, RULE_destructor_definition); - try { - enterOuterAlt(_localctx, 1); - { - setState(2544); - match(TILDE); - setState(2545); - identifier(); - setState(2546); - match(OPEN_PARENS); - setState(2547); - match(CLOSE_PARENS); - setState(2548); - body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Constructor_declarationContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public BodyContext body() { - return getRuleContext(BodyContext.class,0); - } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public Constructor_initializerContext constructor_initializer() { - return getRuleContext(Constructor_initializerContext.class,0); - } - public Constructor_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructor_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterConstructor_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitConstructor_declaration(this); - } - } - - public final Constructor_declarationContext constructor_declaration() throws RecognitionException { - Constructor_declarationContext _localctx = new Constructor_declarationContext(_ctx, getState()); - enterRule(_localctx, 420, RULE_constructor_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2550); - identifier(); - setState(2551); - match(OPEN_PARENS); - setState(2553); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(2552); - formal_parameter_list(); - } - } - - setState(2555); - match(CLOSE_PARENS); - setState(2557); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(2556); - constructor_initializer(); - } - } - - setState(2559); - body(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Method_declarationContext extends ParserRuleContext { - public Method_member_nameContext method_member_name() { - return getRuleContext(Method_member_nameContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Method_bodyContext method_body() { - return getRuleContext(Method_bodyContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public Type_parameter_listContext type_parameter_list() { - return getRuleContext(Type_parameter_listContext.class,0); - } - public Formal_parameter_listContext formal_parameter_list() { - return getRuleContext(Formal_parameter_listContext.class,0); - } - public Type_parameter_constraints_clausesContext type_parameter_constraints_clauses() { - return getRuleContext(Type_parameter_constraints_clausesContext.class,0); - } - public Method_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_method_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMethod_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMethod_declaration(this); - } - } - - public final Method_declarationContext method_declaration() throws RecognitionException { - Method_declarationContext _localctx = new Method_declarationContext(_ctx, getState()); - enterRule(_localctx, 422, RULE_method_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2561); - method_member_name(); - setState(2563); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2562); - type_parameter_list(); - } - } - - setState(2565); - match(OPEN_PARENS); - setState(2567); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (ADD - 10)) | (1L << (ALIAS - 10)) | (1L << (ARGLIST - 10)) | (1L << (ASCENDING - 10)) | (1L << (ASYNC - 10)) | (1L << (AWAIT - 10)) | (1L << (BOOL - 10)) | (1L << (BY - 10)) | (1L << (BYTE - 10)) | (1L << (CHAR - 10)) | (1L << (DECIMAL - 10)) | (1L << (DESCENDING - 10)) | (1L << (DOUBLE - 10)) | (1L << (DYNAMIC - 10)) | (1L << (EQUALS - 10)) | (1L << (FLOAT - 10)) | (1L << (FROM - 10)) | (1L << (GET - 10)) | (1L << (GROUP - 10)) | (1L << (IN - 10)) | (1L << (INT - 10)) | (1L << (INTO - 10)) | (1L << (JOIN - 10)) | (1L << (LET - 10)) | (1L << (LONG - 10)) | (1L << (NAMEOF - 10)) | (1L << (OBJECT - 10)) | (1L << (ON - 10)) | (1L << (ORDERBY - 10)) | (1L << (OUT - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (PARAMS - 74)) | (1L << (PARTIAL - 74)) | (1L << (REF - 74)) | (1L << (REMOVE - 74)) | (1L << (SBYTE - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SHORT - 74)) | (1L << (STRING - 74)) | (1L << (THIS - 74)) | (1L << (UINT - 74)) | (1L << (ULONG - 74)) | (1L << (UNMANAGED - 74)) | (1L << (USHORT - 74)) | (1L << (VAR - 74)) | (1L << (VOID - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (YIELD - 74)) | (1L << (IDENTIFIER - 74)) | (1L << (OPEN_BRACKET - 74)) | (1L << (OPEN_PARENS - 74)))) != 0)) { - { - setState(2566); - formal_parameter_list(); - } - } - - setState(2569); - match(CLOSE_PARENS); - setState(2571); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2570); - type_parameter_constraints_clauses(); - } - } - - setState(2578); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - case SEMICOLON: - { - setState(2573); - method_body(); - } - break; - case ASSIGNMENT: - { - setState(2574); - right_arrow(); - setState(2575); - throwable_expression(); - setState(2576); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Method_member_nameContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DOUBLE_COLON() { return getToken(CSharpParser.DOUBLE_COLON, 0); } - public List DOT() { return getTokens(CSharpParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(CSharpParser.DOT, i); - } - public List type_argument_list() { - return getRuleContexts(Type_argument_listContext.class); - } - public Type_argument_listContext type_argument_list(int i) { - return getRuleContext(Type_argument_listContext.class,i); - } - public Method_member_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_method_member_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMethod_member_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMethod_member_name(this); - } - } - - public final Method_member_nameContext method_member_name() throws RecognitionException { - Method_member_nameContext _localctx = new Method_member_nameContext(_ctx, getState()); - enterRule(_localctx, 424, RULE_method_member_name); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2585); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) { - case 1: - { - setState(2580); - identifier(); - } - break; - case 2: - { - setState(2581); - identifier(); - setState(2582); - match(DOUBLE_COLON); - setState(2583); - identifier(); - } - break; - } - setState(2594); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,335,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2588); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LT) { - { - setState(2587); - type_argument_list(); - } - } - - setState(2590); - match(DOT); - setState(2591); - identifier(); - } - } - } - setState(2596); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,335,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Operator_declarationContext extends ParserRuleContext { - public TerminalNode OPERATOR() { return getToken(CSharpParser.OPERATOR, 0); } - public Overloadable_operatorContext overloadable_operator() { - return getRuleContext(Overloadable_operatorContext.class,0); - } - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public List arg_declaration() { - return getRuleContexts(Arg_declarationContext.class); - } - public Arg_declarationContext arg_declaration(int i) { - return getRuleContext(Arg_declarationContext.class,i); - } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public BodyContext body() { - return getRuleContext(BodyContext.class,0); - } - public Right_arrowContext right_arrow() { - return getRuleContext(Right_arrowContext.class,0); - } - public Throwable_expressionContext throwable_expression() { - return getRuleContext(Throwable_expressionContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(CSharpParser.SEMICOLON, 0); } - public List IN() { return getTokens(CSharpParser.IN); } - public TerminalNode IN(int i) { - return getToken(CSharpParser.IN, i); - } - public TerminalNode COMMA() { return getToken(CSharpParser.COMMA, 0); } - public Operator_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_operator_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterOperator_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitOperator_declaration(this); - } - } - - public final Operator_declarationContext operator_declaration() throws RecognitionException { - Operator_declarationContext _localctx = new Operator_declarationContext(_ctx, getState()); - enterRule(_localctx, 426, RULE_operator_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2597); - match(OPERATOR); - setState(2598); - overloadable_operator(); - setState(2599); - match(OPEN_PARENS); - setState(2601); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(2600); - match(IN); - } - } - - setState(2603); - arg_declaration(); - setState(2609); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2604); - match(COMMA); - setState(2606); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(2605); - match(IN); - } - } - - setState(2608); - arg_declaration(); - } - } - - setState(2611); - match(CLOSE_PARENS); - setState(2617); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_BRACE: - case SEMICOLON: - { - setState(2612); - body(); - } - break; - case ASSIGNMENT: - { - setState(2613); - right_arrow(); - setState(2614); - throwable_expression(); - setState(2615); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Arg_declarationContext extends ParserRuleContext { - public Type_Context type_() { - return getRuleContext(Type_Context.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(CSharpParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public Arg_declarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_arg_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterArg_declaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitArg_declaration(this); - } - } - - public final Arg_declarationContext arg_declaration() throws RecognitionException { - Arg_declarationContext _localctx = new Arg_declarationContext(_ctx, getState()); - enterRule(_localctx, 428, RULE_arg_declaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2619); - type_(); - setState(2620); - identifier(); - setState(2623); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASSIGNMENT) { - { - setState(2621); - match(ASSIGNMENT); - setState(2622); - expression(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Method_invocationContext extends ParserRuleContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Argument_listContext argument_list() { - return getRuleContext(Argument_listContext.class,0); - } - public Method_invocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_method_invocation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterMethod_invocation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitMethod_invocation(this); - } - } - - public final Method_invocationContext method_invocation() throws RecognitionException { - Method_invocationContext _localctx = new Method_invocationContext(_ctx, getState()); - enterRule(_localctx, 430, RULE_method_invocation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2625); - match(OPEN_PARENS); - setState(2627); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(2626); - argument_list(); - } - } - - setState(2629); - match(CLOSE_PARENS); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class Object_creation_expressionContext extends ParserRuleContext { - public TerminalNode OPEN_PARENS() { return getToken(CSharpParser.OPEN_PARENS, 0); } - public TerminalNode CLOSE_PARENS() { return getToken(CSharpParser.CLOSE_PARENS, 0); } - public Argument_listContext argument_list() { - return getRuleContext(Argument_listContext.class,0); - } - public Object_or_collection_initializerContext object_or_collection_initializer() { - return getRuleContext(Object_or_collection_initializerContext.class,0); - } - public Object_creation_expressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_object_creation_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterObject_creation_expression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitObject_creation_expression(this); - } - } - - public final Object_creation_expressionContext object_creation_expression() throws RecognitionException { - Object_creation_expressionContext _localctx = new Object_creation_expressionContext(_ctx, getState()); - enterRule(_localctx, 432, RULE_object_creation_expression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2631); - match(OPEN_PARENS); - setState(2633); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BASE) | (1L << BOOL) | (1L << BY) | (1L << BYTE) | (1L << CHAR) | (1L << CHECKED) | (1L << DECIMAL) | (1L << DEFAULT) | (1L << DELEGATE) | (1L << DESCENDING) | (1L << DOUBLE) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FALSE) | (1L << FLOAT) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << IN) | (1L << INT) | (1L << INTO) | (1L << JOIN) | (1L << LET) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (NEW - 64)) | (1L << (NULL - 64)) | (1L << (OBJECT - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (OUT - 64)) | (1L << (PARTIAL - 64)) | (1L << (REF - 64)) | (1L << (REMOVE - 64)) | (1L << (SBYTE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SHORT - 64)) | (1L << (SIZEOF - 64)) | (1L << (STRING - 64)) | (1L << (THIS - 64)) | (1L << (TRUE - 64)) | (1L << (TYPEOF - 64)) | (1L << (UINT - 64)) | (1L << (ULONG - 64)) | (1L << (UNCHECKED - 64)) | (1L << (UNMANAGED - 64)) | (1L << (USHORT - 64)) | (1L << (VAR - 64)) | (1L << (VOID - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (LITERAL_ACCESS - 64)) | (1L << (INTEGER_LITERAL - 64)) | (1L << (HEX_INTEGER_LITERAL - 64)) | (1L << (BIN_INTEGER_LITERAL - 64)) | (1L << (REAL_LITERAL - 64)) | (1L << (CHARACTER_LITERAL - 64)) | (1L << (REGULAR_STRING - 64)) | (1L << (VERBATIUM_STRING - 64)) | (1L << (INTERPOLATED_REGULAR_STRING_START - 64)) | (1L << (INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (OPEN_PARENS - 129)) | (1L << (PLUS - 129)) | (1L << (MINUS - 129)) | (1L << (STAR - 129)) | (1L << (AMP - 129)) | (1L << (CARET - 129)) | (1L << (BANG - 129)) | (1L << (TILDE - 129)) | (1L << (OP_INC - 129)) | (1L << (OP_DEC - 129)) | (1L << (OP_RANGE - 129)))) != 0)) { - { - setState(2632); - argument_list(); - } - } - - setState(2635); - match(CLOSE_PARENS); - setState(2637); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_BRACE) { - { - setState(2636); - object_or_collection_initializer(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IdentifierContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { return getToken(CSharpParser.IDENTIFIER, 0); } - public TerminalNode ADD() { return getToken(CSharpParser.ADD, 0); } - public TerminalNode ALIAS() { return getToken(CSharpParser.ALIAS, 0); } - public TerminalNode ARGLIST() { return getToken(CSharpParser.ARGLIST, 0); } - public TerminalNode ASCENDING() { return getToken(CSharpParser.ASCENDING, 0); } - public TerminalNode ASYNC() { return getToken(CSharpParser.ASYNC, 0); } - public TerminalNode AWAIT() { return getToken(CSharpParser.AWAIT, 0); } - public TerminalNode BY() { return getToken(CSharpParser.BY, 0); } - public TerminalNode DESCENDING() { return getToken(CSharpParser.DESCENDING, 0); } - public TerminalNode DYNAMIC() { return getToken(CSharpParser.DYNAMIC, 0); } - public TerminalNode EQUALS() { return getToken(CSharpParser.EQUALS, 0); } - public TerminalNode FROM() { return getToken(CSharpParser.FROM, 0); } - public TerminalNode GET() { return getToken(CSharpParser.GET, 0); } - public TerminalNode GROUP() { return getToken(CSharpParser.GROUP, 0); } - public TerminalNode INTO() { return getToken(CSharpParser.INTO, 0); } - public TerminalNode JOIN() { return getToken(CSharpParser.JOIN, 0); } - public TerminalNode LET() { return getToken(CSharpParser.LET, 0); } - public TerminalNode NAMEOF() { return getToken(CSharpParser.NAMEOF, 0); } - public TerminalNode ON() { return getToken(CSharpParser.ON, 0); } - public TerminalNode ORDERBY() { return getToken(CSharpParser.ORDERBY, 0); } - public TerminalNode PARTIAL() { return getToken(CSharpParser.PARTIAL, 0); } - public TerminalNode REMOVE() { return getToken(CSharpParser.REMOVE, 0); } - public TerminalNode SELECT() { return getToken(CSharpParser.SELECT, 0); } - public TerminalNode SET() { return getToken(CSharpParser.SET, 0); } - public TerminalNode UNMANAGED() { return getToken(CSharpParser.UNMANAGED, 0); } - public TerminalNode VAR() { return getToken(CSharpParser.VAR, 0); } - public TerminalNode WHEN() { return getToken(CSharpParser.WHEN, 0); } - public TerminalNode WHERE() { return getToken(CSharpParser.WHERE, 0); } - public TerminalNode YIELD() { return getToken(CSharpParser.YIELD, 0); } - public IdentifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_identifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).enterIdentifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof CSharpParserListener) ((CSharpParserListener)listener).exitIdentifier(this); - } - } - - public final IdentifierContext identifier() throws RecognitionException { - IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); - enterRule(_localctx, 434, RULE_identifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2639); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALIAS) | (1L << ARGLIST) | (1L << ASCENDING) | (1L << ASYNC) | (1L << AWAIT) | (1L << BY) | (1L << DESCENDING) | (1L << DYNAMIC) | (1L << EQUALS) | (1L << FROM) | (1L << GET) | (1L << GROUP) | (1L << INTO) | (1L << JOIN) | (1L << LET))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAMEOF - 64)) | (1L << (ON - 64)) | (1L << (ORDERBY - 64)) | (1L << (PARTIAL - 64)) | (1L << (REMOVE - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (UNMANAGED - 64)) | (1L << (VAR - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (YIELD - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 187: - return right_arrow_sempred((Right_arrowContext)_localctx, predIndex); - case 188: - return right_shift_sempred((Right_shiftContext)_localctx, predIndex); - case 189: - return right_shift_assignment_sempred((Right_shift_assignmentContext)_localctx, predIndex); - } - return true; - } - private boolean right_arrow_sempred(Right_arrowContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return (((Right_arrowContext)_localctx).first!=null?((Right_arrowContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_arrowContext)_localctx).second!=null?((Right_arrowContext)_localctx).second.getTokenIndex():0); - } - return true; - } - private boolean right_shift_sempred(Right_shiftContext _localctx, int predIndex) { - switch (predIndex) { - case 1: - return (((Right_shiftContext)_localctx).first!=null?((Right_shiftContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shiftContext)_localctx).second!=null?((Right_shiftContext)_localctx).second.getTokenIndex():0); - } - return true; - } - private boolean right_shift_assignment_sempred(Right_shift_assignmentContext _localctx, int predIndex) { - switch (predIndex) { - case 2: - return (((Right_shift_assignmentContext)_localctx).first!=null?((Right_shift_assignmentContext)_localctx).first.getTokenIndex():0) + 1 == (((Right_shift_assignmentContext)_localctx).second!=null?((Right_shift_assignmentContext)_localctx).second.getTokenIndex():0); - } - return true; - } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c8\u0a54\4\2\t"+ - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ - "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ - "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ - "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+ - "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+ - "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+ - "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+ - "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+ - "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+ - "\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+ - "\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+ - "\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+ - "\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+ - "\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+ - "\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+ - "\4\u00db\t\u00db\3\2\5\2\u01b8\n\2\3\2\5\2\u01bb\n\2\3\2\5\2\u01be\n\2"+ - "\3\2\7\2\u01c1\n\2\f\2\16\2\u01c4\13\2\3\2\5\2\u01c7\n\2\3\2\3\2\3\3\3"+ - "\3\5\3\u01cd\n\3\3\3\5\3\u01d0\n\3\3\3\3\3\3\3\5\3\u01d5\n\3\7\3\u01d7"+ - "\n\3\f\3\16\3\u01da\13\3\3\4\3\4\3\4\3\4\7\4\u01e0\n\4\f\4\16\4\u01e3"+ - "\13\4\3\5\3\5\3\5\3\5\3\5\5\5\u01ea\n\5\3\6\3\6\3\6\3\6\6\6\u01f0\n\6"+ - "\r\6\16\6\u01f1\3\6\3\6\3\7\3\7\5\7\u01f8\n\7\3\b\3\b\5\b\u01fc\n\b\3"+ - "\t\3\t\3\t\5\t\u0201\n\t\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u020b\n"+ - "\f\3\r\3\r\3\r\3\r\7\r\u0211\n\r\f\r\16\r\u0214\13\r\3\r\3\r\3\16\3\16"+ - "\3\16\7\16\u021b\n\16\f\16\16\16\u021e\13\16\3\17\3\17\3\17\5\17\u0223"+ - "\n\17\3\17\5\17\u0226\n\17\3\17\3\17\5\17\u022a\n\17\3\17\3\17\3\20\3"+ - "\20\3\20\3\20\5\20\u0232\n\20\3\21\3\21\3\21\5\21\u0237\n\21\3\22\3\22"+ - "\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u0241\n\22\3\23\3\23\3\23\3\23\3\23"+ - "\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u024e\n\23\3\24\3\24\3\24\3\24\3\24"+ - "\3\24\5\24\u0256\n\24\3\25\3\25\3\25\3\25\5\25\u025c\n\25\5\25\u025e\n"+ - "\25\3\26\3\26\3\26\7\26\u0263\n\26\f\26\16\26\u0266\13\26\3\27\3\27\3"+ - "\27\7\27\u026b\n\27\f\27\16\27\u026e\13\27\3\30\3\30\3\30\7\30\u0273\n"+ - "\30\f\30\16\30\u0276\13\30\3\31\3\31\3\31\7\31\u027b\n\31\f\31\16\31\u027e"+ - "\13\31\3\32\3\32\3\32\7\32\u0283\n\32\f\32\16\32\u0286\13\32\3\33\3\33"+ - "\3\33\7\33\u028b\n\33\f\33\16\33\u028e\13\33\3\34\3\34\3\34\3\34\3\34"+ - "\3\34\3\34\7\34\u0297\n\34\f\34\16\34\u029a\13\34\3\35\3\35\3\35\5\35"+ - "\u029f\n\35\3\35\7\35\u02a2\n\35\f\35\16\35\u02a5\13\35\3\36\3\36\3\36"+ - "\7\36\u02aa\n\36\f\36\16\36\u02ad\13\36\3\37\3\37\3\37\7\37\u02b2\n\37"+ - "\f\37\16\37\u02b5\13\37\3 \3 \3 \3 \3 \5 \u02bc\n \5 \u02be\n \3 \5 \u02c1"+ - "\n \3!\3!\3!\7!\u02c6\n!\f!\16!\u02c9\13!\3\"\3\"\5\"\u02cd\n\"\3\"\3"+ - "\"\3\"\3#\3#\5#\u02d4\n#\3#\3#\5#\u02d8\n#\5#\u02da\n#\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$\5$\u02f6"+ - "\n$\3%\3%\5%\u02fa\n%\3%\7%\u02fd\n%\f%\16%\u0300\13%\3%\5%\u0303\n%\3"+ - "%\3%\3%\3%\3%\3%\5%\u030b\n%\3%\5%\u030e\n%\3%\7%\u0311\n%\f%\16%\u0314"+ - "\13%\3%\5%\u0317\n%\7%\u0319\n%\f%\16%\u031c\13%\3&\3&\3&\5&\u0321\n&"+ - "\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u032f\n&\3&\3&\3&\3&\5&\u0335"+ - "\n&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u033f\n&\f&\16&\u0342\13&\3&\5&\u0345\n"+ - "&\3&\6&\u0348\n&\r&\16&\u0349\3&\3&\5&\u034e\n&\3&\3&\3&\3&\5&\u0354\n"+ - "&\3&\3&\3&\3&\6&\u035a\n&\r&\16&\u035b\3&\3&\3&\3&\3&\3&\3&\5&\u0365\n"+ - "&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0377\n&\3&\5&\u037a"+ - "\n&\3&\3&\3&\5&\u037f\n&\3&\5&\u0382\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&"+ - "\3&\7&\u038f\n&\f&\16&\u0392\13&\3&\3&\3&\5&\u0397\n&\3\'\3\'\5\'\u039b"+ - "\n\'\3(\3(\3(\3)\5)\u03a1\n)\3)\3)\3)\5)\u03a6\n)\3*\5*\u03a9\n*\3*\3"+ - "*\3*\3*\7*\u03af\n*\f*\16*\u03b2\13*\3*\3*\3+\3+\3+\5+\u03b9\n+\3+\3+"+ - "\3,\3,\3-\3-\3-\7-\u03c2\n-\f-\16-\u03c5\13-\3.\3.\5.\u03c9\n.\3/\3/\3"+ - "/\5/\u03ce\n/\5/\u03d0\n/\3/\3/\3\60\3\60\3\60\7\60\u03d7\n\60\f\60\16"+ - "\60\u03da\13\60\3\61\3\61\3\61\3\61\3\61\5\61\u03e1\n\61\3\61\3\61\3\61"+ - "\3\62\3\62\5\62\u03e8\n\62\3\63\3\63\3\63\3\63\7\63\u03ee\n\63\f\63\16"+ - "\63\u03f1\13\63\3\63\5\63\u03f4\n\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64"+ - "\5\64\u03fd\n\64\3\65\3\65\3\65\5\65\u0402\n\65\5\65\u0404\n\65\3\65\3"+ - "\65\3\66\3\66\3\66\7\66\u040b\n\66\f\66\16\66\u040e\13\66\3\67\3\67\3"+ - "\67\3\67\3\67\5\67\u0415\n\67\38\38\58\u0419\n8\38\38\38\58\u041e\n8\5"+ - "8\u0420\n8\38\38\38\58\u0425\n8\78\u0427\n8\f8\168\u042a\138\39\39\79"+ - "\u042e\n9\f9\169\u0431\139\39\39\3:\3:\3:\7:\u0438\n:\f:\16:\u043b\13"+ - ":\3:\5:\u043e\n:\3:\5:\u0441\n:\3:\5:\u0444\n:\3;\3;\3;\3;\7;\u044a\n"+ - ";\f;\16;\u044d\13;\3;\3;\3<\3<\3<\3<\3=\5=\u0456\n=\3=\3=\3=\3=\3>\3>"+ - "\3>\3>\3>\3>\3>\3>\3>\3>\3>\5>\u0467\n>\3?\3?\3?\7?\u046c\n?\f?\16?\u046f"+ - "\13?\3@\5@\u0472\n@\3@\3@\3@\3A\3A\3A\7A\u047a\nA\fA\16A\u047d\13A\3B"+ - "\3B\5B\u0481\nB\3C\3C\3C\3D\3D\5D\u0488\nD\3D\3D\3D\3D\3E\7E\u048f\nE"+ - "\fE\16E\u0492\13E\3E\3E\5E\u0496\nE\3F\3F\3F\3F\3F\5F\u049d\nF\3G\3G\3"+ - "G\3G\3G\3H\3H\3H\3I\3I\5I\u04a9\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u04b4"+ - "\nI\3J\3J\3J\3J\7J\u04ba\nJ\fJ\16J\u04bd\13J\3K\3K\5K\u04c1\nK\3L\3L\3"+ - "L\3L\3L\3L\3L\5L\u04ca\nL\3M\3M\3M\3M\3N\3N\3N\5N\u04d3\nN\3O\3O\3O\3"+ - "O\3O\3O\3O\5O\u04dc\nO\3P\3P\3P\3Q\5Q\u04e2\nQ\3Q\3Q\3Q\5Q\u04e7\nQ\3"+ - "Q\3Q\5Q\u04eb\nQ\3Q\3Q\5Q\u04ef\nQ\3R\3R\5R\u04f3\nR\3R\3R\5R\u04f7\n"+ - "R\3S\3S\3S\3S\3S\5S\u04fe\nS\3T\3T\3T\3T\3U\3U\5U\u0506\nU\3V\3V\3V\3"+ - "V\3V\3V\3V\3V\3V\3V\3V\5V\u0513\nV\3V\3V\3V\3V\3V\3V\7V\u051b\nV\fV\16"+ - "V\u051e\13V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5"+ - "V\u0533\nV\3V\3V\5V\u0537\nV\3V\3V\5V\u053b\nV\3V\3V\3V\5V\u0540\nV\3"+ - "V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0554\nV\3V\3"+ - "V\3V\5V\u0559\nV\3V\3V\3V\5V\u055e\nV\3V\3V\3V\3V\3V\5V\u0565\nV\3V\5"+ - "V\u0568\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3"+ - "V\5V\u057e\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u058a\nV\3W\3W\5W\u058e"+ - "\nW\3W\3W\3X\3X\3X\3X\5X\u0596\nX\3X\3X\3X\3X\7X\u059c\nX\fX\16X\u059f"+ - "\13X\3X\3X\3X\3X\5X\u05a5\nX\3Y\3Y\5Y\u05a9\nY\3Z\3Z\3Z\5Z\u05ae\nZ\3"+ - "Z\5Z\u05b1\nZ\3[\3[\3[\5[\u05b6\n[\3\\\3\\\3\\\3\\\3]\3]\5]\u05be\n]\3"+ - "^\6^\u05c1\n^\r^\16^\u05c2\3^\3^\3_\3_\3_\5_\u05ca\n_\3_\3_\3_\3_\5_\u05d0"+ - "\n_\3`\3`\3`\3a\6a\u05d6\na\ra\16a\u05d7\3b\3b\3b\3b\7b\u05de\nb\fb\16"+ - "b\u05e1\13b\5b\u05e3\nb\3c\3c\3c\7c\u05e8\nc\fc\16c\u05eb\13c\3d\3d\7"+ - "d\u05ef\nd\fd\16d\u05f2\13d\3d\5d\u05f5\nd\3d\5d\u05f8\nd\3e\3e\3e\3e"+ - "\5e\u05fe\ne\3e\3e\5e\u0602\ne\3e\3e\3f\3f\5f\u0608\nf\3f\3f\3g\3g\3g"+ - "\3g\3g\3h\3h\3h\3i\3i\5i\u0616\ni\3j\3j\3j\3j\5j\u061c\nj\3k\3k\3k\7k"+ - "\u0621\nk\fk\16k\u0624\13k\3l\3l\5l\u0628\nl\3l\5l\u062b\nl\3l\5l\u062e"+ - "\nl\3l\3l\3m\6m\u0633\nm\rm\16m\u0634\3n\3n\3n\3n\3n\3o\6o\u063d\no\r"+ - "o\16o\u063e\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\5p\u0650\np\3"+ - "q\6q\u0653\nq\rq\16q\u0654\3r\3r\5r\u0659\nr\3s\5s\u065c\ns\3s\5s\u065f"+ - "\ns\3s\3s\3s\3s\3s\5s\u0666\ns\3t\3t\3t\3t\5t\u066c\nt\3u\3u\3u\3u\7u"+ - "\u0672\nu\fu\16u\u0675\13u\3u\3u\3v\5v\u067a\nv\3v\3v\3w\3w\3w\3w\7w\u0682"+ - "\nw\fw\16w\u0685\13w\3x\3x\3x\7x\u068a\nx\fx\16x\u068d\13x\3y\6y\u0690"+ - "\ny\ry\16y\u0691\3z\3z\3z\3z\3z\3{\3{\3{\3{\5{\u069d\n{\3{\3{\5{\u06a1"+ - "\n{\5{\u06a3\n{\3|\3|\3|\5|\u06a8\n|\3|\3|\5|\u06ac\n|\3}\3}\3}\7}\u06b1"+ - "\n}\f}\16}\u06b4\13}\3~\3~\3~\3~\3\177\3\177\5\177\u06bc\n\177\3\177\3"+ - "\177\3\u0080\6\u0080\u06c1\n\u0080\r\u0080\16\u0080\u06c2\3\u0081\5\u0081"+ - "\u06c6\n\u0081\3\u0081\5\u0081\u06c9\n\u0081\3\u0081\3\u0081\5\u0081\u06cd"+ - "\n\u0081\3\u0082\6\u0082\u06d0\n\u0082\r\u0082\16\u0082\u06d1\3\u0083"+ - "\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ - "\3\u0084\5\u0084\u06df\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ - "\3\u0084\3\u0084\3\u0084\5\u0084\u06e9\n\u0084\3\u0085\3\u0085\3\u0085"+ - "\3\u0085\3\u0085\5\u0085\u06f0\n\u0085\3\u0085\3\u0085\3\u0085\3\u0085"+ - "\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u06fc\n\u0085"+ - "\3\u0086\3\u0086\3\u0086\7\u0086\u0701\n\u0086\f\u0086\16\u0086\u0704"+ - "\13\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\7\u0088"+ - "\u070d\n\u0088\f\u0088\16\u0088\u0710\13\u0088\3\u0089\3\u0089\3\u0089"+ - "\5\u0089\u0715\n\u0089\3\u008a\3\u008a\5\u008a\u0719\n\u008a\3\u008b\3"+ - "\u008b\5\u008b\u071d\n\u008b\3\u008c\3\u008c\3\u008d\3\u008d\5\u008d\u0723"+ - "\n\u008d\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u0729\n\u008e\5\u008e"+ - "\u072b\n\u008e\3\u008f\3\u008f\3\u008f\7\u008f\u0730\n\u008f\f\u008f\16"+ - "\u008f\u0733\13\u008f\3\u0090\5\u0090\u0736\n\u0090\3\u0090\5\u0090\u0739"+ - "\n\u0090\3\u0090\3\u0090\5\u0090\u073d\n\u0090\3\u0091\3\u0091\3\u0091"+ - "\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u0747\n\u0091\3\u0092"+ - "\5\u0092\u074a\n\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\5\u0093"+ - "\u0751\n\u0093\3\u0093\5\u0093\u0754\n\u0093\3\u0093\3\u0093\3\u0093\5"+ - "\u0093\u0759\n\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u075e\n\u0093\5\u0093"+ - "\u0760\n\u0093\3\u0094\5\u0094\u0763\n\u0094\3\u0094\5\u0094\u0766\n\u0094"+ - "\3\u0094\3\u0094\3\u0094\3\u0095\5\u0095\u076c\n\u0095\3\u0095\5\u0095"+ - "\u076f\n\u0095\3\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096"+ - "\3\u0096\3\u0096\3\u0096\5\u0096\u077b\n\u0096\3\u0097\3\u0097\5\u0097"+ - "\u077f\n\u0097\3\u0098\5\u0098\u0782\n\u0098\3\u0098\3\u0098\3\u0098\3"+ - "\u0098\3\u0098\3\u0098\3\u0098\3\u0098\5\u0098\u078c\n\u0098\3\u0099\5"+ - "\u0099\u078f\n\u0099\3\u0099\3\u0099\3\u0099\3\u009a\5\u009a\u0795\n\u009a"+ - "\3\u009a\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ - "\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ - "\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u07b0"+ - "\n\u009b\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d"+ - "\3\u009d\3\u009d\3\u009d\5\u009d\u07bd\n\u009d\3\u009d\3\u009d\3\u009e"+ - "\3\u009e\5\u009e\u07c3\n\u009e\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0"+ - "\7\u00a0\u07ca\n\u00a0\f\u00a0\16\u00a0\u07cd\13\u00a0\3\u00a0\3\u00a0"+ - "\3\u00a1\5\u00a1\u07d2\n\u00a1\3\u00a1\5\u00a1\u07d5\n\u00a1\3\u00a1\3"+ - "\u00a1\3\u00a1\3\u00a1\6\u00a1\u07db\n\u00a1\r\u00a1\16\u00a1\u07dc\3"+ - "\u00a1\3\u00a1\5\u00a1\u07e1\n\u00a1\3\u00a2\3\u00a2\7\u00a2\u07e5\n\u00a2"+ - "\f\u00a2\16\u00a2\u07e8\13\u00a2\3\u00a2\6\u00a2\u07eb\n\u00a2\r\u00a2"+ - "\16\u00a2\u07ec\3\u00a3\3\u00a3\7\u00a3\u07f1\n\u00a3\f\u00a3\16\u00a3"+ - "\u07f4\13\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\7\u00a4"+ - "\u07fc\n\u00a4\f\u00a4\16\u00a4\u07ff\13\u00a4\3\u00a4\5\u00a4\u0802\n"+ - "\u00a4\5\u00a4\u0804\n\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3"+ - "\u00a5\7\u00a5\u080c\n\u00a5\f\u00a5\16\u00a5\u080f\13\u00a5\3\u00a5\3"+ - "\u00a5\3\u00a6\5\u00a6\u0814\n\u00a6\3\u00a6\5\u00a6\u0817\n\u00a6\3\u00a6"+ - "\3\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a9\3\u00a9\7\u00a9"+ - "\u0822\n\u00a9\f\u00a9\16\u00a9\u0825\13\u00a9\3\u00a9\3\u00a9\3\u00aa"+ - "\5\u00aa\u082a\n\u00aa\3\u00aa\5\u00aa\u082d\n\u00aa\3\u00aa\5\u00aa\u0830"+ - "\n\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0837\n\u00aa"+ - "\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u083c\n\u00aa\3\u00aa\3\u00aa\5\u00aa"+ - "\u0840\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0844\n\u00aa\3\u00aa\3\u00aa\3"+ - "\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa"+ - "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0855\n\u00aa\3\u00aa\5\u00aa"+ - "\u0858\n\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u085d\n\u00aa\3\u00aa\3"+ - "\u00aa\5\u00aa\u0861\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0865\n\u00aa\3\u00aa"+ - "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u086e\n\u00aa"+ - "\3\u00ab\5\u00ab\u0871\n\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0876\n"+ - "\u00ab\3\u00ab\3\u00ab\5\u00ab\u087a\n\u00ab\3\u00ab\3\u00ab\3\u00ab\5"+ - "\u00ab\u087f\n\u00ab\3\u00ab\3\u00ab\5\u00ab\u0883\n\u00ab\5\u00ab\u0885"+ - "\n\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\7\u00ad"+ - "\u088e\n\u00ad\f\u00ad\16\u00ad\u0891\13\u00ad\3\u00ad\5\u00ad\u0894\n"+ - "\u00ad\5\u00ad\u0896\n\u00ad\3\u00ad\3\u00ad\3\u00ae\5\u00ae\u089b\n\u00ae"+ - "\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u08a0\n\u00ae\3\u00af\3\u00af\3\u00af"+ - "\3\u00af\3\u00af\5\u00af\u08a7\n\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0"+ - "\5\u00b0\u08ad\n\u00b0\3\u00b1\6\u00b1\u08b0\n\u00b1\r\u00b1\16\u00b1"+ - "\u08b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u08b8\n\u00b2\3\u00b2\3"+ - "\u00b2\5\u00b2\u08bc\n\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\5\u00b3\u08c2"+ - "\n\u00b3\3\u00b4\3\u00b4\3\u00b4\7\u00b4\u08c7\n\u00b4\f\u00b4\16\u00b4"+ - "\u08ca\13\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u08d1"+ - "\n\u00b5\f\u00b5\16\u00b5\u08d4\13\u00b5\5\u00b5\u08d6\n\u00b5\3\u00b5"+ - "\5\u00b5\u08d9\n\u00b5\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u08de\n\u00b6\3"+ - "\u00b6\3\u00b6\3\u00b7\3\u00b7\5\u00b7\u08e4\n\u00b7\3\u00b7\3\u00b7\7"+ - "\u00b7\u08e8\n\u00b7\f\u00b7\16\u00b7\u08eb\13\u00b7\3\u00b7\3\u00b7\3"+ - "\u00b7\3\u00b7\5\u00b7\u08f1\n\u00b7\3\u00b8\3\u00b8\3\u00b8\7\u00b8\u08f6"+ - "\n\u00b8\f\u00b8\16\u00b8\u08f9\13\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ - "\3\u00ba\5\u00ba\u0900\n\u00ba\3\u00ba\3\u00ba\5\u00ba\u0904\n\u00ba\3"+ - "\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc"+ - "\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0913\n\u00bc\3\u00bc\3\u00bc"+ - "\5\u00bc\u0917\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc"+ - "\u091e\n\u00bc\f\u00bc\16\u00bc\u0921\13\u00bc\3\u00bc\5\u00bc\u0924\n"+ - "\u00bc\3\u00bc\3\u00bc\5\u00bc\u0928\n\u00bc\3\u00bd\3\u00bd\3\u00bd\3"+ - "\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf"+ - "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0"+ - "\u093e\n\u00c0\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\5\u00c2"+ - "\u0946\n\u00c2\3\u00c3\3\u00c3\7\u00c3\u094a\n\u00c3\f\u00c3\16\u00c3"+ - "\u094d\13\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\7\u00c4\u0953\n\u00c4"+ - "\f\u00c4\16\u00c4\u0956\13\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\3\u00c5"+ - "\3\u00c5\5\u00c5\u095e\n\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6"+ - "\u0964\n\u00c6\3\u00c7\3\u00c7\3\u00c7\7\u00c7\u0969\n\u00c7\f\u00c7\16"+ - "\u00c7\u096c\13\u00c7\3\u00c7\3\u00c7\6\u00c7\u0970\n\u00c7\r\u00c7\16"+ - "\u00c7\u0971\5\u00c7\u0974\n\u00c7\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9"+ - "\5\u00c9\u097b\n\u00c9\3\u00c9\5\u00c9\u097e\n\u00c9\3\u00c9\5\u00c9\u0981"+ - "\n\u00c9\3\u00c9\3\u00c9\5\u00c9\u0985\n\u00c9\3\u00ca\5\u00ca\u0988\n"+ - "\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u098d\n\u00ca\3\u00ca\5\u00ca\u0990"+ - "\n\u00ca\3\u00ca\5\u00ca\u0993\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u0997\n"+ - "\u00ca\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u099c\n\u00cb\3\u00cb\5\u00cb\u099f"+ - "\n\u00cb\3\u00cb\5\u00cb\u09a2\n\u00cb\3\u00cb\3\u00cb\5\u00cb\u09a6\n"+ - "\u00cb\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09ab\n\u00cc\3\u00cc\3\u00cc\5"+ - "\u00cc\u09af\n\u00cc\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u09b5\n\u00cd"+ - "\3\u00cd\3\u00cd\5\u00cd\u09b9\n\u00cd\3\u00cd\3\u00cd\5\u00cd\u09bd\n"+ - "\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce"+ - "\3\u00ce\3\u00ce\3\u00ce\3\u00ce\5\u00ce\u09cb\n\u00ce\3\u00cf\3\u00cf"+ - "\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+ - "\5\u00d0\u09d8\n\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u09de\n"+ - "\u00d0\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2"+ - "\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2"+ - "\5\u00d2\u09f1\n\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3"+ - "\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09fc\n\u00d4\3\u00d4\3\u00d4\5\u00d4"+ - "\u0a00\n\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\5\u00d5\u0a06\n\u00d5\3"+ - "\u00d5\3\u00d5\5\u00d5\u0a0a\n\u00d5\3\u00d5\3\u00d5\5\u00d5\u0a0e\n\u00d5"+ - "\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d5\5\u00d5\u0a15\n\u00d5\3\u00d6"+ - "\3\u00d6\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a1c\n\u00d6\3\u00d6\5\u00d6"+ - "\u0a1f\n\u00d6\3\u00d6\3\u00d6\7\u00d6\u0a23\n\u00d6\f\u00d6\16\u00d6"+ - "\u0a26\13\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a2c\n\u00d7"+ - "\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a31\n\u00d7\3\u00d7\5\u00d7\u0a34\n"+ - "\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u0a3c\n"+ - "\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a42\n\u00d8\3\u00d9\3"+ - "\u00d9\5\u00d9\u0a46\n\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\5\u00da\u0a4c"+ - "\n\u00da\3\u00da\3\u00da\5\u00da\u0a50\n\u00da\3\u00db\3\u00db\3\u00db"+ - "\2\2\u00dc\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66"+ - "8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a"+ - "\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2"+ - "\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba"+ - "\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2"+ - "\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea"+ - "\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102"+ - "\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a"+ - "\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132"+ - "\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a"+ - "\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162"+ - "\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a"+ - "\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192"+ - "\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa"+ - "\u01ac\u01ae\u01b0\u01b2\u01b4\2\25\n\2\27\27\32\3299AAUUYYefjj\4\2$$"+ - "//\5\288JJRR\3\2\u009e\u009f\4\2\u0094\u0095\u00a0\u00a1\3\2\u0089\u008a"+ - "\3\2\u008b\u008d\20\2\24\24\27\27\32\32\37\37$$//99AAFFUUYY]]efjj\4\2"+ - "\20\20\"\"\4\2\21\21ii\16\2\13\13\21\21++;;DDKKMQVV\\\\iimmoo\4\2**\67"+ - "\67\4\2\23\23``\4\2\u008b\u008b\u0096\u0096\4\288JJ\4\2,,bb\25\2\13\13"+ - "\17\17\23\25\27!#$&\')\61\64\64\66;==@ACFHHJLNRTVYkmorr\3\2QR\26\2\f\16"+ - "\20\22\26\26\"\"%%((\62\63\65\65<<>?BBGGIIMMSSWXhhllpqst\2\u0b62\2\u01b7"+ - "\3\2\2\2\4\u01cf\3\2\2\2\6\u01db\3\2\2\2\b\u01e9\3\2\2\2\n\u01eb\3\2\2"+ - "\2\f\u01f5\3\2\2\2\16\u01fb\3\2\2\2\20\u0200\3\2\2\2\22\u0202\3\2\2\2"+ - "\24\u0204\3\2\2\2\26\u020a\3\2\2\2\30\u020c\3\2\2\2\32\u0217\3\2\2\2\34"+ - "\u0222\3\2\2\2\36\u0231\3\2\2\2 \u0236\3\2\2\2\"\u0240\3\2\2\2$\u024d"+ - "\3\2\2\2&\u024f\3\2\2\2(\u0257\3\2\2\2*\u025f\3\2\2\2,\u0267\3\2\2\2."+ - "\u026f\3\2\2\2\60\u0277\3\2\2\2\62\u027f\3\2\2\2\64\u0287\3\2\2\2\66\u028f"+ - "\3\2\2\28\u029b\3\2\2\2:\u02a6\3\2\2\2<\u02ae\3\2\2\2>\u02b6\3\2\2\2@"+ - "\u02c2\3\2\2\2B\u02ca\3\2\2\2D\u02d9\3\2\2\2F\u02f5\3\2\2\2H\u02f7\3\2"+ - "\2\2J\u0396\3\2\2\2L\u039a\3\2\2\2N\u039c\3\2\2\2P\u03a0\3\2\2\2R\u03a8"+ - "\3\2\2\2T\u03b8\3\2\2\2V\u03bc\3\2\2\2X\u03be\3\2\2\2Z\u03c8\3\2\2\2\\"+ - "\u03ca\3\2\2\2^\u03d3\3\2\2\2`\u03e0\3\2\2\2b\u03e7\3\2\2\2d\u03e9\3\2"+ - "\2\2f\u03fc\3\2\2\2h\u03fe\3\2\2\2j\u0407\3\2\2\2l\u0414\3\2\2\2n\u0416"+ - "\3\2\2\2p\u042b\3\2\2\2r\u0434\3\2\2\2t\u0445\3\2\2\2v\u0450\3\2\2\2x"+ - "\u0455\3\2\2\2z\u0466\3\2\2\2|\u0468\3\2\2\2~\u0471\3\2\2\2\u0080\u0476"+ - "\3\2\2\2\u0082\u0480\3\2\2\2\u0084\u0482\3\2\2\2\u0086\u0485\3\2\2\2\u0088"+ - "\u0490\3\2\2\2\u008a\u049c\3\2\2\2\u008c\u049e\3\2\2\2\u008e\u04a3\3\2"+ - "\2\2\u0090\u04a6\3\2\2\2\u0092\u04b5\3\2\2\2\u0094\u04be\3\2\2\2\u0096"+ - "\u04c9\3\2\2\2\u0098\u04cb\3\2\2\2\u009a\u04d2\3\2\2\2\u009c\u04db\3\2"+ - "\2\2\u009e\u04dd\3\2\2\2\u00a0\u04e1\3\2\2\2\u00a2\u04f6\3\2\2\2\u00a4"+ - "\u04fd\3\2\2\2\u00a6\u04ff\3\2\2\2\u00a8\u0505\3\2\2\2\u00aa\u0589\3\2"+ - "\2\2\u00ac\u058b\3\2\2\2\u00ae\u05a4\3\2\2\2\u00b0\u05a8\3\2\2\2\u00b2"+ - "\u05aa\3\2\2\2\u00b4\u05b5\3\2\2\2\u00b6\u05b7\3\2\2\2\u00b8\u05bd\3\2"+ - "\2\2\u00ba\u05c0\3\2\2\2\u00bc\u05cf\3\2\2\2\u00be\u05d1\3\2\2\2\u00c0"+ - "\u05d5\3\2\2\2\u00c2\u05e2\3\2\2\2\u00c4\u05e4\3\2\2\2\u00c6\u05f7\3\2"+ - "\2\2\u00c8\u05f9\3\2\2\2\u00ca\u0605\3\2\2\2\u00cc\u060b\3\2\2\2\u00ce"+ - "\u0610\3\2\2\2\u00d0\u0615\3\2\2\2\u00d2\u0617\3\2\2\2\u00d4\u061d\3\2"+ - "\2\2\u00d6\u0625\3\2\2\2\u00d8\u0632\3\2\2\2\u00da\u0636\3\2\2\2\u00dc"+ - "\u063c\3\2\2\2\u00de\u064f\3\2\2\2\u00e0\u0652\3\2\2\2\u00e2\u0658\3\2"+ - "\2\2\u00e4\u065b\3\2\2\2\u00e6\u0667\3\2\2\2\u00e8\u066d\3\2\2\2\u00ea"+ - "\u0679\3\2\2\2\u00ec\u067d\3\2\2\2\u00ee\u0686\3\2\2\2\u00f0\u068f\3\2"+ - "\2\2\u00f2\u0693\3\2\2\2\u00f4\u06a2\3\2\2\2\u00f6\u06ab\3\2\2\2\u00f8"+ - "\u06ad\3\2\2\2\u00fa\u06b5\3\2\2\2\u00fc\u06b9\3\2\2\2\u00fe\u06c0\3\2"+ - "\2\2\u0100\u06c5\3\2\2\2\u0102\u06cf\3\2\2\2\u0104\u06d3\3\2\2\2\u0106"+ - "\u06e8\3\2\2\2\u0108\u06ef\3\2\2\2\u010a\u06fd\3\2\2\2\u010c\u0705\3\2"+ - "\2\2\u010e\u0709\3\2\2\2\u0110\u0711\3\2\2\2\u0112\u0718\3\2\2\2\u0114"+ - "\u071c\3\2\2\2\u0116\u071e\3\2\2\2\u0118\u0722\3\2\2\2\u011a\u072a\3\2"+ - "\2\2\u011c\u072c\3\2\2\2\u011e\u073c\3\2\2\2\u0120\u0746\3\2\2\2\u0122"+ - "\u0749\3\2\2\2\u0124\u0750\3\2\2\2\u0126\u0762\3\2\2\2\u0128\u076b\3\2"+ - "\2\2\u012a\u077a\3\2\2\2\u012c\u077e\3\2\2\2\u012e\u0781\3\2\2\2\u0130"+ - "\u078e\3\2\2\2\u0132\u0794\3\2\2\2\u0134\u07af\3\2\2\2\u0136\u07b1\3\2"+ - "\2\2\u0138\u07b8\3\2\2\2\u013a\u07c2\3\2\2\2\u013c\u07c4\3\2\2\2\u013e"+ - "\u07c7\3\2\2\2\u0140\u07d1\3\2\2\2\u0142\u07e2\3\2\2\2\u0144\u07ee\3\2"+ - "\2\2\u0146\u07f7\3\2\2\2\u0148\u0807\3\2\2\2\u014a\u0813\3\2\2\2\u014c"+ - "\u081a\3\2\2\2\u014e\u081c\3\2\2\2\u0150\u081f\3\2\2\2\u0152\u0829\3\2"+ - "\2\2\u0154\u0870\3\2\2\2\u0156\u0886\3\2\2\2\u0158\u0889\3\2\2\2\u015a"+ - "\u089a\3\2\2\2\u015c\u08a1\3\2\2\2\u015e\u08ac\3\2\2\2\u0160\u08af\3\2"+ - "\2\2\u0162\u08b3\3\2\2\2\u0164\u08c1\3\2\2\2\u0166\u08c3\3\2\2\2\u0168"+ - "\u08cb\3\2\2\2\u016a\u08dd\3\2\2\2\u016c\u08f0\3\2\2\2\u016e\u08f2\3\2"+ - "\2\2\u0170\u08fa\3\2\2\2\u0172\u0903\3\2\2\2\u0174\u0905\3\2\2\2\u0176"+ - "\u0927\3\2\2\2\u0178\u0929\3\2\2\2\u017a\u092d\3\2\2\2\u017c\u0931\3\2"+ - "\2\2\u017e\u093d\3\2\2\2\u0180\u093f\3\2\2\2\u0182\u0945\3\2\2\2\u0184"+ - "\u0947\3\2\2\2\u0186\u0950\3\2\2\2\u0188\u095d\3\2\2\2\u018a\u0963\3\2"+ - "\2\2\u018c\u0965\3\2\2\2\u018e\u0975\3\2\2\2\u0190\u0977\3\2\2\2\u0192"+ - "\u0987\3\2\2\2\u0194\u0998\3\2\2\2\u0196\u09a7\3\2\2\2\u0198\u09b0\3\2"+ - "\2\2\u019a\u09c0\3\2\2\2\u019c\u09cc\3\2\2\2\u019e\u09cf\3\2\2\2\u01a0"+ - "\u09df\3\2\2\2\u01a2\u09e4\3\2\2\2\u01a4\u09f2\3\2\2\2\u01a6\u09f8\3\2"+ - "\2\2\u01a8\u0a03\3\2\2\2\u01aa\u0a1b\3\2\2\2\u01ac\u0a27\3\2\2\2\u01ae"+ - "\u0a3d\3\2\2\2\u01b0\u0a43\3\2\2\2\u01b2\u0a49\3\2\2\2\u01b4\u0a51\3\2"+ - "\2\2\u01b6\u01b8\7\3\2\2\u01b7\u01b6\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8"+ - "\u01ba\3\2\2\2\u01b9\u01bb\5\u00d8m\2\u01ba\u01b9\3\2\2\2\u01ba\u01bb"+ - "\3\2\2\2\u01bb\u01bd\3\2\2\2\u01bc\u01be\5\u00dco\2\u01bd\u01bc\3\2\2"+ - "\2\u01bd\u01be\3\2\2\2\u01be\u01c2\3\2\2\2\u01bf\u01c1\5\u015c\u00af\2"+ - "\u01c0\u01bf\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c2\u01c3"+ - "\3\2\2\2\u01c3\u01c6\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c5\u01c7\5\u00e0q"+ - "\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9"+ - "\7\2\2\3\u01c9\3\3\2\2\2\u01ca\u01cc\5\u01b4\u00db\2\u01cb\u01cd\5\30"+ - "\r\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce"+ - "\u01d0\5\u00e6t\2\u01cf\u01ca\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d8"+ - "\3\2\2\2\u01d1\u01d2\7\u0085\2\2\u01d2\u01d4\5\u01b4\u00db\2\u01d3\u01d5"+ - "\5\30\r\2\u01d4\u01d3\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d7\3\2\2\2"+ - "\u01d6\u01d1\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9"+ - "\3\2\2\2\u01d9\5\3\2\2\2\u01da\u01d8\3\2\2\2\u01db\u01e1\5\b\5\2\u01dc"+ - "\u01e0\7\u0096\2\2\u01dd\u01e0\5\u0144\u00a3\2\u01de\u01e0\7\u008b\2\2"+ - "\u01df\u01dc\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01de\3\2\2\2\u01e0\u01e3"+ - "\3\2\2\2\u01e1\u01df\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\7\3\2\2\2\u01e3"+ - "\u01e1\3\2\2\2\u01e4\u01ea\5\16\b\2\u01e5\u01ea\5\26\f\2\u01e6\u01e7\7"+ - "n\2\2\u01e7\u01ea\7\u008b\2\2\u01e8\u01ea\5\n\6\2\u01e9\u01e4\3\2\2\2"+ - "\u01e9\u01e5\3\2\2\2\u01e9\u01e6\3\2\2\2\u01e9\u01e8\3\2\2\2\u01ea\t\3"+ - "\2\2\2\u01eb\u01ec\7\u0083\2\2\u01ec\u01ef\5\f\7\2\u01ed\u01ee\7\u0086"+ - "\2\2\u01ee\u01f0\5\f\7\2\u01ef\u01ed\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1"+ - "\u01ef\3\2\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4\7\u0084"+ - "\2\2\u01f4\13\3\2\2\2\u01f5\u01f7\5\6\4\2\u01f6\u01f8\5\u01b4\u00db\2"+ - "\u01f7\u01f6\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\r\3\2\2\2\u01f9\u01fc\5"+ - "\20\t\2\u01fa\u01fc\7\24\2\2\u01fb\u01f9\3\2\2\2\u01fb\u01fa\3\2\2\2\u01fc"+ - "\17\3\2\2\2\u01fd\u0201\5\22\n\2\u01fe\u0201\5\24\13\2\u01ff\u0201\7\37"+ - "\2\2\u0200\u01fd\3\2\2\2\u0200\u01fe\3\2\2\2\u0200\u01ff\3\2\2\2\u0201"+ - "\21\3\2\2\2\u0202\u0203\t\2\2\2\u0203\23\3\2\2\2\u0204\u0205\t\3\2\2\u0205"+ - "\25\3\2\2\2\u0206\u020b\5\4\3\2\u0207\u020b\7F\2\2\u0208\u020b\7%\2\2"+ - "\u0209\u020b\7]\2\2\u020a\u0206\3\2\2\2\u020a\u0207\3\2\2\2\u020a\u0208"+ - "\3\2\2\2\u020a\u0209\3\2\2\2\u020b\27\3\2\2\2\u020c\u020d\7\u0094\2\2"+ - "\u020d\u0212\5\6\4\2\u020e\u020f\7\u0086\2\2\u020f\u0211\5\6\4\2\u0210"+ - "\u020e\3\2\2\2\u0211\u0214\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2"+ - "\2\2\u0213\u0215\3\2\2\2\u0214\u0212\3\2\2\2\u0215\u0216\7\u0095\2\2\u0216"+ - "\31\3\2\2\2\u0217\u021c\5\34\17\2\u0218\u0219\7\u0086\2\2\u0219\u021b"+ - "\5\34\17\2\u021a\u0218\3\2\2\2\u021b\u021e\3\2\2\2\u021c\u021a\3\2\2\2"+ - "\u021c\u021d\3\2\2\2\u021d\33\3\2\2\2\u021e\u021c\3\2\2\2\u021f\u0220"+ - "\5\u01b4\u00db\2\u0220\u0221\7\u0087\2\2\u0221\u0223\3\2\2\2\u0222\u021f"+ - "\3\2\2\2\u0222\u0223\3\2\2\2\u0223\u0225\3\2\2\2\u0224\u0226\t\4\2\2\u0225"+ - "\u0224\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0229\3\2\2\2\u0227\u022a\7l"+ - "\2\2\u0228\u022a\5\6\4\2\u0229\u0227\3\2\2\2\u0229\u0228\3\2\2\2\u0229"+ - "\u022a\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u022c\5\36\20\2\u022c\35\3\2"+ - "\2\2\u022d\u0232\5\"\22\2\u022e\u0232\5 \21\2\u022f\u0230\7R\2\2\u0230"+ - "\u0232\5 \21\2\u0231\u022d\3\2\2\2\u0231\u022e\3\2\2\2\u0231\u022f\3\2"+ - "\2\2\u0232\37\3\2\2\2\u0233\u0237\5x=\2\u0234\u0237\5\u0084C\2\u0235\u0237"+ - "\5&\24\2\u0236\u0233\3\2\2\2\u0236\u0234\3\2\2\2\u0236\u0235\3\2\2\2\u0237"+ - "!\3\2\2\2\u0238\u0239\5F$\2\u0239\u023a\5$\23\2\u023a\u023b\5\36\20\2"+ - "\u023b\u0241\3\2\2\2\u023c\u023d\5F$\2\u023d\u023e\7\u00ac\2\2\u023e\u023f"+ - "\5L\'\2\u023f\u0241\3\2\2\2\u0240\u0238\3\2\2\2\u0240\u023c\3\2\2\2\u0241"+ - "#\3\2\2\2\u0242\u024e\7\u0093\2\2\u0243\u024e\7\u00a2\2\2\u0244\u024e"+ - "\7\u00a3\2\2\u0245\u024e\7\u00a4\2\2\u0246\u024e\7\u00a5\2\2\u0247\u024e"+ - "\7\u00a6\2\2\u0248\u024e\7\u00a7\2\2\u0249\u024e\7\u00a8\2\2\u024a\u024e"+ - "\7\u00a9\2\2\u024b\u024e\7\u00ab\2\2\u024c\u024e\5\u017c\u00bf\2\u024d"+ - "\u0242\3\2\2\2\u024d\u0243\3\2\2\2\u024d\u0244\3\2\2\2\u024d\u0245\3\2"+ - "\2\2\u024d\u0246\3\2\2\2\u024d\u0247\3\2\2\2\u024d\u0248\3\2\2\2\u024d"+ - "\u0249\3\2\2\2\u024d\u024a\3\2\2\2\u024d\u024b\3\2\2\2\u024d\u024c\3\2"+ - "\2\2\u024e%\3\2\2\2\u024f\u0255\5(\25\2\u0250\u0251\7\u0096\2\2\u0251"+ - "\u0252\5L\'\2\u0252\u0253\7\u0087\2\2\u0253\u0254\5L\'\2\u0254\u0256\3"+ - "\2\2\2\u0255\u0250\3\2\2\2\u0255\u0256\3\2\2\2\u0256\'\3\2\2\2\u0257\u025d"+ - "\5*\26\2\u0258\u025b\7\u0098\2\2\u0259\u025c\5(\25\2\u025a\u025c\5N(\2"+ - "\u025b\u0259\3\2\2\2\u025b\u025a\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u0258"+ - "\3\2\2\2\u025d\u025e\3\2\2\2\u025e)\3\2\2\2\u025f\u0264\5,\27\2\u0260"+ - "\u0261\7\u009c\2\2\u0261\u0263\5,\27\2\u0262\u0260\3\2\2\2\u0263\u0266"+ - "\3\2\2\2\u0264\u0262\3\2\2\2\u0264\u0265\3\2\2\2\u0265+\3\2\2\2\u0266"+ - "\u0264\3\2\2\2\u0267\u026c\5.\30\2\u0268\u0269\7\u009b\2\2\u0269\u026b"+ - "\5.\30\2\u026a\u0268\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026a\3\2\2\2\u026c"+ - "\u026d\3\2\2\2\u026d-\3\2\2\2\u026e\u026c\3\2\2\2\u026f\u0274\5\60\31"+ - "\2\u0270\u0271\7\u008f\2\2\u0271\u0273\5\60\31\2\u0272\u0270\3\2\2\2\u0273"+ - "\u0276\3\2\2\2\u0274\u0272\3\2\2\2\u0274\u0275\3\2\2\2\u0275/\3\2\2\2"+ - "\u0276\u0274\3\2\2\2\u0277\u027c\5\62\32\2\u0278\u0279\7\u0090\2\2\u0279"+ - "\u027b\5\62\32\2\u027a\u0278\3\2\2\2\u027b\u027e\3\2\2\2\u027c\u027a\3"+ - "\2\2\2\u027c\u027d\3\2\2\2\u027d\61\3\2\2\2\u027e\u027c\3\2\2\2\u027f"+ - "\u0284\5\64\33\2\u0280\u0281\7\u008e\2\2\u0281\u0283\5\64\33\2\u0282\u0280"+ - "\3\2\2\2\u0283\u0286\3\2\2\2\u0284\u0282\3\2\2\2\u0284\u0285\3\2\2\2\u0285"+ - "\63\3\2\2\2\u0286\u0284\3\2\2\2\u0287\u028c\5\66\34\2\u0288\u0289\t\5"+ - "\2\2\u0289\u028b\5\66\34\2\u028a\u0288\3\2\2\2\u028b\u028e\3\2\2\2\u028c"+ - "\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d\65\3\2\2\2\u028e\u028c\3\2\2"+ - "\2\u028f\u0298\58\35\2\u0290\u0291\t\6\2\2\u0291\u0297\58\35\2\u0292\u0293"+ - "\7=\2\2\u0293\u0297\5r:\2\u0294\u0295\7\17\2\2\u0295\u0297\5\6\4\2\u0296"+ - "\u0290\3\2\2\2\u0296\u0292\3\2\2\2\u0296\u0294\3\2\2\2\u0297\u029a\3\2"+ - "\2\2\u0298\u0296\3\2\2\2\u0298\u0299\3\2\2\2\u0299\67\3\2\2\2\u029a\u0298"+ - "\3\2\2\2\u029b\u02a3\5:\36\2\u029c\u029f\7\u00aa\2\2\u029d\u029f\5\u017a"+ - "\u00be\2\u029e\u029c\3\2\2\2\u029e\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0"+ - "\u02a2\5:\36\2\u02a1\u029e\3\2\2\2\u02a2\u02a5\3\2\2\2\u02a3\u02a1\3\2"+ - "\2\2\u02a3\u02a4\3\2\2\2\u02a49\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6\u02ab"+ - "\5<\37\2\u02a7\u02a8\t\7\2\2\u02a8\u02aa\5<\37\2\u02a9\u02a7\3\2\2\2\u02aa"+ - "\u02ad\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac;\3\2\2\2"+ - "\u02ad\u02ab\3\2\2\2\u02ae\u02b3\5> \2\u02af\u02b0\t\b\2\2\u02b0\u02b2"+ - "\5> \2\u02b1\u02af\3\2\2\2\u02b2\u02b5\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b3"+ - "\u02b4\3\2\2\2\u02b4=\3\2\2\2\u02b5\u02b3\3\2\2\2\u02b6\u02c0\5D#\2\u02b7"+ - "\u02b8\7_\2\2\u02b8\u02bd\7\177\2\2\u02b9\u02bb\5@!\2\u02ba\u02bc\7\u0086"+ - "\2\2\u02bb\u02ba\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02be\3\2\2\2\u02bd"+ - "\u02b9\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c1\7\u0080"+ - "\2\2\u02c0\u02b7\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1?\3\2\2\2\u02c2\u02c7"+ - "\5B\"\2\u02c3\u02c4\7\u0086\2\2\u02c4\u02c6\5B\"\2\u02c5\u02c3\3\2\2\2"+ - "\u02c6\u02c9\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8A\3"+ - "\2\2\2\u02c9\u02c7\3\2\2\2\u02ca\u02cc\5\36\20\2\u02cb\u02cd\5\u00be`"+ - "\2\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf"+ - "\5\u0178\u00bd\2\u02cf\u02d0\5L\'\2\u02d0C\3\2\2\2\u02d1\u02da\5F$\2\u02d2"+ - "\u02d4\5F$\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d5\3\2\2"+ - "\2\u02d5\u02d7\7\u00ad\2\2\u02d6\u02d8\5F$\2\u02d7\u02d6\3\2\2\2\u02d7"+ - "\u02d8\3\2\2\2\u02d8\u02da\3\2\2\2\u02d9\u02d1\3\2\2\2\u02d9\u02d3\3\2"+ - "\2\2\u02daE\3\2\2\2\u02db\u02f6\5H%\2\u02dc\u02dd\7\u0089\2\2\u02dd\u02f6"+ - "\5F$\2\u02de\u02df\7\u008a\2\2\u02df\u02f6\5F$\2\u02e0\u02e1\7\u0091\2"+ - "\2\u02e1\u02f6\5F$\2\u02e2\u02e3\7\u0092\2\2\u02e3\u02f6\5F$\2\u02e4\u02e5"+ - "\7\u0099\2\2\u02e5\u02f6\5F$\2\u02e6\u02e7\7\u009a\2\2\u02e7\u02f6\5F"+ - "$\2\u02e8\u02e9\7\u0083\2\2\u02e9\u02ea\5\6\4\2\u02ea\u02eb\7\u0084\2"+ - "\2\u02eb\u02ec\5F$\2\u02ec\u02f6\3\2\2\2\u02ed\u02ee\7\22\2\2\u02ee\u02f6"+ - "\5F$\2\u02ef\u02f0\7\u008e\2\2\u02f0\u02f6\5F$\2\u02f1\u02f2\7\u008b\2"+ - "\2\u02f2\u02f6\5F$\2\u02f3\u02f4\7\u0090\2\2\u02f4\u02f6\5F$\2\u02f5\u02db"+ - "\3\2\2\2\u02f5\u02dc\3\2\2\2\u02f5\u02de\3\2\2\2\u02f5\u02e0\3\2\2\2\u02f5"+ - "\u02e2\3\2\2\2\u02f5\u02e4\3\2\2\2\u02f5\u02e6\3\2\2\2\u02f5\u02e8\3\2"+ - "\2\2\u02f5\u02ed\3\2\2\2\u02f5\u02ef\3\2\2\2\u02f5\u02f1\3\2\2\2\u02f5"+ - "\u02f3\3\2\2\2\u02f6G\3\2\2\2\u02f7\u02f9\5J&\2\u02f8\u02fa\7\u0091\2"+ - "\2\u02f9\u02f8\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fe\3\2\2\2\u02fb\u02fd"+ - "\5R*\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe"+ - "\u02ff\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0301\u0303\7\u0091"+ - "\2\2\u0302\u0301\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u031a\3\2\2\2\u0304"+ - "\u030b\5P)\2\u0305\u030b\5\u01b0\u00d9\2\u0306\u030b\7\u0099\2\2\u0307"+ - "\u030b\7\u009a\2\2\u0308\u0309\7\u009d\2\2\u0309\u030b\5\u01b4\u00db\2"+ - "\u030a\u0304\3\2\2\2\u030a\u0305\3\2\2\2\u030a\u0306\3\2\2\2\u030a\u0307"+ - "\3\2\2\2\u030a\u0308\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030e\7\u0091\2"+ - "\2\u030d\u030c\3\2\2\2\u030d\u030e\3\2\2\2\u030e\u0312\3\2\2\2\u030f\u0311"+ - "\5R*\2\u0310\u030f\3\2\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312"+ - "\u0313\3\2\2\2\u0313\u0316\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0317\7\u0091"+ - "\2\2\u0316\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0319\3\2\2\2\u0318"+ - "\u030a\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u0318\3\2\2\2\u031a\u031b\3\2"+ - "\2\2\u031bI\3\2\2\2\u031c\u031a\3\2\2\2\u031d\u0397\5\u017e\u00c0\2\u031e"+ - "\u0320\5\u01b4\u00db\2\u031f\u0321\5\30\r\2\u0320\u031f\3\2\2\2\u0320"+ - "\u0321\3\2\2\2\u0321\u0397\3\2\2\2\u0322\u0323\7\u0083\2\2\u0323\u0324"+ - "\5\36\20\2\u0324\u0325\7\u0084\2\2\u0325\u0397\3\2\2\2\u0326\u0397\5V"+ - ",\2\u0327\u0397\5\u00e6t\2\u0328\u0397\7u\2\2\u0329\u0397\7`\2\2\u032a"+ - "\u0334\7\23\2\2\u032b\u032c\7\u0085\2\2\u032c\u032e\5\u01b4\u00db\2\u032d"+ - "\u032f\5\30\r\2\u032e\u032d\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0335\3"+ - "\2\2\2\u0330\u0331\7\u0081\2\2\u0331\u0332\5X-\2\u0332\u0333\7\u0082\2"+ - "\2\u0333\u0335\3\2\2\2\u0334\u032b\3\2\2\2\u0334\u0330\3\2\2\2\u0335\u0397"+ - "\3\2\2\2\u0336\u0353\7D\2\2\u0337\u034d\5\6\4\2\u0338\u034e\5\u01b2\u00da"+ - "\2\u0339\u034e\5Z.\2\u033a\u033b\7\u0081\2\2\u033b\u033c\5X-\2\u033c\u0340"+ - "\7\u0082\2\2\u033d\u033f\5\u0144\u00a3\2\u033e\u033d\3\2\2\2\u033f\u0342"+ - "\3\2\2\2\u0340\u033e\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0344\3\2\2\2\u0342"+ - "\u0340\3\2\2\2\u0343\u0345\5\u0146\u00a4\2\u0344\u0343\3\2\2\2\u0344\u0345"+ - "\3\2\2\2\u0345\u034e\3\2\2\2\u0346\u0348\5\u0144\u00a3\2\u0347\u0346\3"+ - "\2\2\2\u0348\u0349\3\2\2\2\u0349\u0347\3\2\2\2\u0349\u034a\3\2\2\2\u034a"+ - "\u034b\3\2\2\2\u034b\u034c\5\u0146\u00a4\2\u034c\u034e\3\2\2\2\u034d\u0338"+ - "\3\2\2\2\u034d\u0339\3\2\2\2\u034d\u033a\3\2\2\2\u034d\u0347\3\2\2\2\u034e"+ - "\u0354\3\2\2\2\u034f\u0354\5h\65\2\u0350\u0351\5\u0144\u00a3\2\u0351\u0352"+ - "\5\u0146\u00a4\2\u0352\u0354\3\2\2\2\u0353\u0337\3\2\2\2\u0353\u034f\3"+ - "\2\2\2\u0353\u0350\3\2\2\2\u0354\u0397\3\2\2\2\u0355\u0356\7\u0083\2\2"+ - "\u0356\u0359\5\34\17\2\u0357\u0358\7\u0086\2\2\u0358\u035a\5\34\17\2\u0359"+ - "\u0357\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u0359\3\2\2\2\u035b\u035c\3\2"+ - "\2\2\u035c\u035d\3\2\2\2\u035d\u035e\7\u0084\2\2\u035e\u0397\3\2\2\2\u035f"+ - "\u0360\7d\2\2\u0360\u0364\7\u0083\2\2\u0361\u0365\5n8\2\u0362\u0365\5"+ - "\6\4\2\u0363\u0365\7n\2\2\u0364\u0361\3\2\2\2\u0364\u0362\3\2\2\2\u0364"+ - "\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366\u0397\7\u0084\2\2\u0367\u0368"+ - "\7\33\2\2\u0368\u0369\7\u0083\2\2\u0369\u036a\5\36\20\2\u036a\u036b\7"+ - "\u0084\2\2\u036b\u0397\3\2\2\2\u036c\u036d\7g\2\2\u036d\u036e\7\u0083"+ - "\2\2\u036e\u036f\5\36\20\2\u036f\u0370\7\u0084\2\2\u0370\u0397\3\2\2\2"+ - "\u0371\u0376\7 \2\2\u0372\u0373\7\u0083\2\2\u0373\u0374\5\6\4\2\u0374"+ - "\u0375\7\u0084\2\2\u0375\u0377\3\2\2\2\u0376\u0372\3\2\2\2\u0376\u0377"+ - "\3\2\2\2\u0377\u0397\3\2\2\2\u0378\u037a\7\21\2\2\u0379\u0378\3\2\2\2"+ - "\u0379\u037a\3\2\2\2\u037a\u037b\3\2\2\2\u037b\u0381\7!\2\2\u037c\u037e"+ - "\7\u0083\2\2\u037d\u037f\5|?\2\u037e\u037d\3\2\2\2\u037e\u037f\3\2\2\2"+ - "\u037f\u0380\3\2\2\2\u0380\u0382\7\u0084\2\2\u0381\u037c\3\2\2\2\u0381"+ - "\u0382\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0397\5\u00acW\2\u0384\u0385"+ - "\7Z\2\2\u0385\u0386\7\u0083\2\2\u0386\u0387\5\6\4\2\u0387\u0388\7\u0084"+ - "\2\2\u0388\u0397\3\2\2\2\u0389\u038a\7B\2\2\u038a\u0390\7\u0083\2\2\u038b"+ - "\u038c\5\u01b4\u00db\2\u038c\u038d\7\u0085\2\2\u038d\u038f\3\2\2\2\u038e"+ - "\u038b\3\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2"+ - "\2\2\u0391\u0393\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0394\5\u01b4\u00db"+ - "\2\u0394\u0395\7\u0084\2\2\u0395\u0397\3\2\2\2\u0396\u031d\3\2\2\2\u0396"+ - "\u031e\3\2\2\2\u0396\u0322\3\2\2\2\u0396\u0326\3\2\2\2\u0396\u0327\3\2"+ - "\2\2\u0396\u0328\3\2\2\2\u0396\u0329\3\2\2\2\u0396\u032a\3\2\2\2\u0396"+ - "\u0336\3\2\2\2\u0396\u0355\3\2\2\2\u0396\u035f\3\2\2\2\u0396\u0367\3\2"+ - "\2\2\u0396\u036c\3\2\2\2\u0396\u0371\3\2\2\2\u0396\u0379\3\2\2\2\u0396"+ - "\u0384\3\2\2\2\u0396\u0389\3\2\2\2\u0397K\3\2\2\2\u0398\u039b\5\36\20"+ - "\2\u0399\u039b\5N(\2\u039a\u0398\3\2\2\2\u039a\u0399\3\2\2\2\u039bM\3"+ - "\2\2\2\u039c\u039d\7a\2\2\u039d\u039e\5\36\20\2\u039eO\3\2\2\2\u039f\u03a1"+ - "\7\u0096\2\2\u03a0\u039f\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03a2\3\2\2"+ - "\2\u03a2\u03a3\7\u0085\2\2\u03a3\u03a5\5\u01b4\u00db\2\u03a4\u03a6\5\30"+ - "\r\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6Q\3\2\2\2\u03a7\u03a9"+ - "\7\u0096\2\2\u03a8\u03a7\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03aa\3\2\2"+ - "\2\u03aa\u03ab\7\u0081\2\2\u03ab\u03b0\5T+\2\u03ac\u03ad\7\u0086\2\2\u03ad"+ - "\u03af\5T+\2\u03ae\u03ac\3\2\2\2\u03af\u03b2\3\2\2\2\u03b0\u03ae\3\2\2"+ - "\2\u03b0\u03b1\3\2\2\2\u03b1\u03b3\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b3\u03b4"+ - "\7\u0082\2\2\u03b4S\3\2\2\2\u03b5\u03b6\5\u01b4\u00db\2\u03b6\u03b7\7"+ - "\u0087\2\2\u03b7\u03b9\3\2\2\2\u03b8\u03b5\3\2\2\2\u03b8\u03b9\3\2\2\2"+ - "\u03b9\u03ba\3\2\2\2\u03ba\u03bb\5\36\20\2\u03bbU\3\2\2\2\u03bc\u03bd"+ - "\t\t\2\2\u03bdW\3\2\2\2\u03be\u03c3\5\36\20\2\u03bf\u03c0\7\u0086\2\2"+ - "\u03c0\u03c2\5\36\20\2\u03c1\u03bf\3\2\2\2\u03c2\u03c5\3\2\2\2\u03c3\u03c1"+ - "\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4Y\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c6"+ - "\u03c9\5\\/\2\u03c7\u03c9\5d\63\2\u03c8\u03c6\3\2\2\2\u03c8\u03c7\3\2"+ - "\2\2\u03c9[\3\2\2\2\u03ca\u03cf\7\177\2\2\u03cb\u03cd\5^\60\2\u03cc\u03ce"+ - "\7\u0086\2\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2"+ - "\2\u03cf\u03cb\3\2\2\2\u03cf\u03d0\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03d2"+ - "\7\u0080\2\2\u03d2]\3\2\2\2\u03d3\u03d8\5`\61\2\u03d4\u03d5\7\u0086\2"+ - "\2\u03d5\u03d7\5`\61\2\u03d6\u03d4\3\2\2\2\u03d7\u03da\3\2\2\2\u03d8\u03d6"+ - "\3\2\2\2\u03d8\u03d9\3\2\2\2\u03d9_\3\2\2\2\u03da\u03d8\3\2\2\2\u03db"+ - "\u03e1\5\u01b4\u00db\2\u03dc\u03dd\7\u0081\2\2\u03dd\u03de\5\36\20\2\u03de"+ - "\u03df\7\u0082\2\2\u03df\u03e1\3\2\2\2\u03e0\u03db\3\2\2\2\u03e0\u03dc"+ - "\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e3\7\u0093\2\2\u03e3\u03e4\5b\62"+ - "\2\u03e4a\3\2\2\2\u03e5\u03e8\5\36\20\2\u03e6\u03e8\5Z.\2\u03e7\u03e5"+ - "\3\2\2\2\u03e7\u03e6\3\2\2\2\u03e8c\3\2\2\2\u03e9\u03ea\7\177\2\2\u03ea"+ - "\u03ef\5f\64\2\u03eb\u03ec\7\u0086\2\2\u03ec\u03ee\5f\64\2\u03ed\u03eb"+ - "\3\2\2\2\u03ee\u03f1\3\2\2\2\u03ef\u03ed\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0"+ - "\u03f3\3\2\2\2\u03f1\u03ef\3\2\2\2\u03f2\u03f4\7\u0086\2\2\u03f3\u03f2"+ - "\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\7\u0080\2"+ - "\2\u03f6e\3\2\2\2\u03f7\u03fd\5 \21\2\u03f8\u03f9\7\177\2\2\u03f9\u03fa"+ - "\5X-\2\u03fa\u03fb\7\u0080\2\2\u03fb\u03fd\3\2\2\2\u03fc\u03f7\3\2\2\2"+ - "\u03fc\u03f8\3\2\2\2\u03fdg\3\2\2\2\u03fe\u0403\7\177\2\2\u03ff\u0401"+ - "\5j\66\2\u0400\u0402\7\u0086\2\2\u0401\u0400\3\2\2\2\u0401\u0402\3\2\2"+ - "\2\u0402\u0404\3\2\2\2\u0403\u03ff\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u0405"+ - "\3\2\2\2\u0405\u0406\7\u0080\2\2\u0406i\3\2\2\2\u0407\u040c\5l\67\2\u0408"+ - "\u0409\7\u0086\2\2\u0409\u040b\5l\67\2\u040a\u0408\3\2\2\2\u040b\u040e"+ - "\3\2\2\2\u040c\u040a\3\2\2\2\u040c\u040d\3\2\2\2\u040dk\3\2\2\2\u040e"+ - "\u040c\3\2\2\2\u040f\u0415\5H%\2\u0410\u0411\5\u01b4\u00db\2\u0411\u0412"+ - "\7\u0093\2\2\u0412\u0413\5\36\20\2\u0413\u0415\3\2\2\2\u0414\u040f\3\2"+ - "\2\2\u0414\u0410\3\2\2\2\u0415m\3\2\2\2\u0416\u041f\5\u01b4\u00db\2\u0417"+ - "\u0419\5p9\2\u0418\u0417\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u0420\3\2\2"+ - "\2\u041a\u041b\7\u0097\2\2\u041b\u041d\5\u01b4\u00db\2\u041c\u041e\5p"+ - "9\2\u041d\u041c\3\2\2\2\u041d\u041e\3\2\2\2\u041e\u0420\3\2\2\2\u041f"+ - "\u0418\3\2\2\2\u041f\u041a\3\2\2\2\u0420\u0428\3\2\2\2\u0421\u0422\7\u0085"+ - "\2\2\u0422\u0424\5\u01b4\u00db\2\u0423\u0425\5p9\2\u0424\u0423\3\2\2\2"+ - "\u0424\u0425\3\2\2\2\u0425\u0427\3\2\2\2\u0426\u0421\3\2\2\2\u0427\u042a"+ - "\3\2\2\2\u0428\u0426\3\2\2\2\u0428\u0429\3\2\2\2\u0429o\3\2\2\2\u042a"+ - "\u0428\3\2\2\2\u042b\u042f\7\u0094\2\2\u042c\u042e\7\u0086\2\2\u042d\u042c"+ - "\3\2\2\2\u042e\u0431\3\2\2\2\u042f\u042d\3\2\2\2\u042f\u0430\3\2\2\2\u0430"+ - "\u0432\3\2\2\2\u0431\u042f\3\2\2\2\u0432\u0433\7\u0095\2\2\u0433q\3\2"+ - "\2\2\u0434\u0439\5\b\5\2\u0435\u0438\5\u0144\u00a3\2\u0436\u0438\7\u008b"+ - "\2\2\u0437\u0435\3\2\2\2\u0437\u0436\3\2\2\2\u0438\u043b\3\2\2\2\u0439"+ - "\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043d\3\2\2\2\u043b\u0439\3\2"+ - "\2\2\u043c\u043e\7\u0096\2\2\u043d\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e"+ - "\u0440\3\2\2\2\u043f\u0441\5t;\2\u0440\u043f\3\2\2\2\u0440\u0441\3\2\2"+ - "\2\u0441\u0443\3\2\2\2\u0442\u0444\5\u01b4\u00db\2\u0443\u0442\3\2\2\2"+ - "\u0443\u0444\3\2\2\2\u0444s\3\2\2\2\u0445\u0446\7\177\2\2\u0446\u044b"+ - "\5v<\2\u0447\u0448\7\u0086\2\2\u0448\u044a\5v<\2\u0449\u0447\3\2\2\2\u044a"+ - "\u044d\3\2\2\2\u044b\u0449\3\2\2\2\u044b\u044c\3\2\2\2\u044c\u044e\3\2"+ - "\2\2\u044d\u044b\3\2\2\2\u044e\u044f\7\u0080\2\2\u044fu\3\2\2\2\u0450"+ - "\u0451\5\u01b4\u00db\2\u0451\u0452\7\u0087\2\2\u0452\u0453\5\36\20\2\u0453"+ - "w\3\2\2\2\u0454\u0456\7\21\2\2\u0455\u0454\3\2\2\2\u0455\u0456\3\2\2\2"+ - "\u0456\u0457\3\2\2\2\u0457\u0458\5z>\2\u0458\u0459\5\u0178\u00bd\2\u0459"+ - "\u045a\5\u0082B\2\u045ay\3\2\2\2\u045b\u045c\7\u0083\2\2\u045c\u0467\7"+ - "\u0084\2\2\u045d\u045e\7\u0083\2\2\u045e\u045f\5|?\2\u045f\u0460\7\u0084"+ - "\2\2\u0460\u0467\3\2\2\2\u0461\u0462\7\u0083\2\2\u0462\u0463\5\u0080A"+ - "\2\u0463\u0464\7\u0084\2\2\u0464\u0467\3\2\2\2\u0465\u0467\5\u01b4\u00db"+ - "\2\u0466\u045b\3\2\2\2\u0466\u045d\3\2\2\2\u0466\u0461\3\2\2\2\u0466\u0465"+ - "\3\2\2\2\u0467{\3\2\2\2\u0468\u046d\5~@\2\u0469\u046a\7\u0086\2\2\u046a"+ - "\u046c\5~@\2\u046b\u0469\3\2\2\2\u046c\u046f\3\2\2\2\u046d\u046b\3\2\2"+ - "\2\u046d\u046e\3\2\2\2\u046e}\3\2\2\2\u046f\u046d\3\2\2\2\u0470\u0472"+ - "\t\4\2\2\u0471\u0470\3\2\2\2\u0471\u0472\3\2\2\2\u0472\u0473\3\2\2\2\u0473"+ - "\u0474\5\6\4\2\u0474\u0475\5\u01b4\u00db\2\u0475\177\3\2\2\2\u0476\u047b"+ - "\5\u01b4\u00db\2\u0477\u0478\7\u0086\2\2\u0478\u047a\5\u01b4\u00db\2\u0479"+ - "\u0477\3\2\2\2\u047a\u047d\3\2\2\2\u047b\u0479\3\2\2\2\u047b\u047c\3\2"+ - "\2\2\u047c\u0081\3\2\2\2\u047d\u047b\3\2\2\2\u047e\u0481\5L\'\2\u047f"+ - "\u0481\5\u00acW\2\u0480\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481\u0083"+ - "\3\2\2\2\u0482\u0483\5\u0086D\2\u0483\u0484\5\u0088E\2\u0484\u0085\3\2"+ - "\2\2\u0485\u0487\7\62\2\2\u0486\u0488\5\6\4\2\u0487\u0486\3\2\2\2\u0487"+ - "\u0488\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048a\5\u01b4\u00db\2\u048a\u048b"+ - "\78\2\2\u048b\u048c\5\36\20\2\u048c\u0087\3\2\2\2\u048d\u048f\5\u008a"+ - "F\2\u048e\u048d\3\2\2\2\u048f\u0492\3\2\2\2\u0490\u048e\3\2\2\2\u0490"+ - "\u0491\3\2\2\2\u0491\u0493\3\2\2\2\u0492\u0490\3\2\2\2\u0493\u0495\5\u0096"+ - "L\2\u0494\u0496\5\u0098M\2\u0495\u0494\3\2\2\2\u0495\u0496\3\2\2\2\u0496"+ - "\u0089\3\2\2\2\u0497\u049d\5\u0086D\2\u0498\u049d\5\u008cG\2\u0499\u049d"+ - "\5\u008eH\2\u049a\u049d\5\u0090I\2\u049b\u049d\5\u0092J\2\u049c\u0497"+ - "\3\2\2\2\u049c\u0498\3\2\2\2\u049c\u0499\3\2\2\2\u049c\u049a\3\2\2\2\u049c"+ - "\u049b\3\2\2\2\u049d\u008b\3\2\2\2\u049e\u049f\7?\2\2\u049f\u04a0\5\u01b4"+ - "\u00db\2\u04a0\u04a1\7\u0093\2\2\u04a1\u04a2\5\36\20\2\u04a2\u008d\3\2"+ - "\2\2\u04a3\u04a4\7q\2\2\u04a4\u04a5\5\36\20\2\u04a5\u008f\3\2\2\2\u04a6"+ - "\u04a8\7>\2\2\u04a7\u04a9\5\6\4\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2"+ - "\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab\5\u01b4\u00db\2\u04ab\u04ac\78\2"+ - "\2\u04ac\u04ad\5\36\20\2\u04ad\u04ae\7G\2\2\u04ae\u04af\5\36\20\2\u04af"+ - "\u04b0\7(\2\2\u04b0\u04b3\5\36\20\2\u04b1\u04b2\7<\2\2\u04b2\u04b4\5\u01b4"+ - "\u00db\2\u04b3\u04b1\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u0091\3\2\2\2\u04b5"+ - "\u04b6\7I\2\2\u04b6\u04bb\5\u0094K\2\u04b7\u04b8\7\u0086\2\2\u04b8\u04ba"+ - "\5\u0094K\2\u04b9\u04b7\3\2\2\2\u04ba\u04bd\3\2\2\2\u04bb\u04b9\3\2\2"+ - "\2\u04bb\u04bc\3\2\2\2\u04bc\u0093\3\2\2\2\u04bd\u04bb\3\2\2\2\u04be\u04c0"+ - "\5\36\20\2\u04bf\u04c1\t\n\2\2\u04c0\u04bf\3\2\2\2\u04c0\u04c1\3\2\2\2"+ - "\u04c1\u0095\3\2\2\2\u04c2\u04c3\7W\2\2\u04c3\u04ca\5\36\20\2\u04c4\u04c5"+ - "\7\65\2\2\u04c5\u04c6\5\36\20\2\u04c6\u04c7\7\26\2\2\u04c7\u04c8\5\36"+ - "\20\2\u04c8\u04ca\3\2\2\2\u04c9\u04c2\3\2\2\2\u04c9\u04c4\3\2\2\2\u04ca"+ - "\u0097\3\2\2\2\u04cb\u04cc\7<\2\2\u04cc\u04cd\5\u01b4\u00db\2\u04cd\u04ce"+ - "\5\u0088E\2\u04ce\u0099\3\2\2\2\u04cf\u04d3\5\u00a6T\2\u04d0\u04d3\5\u009c"+ - "O\2\u04d1\u04d3\5\u00a8U\2\u04d2\u04cf\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2"+ - "\u04d1\3\2\2\2\u04d3\u009b\3\2\2\2\u04d4\u04d5\5\u00aeX\2\u04d5\u04d6"+ - "\7\u0088\2\2\u04d6\u04dc\3\2\2\2\u04d7\u04d8\5\u00b6\\\2\u04d8\u04d9\7"+ - "\u0088\2\2\u04d9\u04dc\3\2\2\2\u04da\u04dc\5\u009eP\2\u04db\u04d4\3\2"+ - "\2\2\u04db\u04d7\3\2\2\2\u04db\u04da\3\2\2\2\u04dc\u009d\3\2\2\2\u04dd"+ - "\u04de\5\u00a0Q\2\u04de\u04df\5\u00a4S\2\u04df\u009f\3\2\2\2\u04e0\u04e2"+ - "\5\u00a2R\2\u04e1\u04e0\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e3\3\2\2"+ - "\2\u04e3\u04e4\5\u0114\u008b\2\u04e4\u04e6\5\u01b4\u00db\2\u04e5\u04e7"+ - "\5\u00e8u\2\u04e6\u04e5\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7\u04e8\3\2\2"+ - "\2\u04e8\u04ea\7\u0083\2\2\u04e9\u04eb\5\u011a\u008e\2\u04ea\u04e9\3\2"+ - "\2\2\u04ea\u04eb\3\2\2\2\u04eb\u04ec\3\2\2\2\u04ec\u04ee\7\u0084\2\2\u04ed"+ - "\u04ef\5\u00f0y\2\u04ee\u04ed\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u00a1"+ - "\3\2\2\2\u04f0\u04f2\t\13\2\2\u04f1\u04f3\7\\\2\2\u04f2\u04f1\3\2\2\2"+ - "\u04f2\u04f3\3\2\2\2\u04f3\u04f7\3\2\2\2\u04f4\u04f5\7\\\2\2\u04f5\u04f7"+ - "\t\13\2\2\u04f6\u04f0\3\2\2\2\u04f6\u04f4\3\2\2\2\u04f7\u00a3\3\2\2\2"+ - "\u04f8\u04fe\5\u00acW\2\u04f9\u04fa\5\u0178\u00bd\2\u04fa\u04fb\5L\'\2"+ - "\u04fb\u04fc\7\u0088\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04f8\3\2\2\2\u04fd"+ - "\u04f9\3\2\2\2\u04fe\u00a5\3\2\2\2\u04ff\u0500\5\u01b4\u00db\2\u0500\u0501"+ - "\7\u0087\2\2\u0501\u0502\5\u009aN\2\u0502\u00a7\3\2\2\2\u0503\u0506\5"+ - "\u00acW\2\u0504\u0506\5\u00aaV\2\u0505\u0503\3\2\2\2\u0505\u0504\3\2\2"+ - "\2\u0506\u00a9\3\2\2\2\u0507\u058a\7\u0088\2\2\u0508\u0509\5\36\20\2\u0509"+ - "\u050a\7\u0088\2\2\u050a\u058a\3\2\2\2\u050b\u050c\7\66\2\2\u050c\u050d"+ - "\7\u0083\2\2\u050d\u050e\5\36\20\2\u050e\u050f\7\u0084\2\2\u050f\u0512"+ - "\5\u00b8]\2\u0510\u0511\7&\2\2\u0511\u0513\5\u00b8]\2\u0512\u0510\3\2"+ - "\2\2\u0512\u0513\3\2\2\2\u0513\u058a\3\2\2\2\u0514\u0515\7_\2\2\u0515"+ - "\u0516\7\u0083\2\2\u0516\u0517\5\36\20\2\u0517\u0518\7\u0084\2\2\u0518"+ - "\u051c\7\177\2\2\u0519\u051b\5\u00ba^\2\u051a\u0519\3\2\2\2\u051b\u051e"+ - "\3\2\2\2\u051c\u051a\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051f\3\2\2\2\u051e"+ - "\u051c\3\2\2\2\u051f\u0520\7\u0080\2\2\u0520\u058a\3\2\2\2\u0521\u0522"+ - "\7r\2\2\u0522\u0523\7\u0083\2\2\u0523\u0524\5\36\20\2\u0524\u0525\7\u0084"+ - "\2\2\u0525\u0526\5\u00a8U\2\u0526\u058a\3\2\2\2\u0527\u0528\7#\2\2\u0528"+ - "\u0529\5\u00a8U\2\u0529\u052a\7r\2\2\u052a\u052b\7\u0083\2\2\u052b\u052c"+ - "\5\36\20\2\u052c\u052d\7\u0084\2\2\u052d\u052e\7\u0088\2\2\u052e\u058a"+ - "\3\2\2\2\u052f\u0530\7\60\2\2\u0530\u0532\7\u0083\2\2\u0531\u0533\5\u00c2"+ - "b\2\u0532\u0531\3\2\2\2\u0532\u0533\3\2\2\2\u0533\u0534\3\2\2\2\u0534"+ - "\u0536\7\u0088\2\2\u0535\u0537\5\36\20\2\u0536\u0535\3\2\2\2\u0536\u0537"+ - "\3\2\2\2\u0537\u0538\3\2\2\2\u0538\u053a\7\u0088\2\2\u0539\u053b\5\u00c4"+ - "c\2\u053a\u0539\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2\2\2\u053c"+ - "\u053d\7\u0084\2\2\u053d\u058a\5\u00a8U\2\u053e\u0540\7\22\2\2\u053f\u053e"+ - "\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0541\3\2\2\2\u0541\u0542\7\61\2\2"+ - "\u0542\u0543\7\u0083\2\2\u0543\u0544\5\u00b0Y\2\u0544\u0545\5\u01b4\u00db"+ - "\2\u0545\u0546\78\2\2\u0546\u0547\5\36\20\2\u0547\u0548\7\u0084\2\2\u0548"+ - "\u0549\5\u00a8U\2\u0549\u058a\3\2\2\2\u054a\u054b\7\25\2\2\u054b\u058a"+ - "\7\u0088\2\2\u054c\u054d\7\36\2\2\u054d\u058a\7\u0088\2\2\u054e\u0553"+ - "\7\64\2\2\u054f\u0554\5\u01b4\u00db\2\u0550\u0551\7\30\2\2\u0551\u0554"+ - "\5\36\20\2\u0552\u0554\7 \2\2\u0553\u054f\3\2\2\2\u0553\u0550\3\2\2\2"+ - "\u0553\u0552\3\2\2\2\u0554\u0555\3\2\2\2\u0555\u058a\7\u0088\2\2\u0556"+ - "\u0558\7T\2\2\u0557\u0559\5\36\20\2\u0558\u0557\3\2\2\2\u0558\u0559\3"+ - "\2\2\2\u0559\u055a\3\2\2\2\u055a\u058a\7\u0088\2\2\u055b\u055d\7a\2\2"+ - "\u055c\u055e\5\36\20\2\u055d\u055c\3\2\2\2\u055d\u055e\3\2\2\2\u055e\u055f"+ - "\3\2\2\2\u055f\u058a\7\u0088\2\2\u0560\u0561\7c\2\2\u0561\u0567\5\u00ac"+ - "W\2\u0562\u0564\5\u00c6d\2\u0563\u0565\5\u00ceh\2\u0564\u0563\3\2\2\2"+ - "\u0564\u0565\3\2\2\2\u0565\u0568\3\2\2\2\u0566\u0568\5\u00ceh\2\u0567"+ - "\u0562\3\2\2\2\u0567\u0566\3\2\2\2\u0568\u058a\3\2\2\2\u0569\u056a\7\33"+ - "\2\2\u056a\u058a\5\u00acW\2\u056b\u056c\7g\2\2\u056c\u058a\5\u00acW\2"+ - "\u056d\u056e\7@\2\2\u056e\u056f\7\u0083\2\2\u056f\u0570\5\36\20\2\u0570"+ - "\u0571\7\u0084\2\2\u0571\u0572\5\u00a8U\2\u0572\u058a\3\2\2\2\u0573\u0574"+ - "\7k\2\2\u0574\u0575\7\u0083\2\2\u0575\u0576\5\u00d0i\2\u0576\u0577\7\u0084"+ - "\2\2\u0577\u0578\5\u00a8U\2\u0578\u058a\3\2\2\2\u0579\u057d\7s\2\2\u057a"+ - "\u057b\7T\2\2\u057b\u057e\5\36\20\2\u057c\u057e\7\25\2\2\u057d\u057a\3"+ - "\2\2\2\u057d\u057c\3\2\2\2\u057e\u057f\3\2\2\2\u057f\u058a\7\u0088\2\2"+ - "\u0580\u0581\7i\2\2\u0581\u058a\5\u00acW\2\u0582\u0583\7.\2\2\u0583\u0584"+ - "\7\u0083\2\2\u0584\u0585\5\u016c\u00b7\2\u0585\u0586\5\u016e\u00b8\2\u0586"+ - "\u0587\7\u0084\2\2\u0587\u0588\5\u00a8U\2\u0588\u058a\3\2\2\2\u0589\u0507"+ - "\3\2\2\2\u0589\u0508\3\2\2\2\u0589\u050b\3\2\2\2\u0589\u0514\3\2\2\2\u0589"+ - "\u0521\3\2\2\2\u0589\u0527\3\2\2\2\u0589\u052f\3\2\2\2\u0589\u053f\3\2"+ - "\2\2\u0589\u054a\3\2\2\2\u0589\u054c\3\2\2\2\u0589\u054e\3\2\2\2\u0589"+ - "\u0556\3\2\2\2\u0589\u055b\3\2\2\2\u0589\u0560\3\2\2\2\u0589\u0569\3\2"+ - "\2\2\u0589\u056b\3\2\2\2\u0589\u056d\3\2\2\2\u0589\u0573\3\2\2\2\u0589"+ - "\u0579\3\2\2\2\u0589\u0580\3\2\2\2\u0589\u0582\3\2\2\2\u058a\u00ab\3\2"+ - "\2\2\u058b\u058d\7\177\2\2\u058c\u058e\5\u00c0a\2\u058d\u058c\3\2\2\2"+ - "\u058d\u058e\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0590\7\u0080\2\2\u0590"+ - "\u00ad\3\2\2\2\u0591\u0596\7k\2\2\u0592\u0596\7R\2\2\u0593\u0594\7R\2"+ - "\2\u0594\u0596\7Q\2\2\u0595\u0591\3\2\2\2\u0595\u0592\3\2\2\2\u0595\u0593"+ - "\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0597\3\2\2\2\u0597\u0598\5\u00b0Y"+ - "\2\u0598\u059d\5\u00b2Z\2\u0599\u059a\7\u0086\2\2\u059a\u059c\5\u00b2"+ - "Z\2\u059b\u0599\3\2\2\2\u059c\u059f\3\2\2\2\u059d\u059b\3\2\2\2\u059d"+ - "\u059e\3\2\2\2\u059e\u05a5\3\2\2\2\u059f\u059d\3\2\2\2\u05a0\u05a1\7."+ - "\2\2\u05a1\u05a2\5\u016c\u00b7\2\u05a2\u05a3\5\u016e\u00b8\2\u05a3\u05a5"+ - "\3\2\2\2\u05a4\u0595\3\2\2\2\u05a4\u05a0\3\2\2\2\u05a5\u00af\3\2\2\2\u05a6"+ - "\u05a9\7l\2\2\u05a7\u05a9\5\6\4\2\u05a8\u05a6\3\2\2\2\u05a8\u05a7\3\2"+ - "\2\2\u05a9\u00b1\3\2\2\2\u05aa\u05b0\5\u01b4\u00db\2\u05ab\u05ad\7\u0093"+ - "\2\2\u05ac\u05ae\7R\2\2\u05ad\u05ac\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae"+ - "\u05af\3\2\2\2\u05af\u05b1\5\u00b4[\2\u05b0\u05ab\3\2\2\2\u05b0\u05b1"+ - "\3\2\2\2\u05b1\u00b3\3\2\2\2\u05b2\u05b6\5\36\20\2\u05b3\u05b6\5\u0146"+ - "\u00a4\2\u05b4\u05b6\5\u0176\u00bc\2\u05b5\u05b2\3\2\2\2\u05b5\u05b3\3"+ - "\2\2\2\u05b5\u05b4\3\2\2\2\u05b6\u00b5\3\2\2\2\u05b7\u05b8\7\35\2\2\u05b8"+ - "\u05b9\5\6\4\2\u05b9\u05ba\5\u010a\u0086\2\u05ba\u00b7\3\2\2\2\u05bb\u05be"+ - "\5\u00acW\2\u05bc\u05be\5\u00aaV\2\u05bd\u05bb\3\2\2\2\u05bd\u05bc\3\2"+ - "\2\2\u05be\u00b9\3\2\2\2\u05bf\u05c1\5\u00bc_\2\u05c0\u05bf\3\2\2\2\u05c1"+ - "\u05c2\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c4\3\2"+ - "\2\2\u05c4\u05c5\5\u00c0a\2\u05c5\u00bb\3\2\2\2\u05c6\u05c7\7\30\2\2\u05c7"+ - "\u05c9\5\36\20\2\u05c8\u05ca\5\u00be`\2\u05c9\u05c8\3\2\2\2\u05c9\u05ca"+ - "\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cc\7\u0087\2\2\u05cc\u05d0\3\2\2"+ - "\2\u05cd\u05ce\7 \2\2\u05ce\u05d0\7\u0087\2\2\u05cf\u05c6\3\2\2\2\u05cf"+ - "\u05cd\3\2\2\2\u05d0\u00bd\3\2\2\2\u05d1\u05d2\7p\2\2\u05d2\u05d3\5\36"+ - "\20\2\u05d3\u00bf\3\2\2\2\u05d4\u05d6\5\u009aN\2\u05d5\u05d4\3\2\2\2\u05d6"+ - "\u05d7\3\2\2\2\u05d7\u05d5\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u00c1\3\2"+ - "\2\2\u05d9\u05e3\5\u00aeX\2\u05da\u05df\5\36\20\2\u05db\u05dc\7\u0086"+ - "\2\2\u05dc\u05de\5\36\20\2\u05dd\u05db\3\2\2\2\u05de\u05e1\3\2\2\2\u05df"+ - "\u05dd\3\2\2\2\u05df\u05e0\3\2\2\2\u05e0\u05e3\3\2\2\2\u05e1\u05df\3\2"+ - "\2\2\u05e2\u05d9\3\2\2\2\u05e2\u05da\3\2\2\2\u05e3\u00c3\3\2\2\2\u05e4"+ - "\u05e9\5\36\20\2\u05e5\u05e6\7\u0086\2\2\u05e6\u05e8\5\36\20\2\u05e7\u05e5"+ - "\3\2\2\2\u05e8\u05eb\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05ea\3\2\2\2\u05ea"+ - "\u00c5\3\2\2\2\u05eb\u05e9\3\2\2\2\u05ec\u05f0\5\u00c8e\2\u05ed\u05ef"+ - "\5\u00c8e\2\u05ee\u05ed\3\2\2\2\u05ef\u05f2\3\2\2\2\u05f0\u05ee\3\2\2"+ - "\2\u05f0\u05f1\3\2\2\2\u05f1\u05f4\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f3\u05f5"+ - "\5\u00caf\2\u05f4\u05f3\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5\u05f8\3\2\2"+ - "\2\u05f6\u05f8\5\u00caf\2\u05f7\u05ec\3\2\2\2\u05f7\u05f6\3\2\2\2\u05f8"+ - "\u00c7\3\2\2\2\u05f9\u05fa\7\31\2\2\u05fa\u05fb\7\u0083\2\2\u05fb\u05fd"+ - "\5\26\f\2\u05fc\u05fe\5\u01b4\u00db\2\u05fd\u05fc\3\2\2\2\u05fd\u05fe"+ - "\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0601\7\u0084\2\2\u0600\u0602\5\u00cc"+ - "g\2\u0601\u0600\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0603\3\2\2\2\u0603"+ - "\u0604\5\u00acW\2\u0604\u00c9\3\2\2\2\u0605\u0607\7\31\2\2\u0606\u0608"+ - "\5\u00ccg\2\u0607\u0606\3\2\2\2\u0607\u0608\3\2\2\2\u0608\u0609\3\2\2"+ - "\2\u0609\u060a\5\u00acW\2\u060a\u00cb\3\2\2\2\u060b\u060c\7p\2\2\u060c"+ - "\u060d\7\u0083\2\2\u060d\u060e\5\36\20\2\u060e\u060f\7\u0084\2\2\u060f"+ - "\u00cd\3\2\2\2\u0610\u0611\7-\2\2\u0611\u0612\5\u00acW\2\u0612\u00cf\3"+ - "\2\2\2\u0613\u0616\5\u00aeX\2\u0614\u0616\5\36\20\2\u0615\u0613\3\2\2"+ - "\2\u0615\u0614\3\2\2\2\u0616\u00d1\3\2\2\2\u0617\u0618\7C\2\2\u0618\u0619"+ - "\5\u00d4k\2\u0619\u061b\5\u00d6l\2\u061a\u061c\7\u0088\2\2\u061b\u061a"+ - "\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u00d3\3\2\2\2\u061d\u0622\5\u01b4\u00db"+ - "\2\u061e\u061f\7\u0085\2\2\u061f\u0621\5\u01b4\u00db\2\u0620\u061e\3\2"+ - "\2\2\u0621\u0624\3\2\2\2\u0622\u0620\3\2\2\2\u0622\u0623\3\2\2\2\u0623"+ - "\u00d5\3\2\2\2\u0624\u0622\3\2\2\2\u0625\u0627\7\177\2\2\u0626\u0628\5"+ - "\u00d8m\2\u0627\u0626\3\2\2\2\u0627\u0628\3\2\2\2\u0628\u062a\3\2\2\2"+ - "\u0629\u062b\5\u00dco\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b"+ - "\u062d\3\2\2\2\u062c\u062e\5\u00e0q\2\u062d\u062c\3\2\2\2\u062d\u062e"+ - "\3\2\2\2\u062e\u062f\3\2\2\2\u062f\u0630\7\u0080\2\2\u0630\u00d7\3\2\2"+ - "\2\u0631\u0633\5\u00dan\2\u0632\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634"+ - "\u0632\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u00d9\3\2\2\2\u0636\u0637\7+"+ - "\2\2\u0637\u0638\7\r\2\2\u0638\u0639\5\u01b4\u00db\2\u0639\u063a\7\u0088"+ - "\2\2\u063a\u00db\3\2\2\2\u063b\u063d\5\u00dep\2\u063c\u063b\3\2\2\2\u063d"+ - "\u063e\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u00dd\3\2"+ - "\2\2\u0640\u0641\7k\2\2\u0641\u0642\5\u01b4\u00db\2\u0642\u0643\7\u0093"+ - "\2\2\u0643\u0644\5\4\3\2\u0644\u0645\7\u0088\2\2\u0645\u0650\3\2\2\2\u0646"+ - "\u0647\7k\2\2\u0647\u0648\5\4\3\2\u0648\u0649\7\u0088\2\2\u0649\u0650"+ - "\3\2\2\2\u064a\u064b\7k\2\2\u064b\u064c\7\\\2\2\u064c\u064d\5\4\3\2\u064d"+ - "\u064e\7\u0088\2\2\u064e\u0650\3\2\2\2\u064f\u0640\3\2\2\2\u064f\u0646"+ - "\3\2\2\2\u064f\u064a\3\2\2\2\u0650\u00df\3\2\2\2\u0651\u0653\5\u00e2r"+ - "\2\u0652\u0651\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0652\3\2\2\2\u0654\u0655"+ - "\3\2\2\2\u0655\u00e1\3\2\2\2\u0656\u0659\5\u00d2j\2\u0657\u0659\5\u00e4"+ - "s\2\u0658\u0656\3\2\2\2\u0658\u0657\3\2\2\2\u0659\u00e3\3\2\2\2\u065a"+ - "\u065c\5\u0160\u00b1\2\u065b\u065a\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e"+ - "\3\2\2\2\u065d\u065f\5\u0102\u0082\2\u065e\u065d\3\2\2\2\u065e\u065f\3"+ - "\2\2\2\u065f\u0665\3\2\2\2\u0660\u0666\5\u0190\u00c9\2\u0661\u0666\5\u0192"+ - "\u00ca\2\u0662\u0666\5\u0194\u00cb\2\u0663\u0666\5\u0196\u00cc\2\u0664"+ - "\u0666\5\u0198\u00cd\2\u0665\u0660\3\2\2\2\u0665\u0661\3\2\2\2\u0665\u0662"+ - "\3\2\2\2\u0665\u0663\3\2\2\2\u0665\u0664\3\2\2\2\u0666\u00e5\3\2\2\2\u0667"+ - "\u0668\5\u01b4\u00db\2\u0668\u0669\7\u0097\2\2\u0669\u066b\5\u01b4\u00db"+ - "\2\u066a\u066c\5\30\r\2\u066b\u066a\3\2\2\2\u066b\u066c\3\2\2\2\u066c"+ - "\u00e7\3\2\2\2\u066d\u066e\7\u0094\2\2\u066e\u0673\5\u00eav\2\u066f\u0670"+ - "\7\u0086\2\2\u0670\u0672\5\u00eav\2\u0671\u066f\3\2\2\2\u0672\u0675\3"+ - "\2\2\2\u0673\u0671\3\2\2\2\u0673\u0674\3\2\2\2\u0674\u0676\3\2\2\2\u0675"+ - "\u0673\3\2\2\2\u0676\u0677\7\u0095\2\2\u0677\u00e9\3\2\2\2\u0678\u067a"+ - "\5\u0160\u00b1\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067b\3"+ - "\2\2\2\u067b\u067c\5\u01b4\u00db\2\u067c\u00eb\3\2\2\2\u067d\u067e\7\u0087"+ - "\2\2\u067e\u0683\5\26\f\2\u067f\u0680\7\u0086\2\2\u0680\u0682\5\4\3\2"+ - "\u0681\u067f\3\2\2\2\u0682\u0685\3\2\2\2\u0683\u0681\3\2\2\2\u0683\u0684"+ - "\3\2\2\2\u0684\u00ed\3\2\2\2\u0685\u0683\3\2\2\2\u0686\u068b\5\4\3\2\u0687"+ - "\u0688\7\u0086\2\2\u0688\u068a\5\4\3\2\u0689\u0687\3\2\2\2\u068a\u068d"+ - "\3\2\2\2\u068b\u0689\3\2\2\2\u068b\u068c\3\2\2\2\u068c\u00ef\3\2\2\2\u068d"+ - "\u068b\3\2\2\2\u068e\u0690\5\u00f2z\2\u068f\u068e\3\2\2\2\u0690\u0691"+ - "\3\2\2\2\u0691\u068f\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u00f1\3\2\2\2\u0693"+ - "\u0694\7q\2\2\u0694\u0695\5\u01b4\u00db\2\u0695\u0696\7\u0087\2\2\u0696"+ - "\u0697\5\u00f4{\2\u0697\u00f3\3\2\2\2\u0698\u06a3\5\u00fa~\2\u0699\u069c"+ - "\5\u00f6|\2\u069a\u069b\7\u0086\2\2\u069b\u069d\5\u00f8}\2\u069c\u069a"+ - "\3\2\2\2\u069c\u069d\3\2\2\2\u069d\u06a0\3\2\2\2\u069e\u069f\7\u0086\2"+ - "\2\u069f\u06a1\5\u00fa~\2\u06a0\u069e\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1"+ - "\u06a3\3\2\2\2\u06a2\u0698\3\2\2\2\u06a2\u0699\3\2\2\2\u06a3\u00f5\3\2"+ - "\2\2\u06a4\u06ac\5\26\f\2\u06a5\u06a7\7\34\2\2\u06a6\u06a8\7\u0096\2\2"+ - "\u06a7\u06a6\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u06ac\3\2\2\2\u06a9\u06ac"+ - "\7^\2\2\u06aa\u06ac\7h\2\2\u06ab\u06a4\3\2\2\2\u06ab\u06a5\3\2\2\2\u06ab"+ - "\u06a9\3\2\2\2\u06ab\u06aa\3\2\2\2\u06ac\u00f7\3\2\2\2\u06ad\u06b2\5\4"+ - "\3\2\u06ae\u06af\7\u0086\2\2\u06af\u06b1\5\4\3\2\u06b0\u06ae\3\2\2\2\u06b1"+ - "\u06b4\3\2\2\2\u06b2\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u00f9\3\2"+ - "\2\2\u06b4\u06b2\3\2\2\2\u06b5\u06b6\7D\2\2\u06b6\u06b7\7\u0083\2\2\u06b7"+ - "\u06b8\7\u0084\2\2\u06b8\u00fb\3\2\2\2\u06b9\u06bb\7\177\2\2\u06ba\u06bc"+ - "\5\u00fe\u0080\2\u06bb\u06ba\3\2\2\2\u06bb\u06bc\3\2\2\2\u06bc\u06bd\3"+ - "\2\2\2\u06bd\u06be\7\u0080\2\2\u06be\u00fd\3\2\2\2\u06bf\u06c1\5\u0100"+ - "\u0081\2\u06c0\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c0\3\2\2\2\u06c2"+ - "\u06c3\3\2\2\2\u06c3\u00ff\3\2\2\2\u06c4\u06c6\5\u0160\u00b1\2\u06c5\u06c4"+ - "\3\2\2\2\u06c5\u06c6\3\2\2\2\u06c6\u06c8\3\2\2\2\u06c7\u06c9\5\u0102\u0082"+ - "\2\u06c8\u06c7\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06cc\3\2\2\2\u06ca\u06cd"+ - "\5\u0106\u0084\2\u06cb\u06cd\5\u01a4\u00d3\2\u06cc\u06ca\3\2\2\2\u06cc"+ - "\u06cb\3\2\2\2\u06cd\u0101\3\2\2\2\u06ce\u06d0\5\u0104\u0083\2\u06cf\u06ce"+ - "\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06cf\3\2\2\2\u06d1\u06d2\3\2\2\2\u06d2"+ - "\u0103\3\2\2\2\u06d3\u06d4\t\f\2\2\u06d4\u0105\3\2\2\2\u06d5\u06e9\5\u01a0"+ - "\u00d1\2\u06d6\u06e9\5\u0108\u0085\2\u06d7\u06e9\5\u019a\u00ce\2\u06d8"+ - "\u06de\5\u0136\u009c\2\u06d9\u06df\5\u013a\u009e\2\u06da\u06db\5\u0178"+ - "\u00bd\2\u06db\u06dc\5L\'\2\u06dc\u06dd\7\u0088\2\2\u06dd\u06df\3\2\2"+ - "\2\u06de\u06d9\3\2\2\2\u06de\u06da\3\2\2\2\u06df\u06e9\3\2\2\2\u06e0\u06e9"+ - "\5\u01a6\u00d4\2\u06e1\u06e2\7n\2\2\u06e2\u06e9\5\u01a8\u00d5\2\u06e3"+ - "\u06e9\5\u0190\u00c9\2\u06e4\u06e9\5\u0192\u00ca\2\u06e5\u06e9\5\u0194"+ - "\u00cb\2\u06e6\u06e9\5\u0196\u00cc\2\u06e7\u06e9\5\u0198\u00cd\2\u06e8"+ - "\u06d5\3\2\2\2\u06e8\u06d6\3\2\2\2\u06e8\u06d7\3\2\2\2\u06e8\u06d8\3\2"+ - "\2\2\u06e8\u06e0\3\2\2\2\u06e8\u06e1\3\2\2\2\u06e8\u06e3\3\2\2\2\u06e8"+ - "\u06e4\3\2\2\2\u06e8\u06e5\3\2\2\2\u06e8\u06e6\3\2\2\2\u06e8\u06e7\3\2"+ - "\2\2\u06e9\u0107\3\2\2\2\u06ea\u06f0\7R\2\2\u06eb\u06ec\7Q\2\2\u06ec\u06f0"+ - "\7R\2\2\u06ed\u06ee\7R\2\2\u06ee\u06f0\7Q\2\2\u06ef\u06ea\3\2\2\2\u06ef"+ - "\u06eb\3\2\2\2\u06ef\u06ed\3\2\2\2\u06ef\u06f0\3\2\2\2\u06f0\u06f1\3\2"+ - "\2\2\u06f1\u06fb\5\6\4\2\u06f2\u06f3\5\4\3\2\u06f3\u06f4\7\u0085\2\2\u06f4"+ - "\u06f5\5\u01a2\u00d2\2\u06f5\u06fc\3\2\2\2\u06f6\u06fc\5\u01a8\u00d5\2"+ - "\u06f7\u06fc\5\u019e\u00d0\2\u06f8\u06fc\5\u01a2\u00d2\2\u06f9\u06fc\5"+ - "\u01ac\u00d7\2\u06fa\u06fc\5\u019c\u00cf\2\u06fb\u06f2\3\2\2\2\u06fb\u06f6"+ - "\3\2\2\2\u06fb\u06f7\3\2\2\2\u06fb\u06f8\3\2\2\2\u06fb\u06f9\3\2\2\2\u06fb"+ - "\u06fa\3\2\2\2\u06fc\u0109\3\2\2\2\u06fd\u0702\5\u010c\u0087\2\u06fe\u06ff"+ - "\7\u0086\2\2\u06ff\u0701\5\u010c\u0087\2\u0700\u06fe\3\2\2\2\u0701\u0704"+ - "\3\2\2\2\u0702\u0700\3\2\2\2\u0702\u0703\3\2\2\2\u0703\u010b\3\2\2\2\u0704"+ - "\u0702\3\2\2\2\u0705\u0706\5\u01b4\u00db\2\u0706\u0707\7\u0093\2\2\u0707"+ - "\u0708\5\36\20\2\u0708\u010d\3\2\2\2\u0709\u070e\5\u0110\u0089\2\u070a"+ - "\u070b\7\u0086\2\2\u070b\u070d\5\u0110\u0089\2\u070c\u070a\3\2\2\2\u070d"+ - "\u0710\3\2\2\2\u070e\u070c\3\2\2\2\u070e\u070f\3\2\2\2\u070f\u010f\3\2"+ - "\2\2\u0710\u070e\3\2\2\2\u0711\u0714\5\u01b4\u00db\2\u0712\u0713\7\u0093"+ - "\2\2\u0713\u0715\5\u0112\u008a\2\u0714\u0712\3\2\2\2\u0714\u0715\3\2\2"+ - "\2\u0715\u0111\3\2\2\2\u0716\u0719\5\36\20\2\u0717\u0719\5\u0146\u00a4"+ - "\2\u0718\u0716\3\2\2\2\u0718\u0717\3\2\2\2\u0719\u0113\3\2\2\2\u071a\u071d"+ - "\5\6\4\2\u071b\u071d\7n\2\2\u071c\u071a\3\2\2\2\u071c\u071b\3\2\2\2\u071d"+ - "\u0115\3\2\2\2\u071e\u071f\5\4\3\2\u071f\u0117\3\2\2\2\u0720\u0723\5\u00ac"+ - "W\2\u0721\u0723\7\u0088\2\2\u0722\u0720\3\2\2\2\u0722\u0721\3\2\2\2\u0723"+ - "\u0119\3\2\2\2\u0724\u072b\5\u0122\u0092\2\u0725\u0728\5\u011c\u008f\2"+ - "\u0726\u0727\7\u0086\2\2\u0727\u0729\5\u0122\u0092\2\u0728\u0726\3\2\2"+ - "\2\u0728\u0729\3\2\2\2\u0729\u072b\3\2\2\2\u072a\u0724\3\2\2\2\u072a\u0725"+ - "\3\2\2\2\u072b\u011b\3\2\2\2\u072c\u0731\5\u011e\u0090\2\u072d\u072e\7"+ - "\u0086\2\2\u072e\u0730\5\u011e\u0090\2\u072f\u072d\3\2\2\2\u0730\u0733"+ - "\3\2\2\2\u0731\u072f\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u011d\3\2\2\2\u0733"+ - "\u0731\3\2\2\2\u0734\u0736\5\u0160\u00b1\2\u0735\u0734\3\2\2\2\u0735\u0736"+ - "\3\2\2\2\u0736\u0738\3\2\2\2\u0737\u0739\5\u0120\u0091\2\u0738\u0737\3"+ - "\2\2\2\u0738\u0739\3\2\2\2\u0739\u073a\3\2\2\2\u073a\u073d\5\u01ae\u00d8"+ - "\2\u073b\u073d\7\16\2\2\u073c\u0735\3\2\2\2\u073c\u073b\3\2\2\2\u073d"+ - "\u011f\3\2\2\2\u073e\u0747\7R\2\2\u073f\u0747\7J\2\2\u0740\u0747\78\2"+ - "\2\u0741\u0742\7R\2\2\u0742\u0747\7`\2\2\u0743\u0744\78\2\2\u0744\u0747"+ - "\7`\2\2\u0745\u0747\7`\2\2\u0746\u073e\3\2\2\2\u0746\u073f\3\2\2\2\u0746"+ - "\u0740\3\2\2\2\u0746\u0741\3\2\2\2\u0746\u0743\3\2\2\2\u0746\u0745\3\2"+ - "\2\2\u0747\u0121\3\2\2\2\u0748\u074a\5\u0160\u00b1\2\u0749\u0748\3\2\2"+ - "\2\u0749\u074a\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u074c\7L\2\2\u074c\u074d"+ - "\5\u0142\u00a2\2\u074d\u074e\5\u01b4\u00db\2\u074e\u0123\3\2\2\2\u074f"+ - "\u0751\5\u0160\u00b1\2\u0750\u074f\3\2\2\2\u0750\u0751\3\2\2\2\u0751\u0753"+ - "\3\2\2\2\u0752\u0754\5\u012a\u0096\2\u0753\u0752\3\2\2\2\u0753\u0754\3"+ - "\2\2\2\u0754\u075f\3\2\2\2\u0755\u0756\7\63\2\2\u0756\u0758\5\u012c\u0097"+ - "\2\u0757\u0759\5\u0128\u0095\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2\2"+ - "\u0759\u0760\3\2\2\2\u075a\u075b\7X\2\2\u075b\u075d\5\u012c\u0097\2\u075c"+ - "\u075e\5\u0126\u0094\2\u075d\u075c\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u0760"+ - "\3\2\2\2\u075f\u0755\3\2\2\2\u075f\u075a\3\2\2\2\u0760\u0125\3\2\2\2\u0761"+ - "\u0763\5\u0160\u00b1\2\u0762\u0761\3\2\2\2\u0762\u0763\3\2\2\2\u0763\u0765"+ - "\3\2\2\2\u0764\u0766\5\u012a\u0096\2\u0765\u0764\3\2\2\2\u0765\u0766\3"+ - "\2\2\2\u0766\u0767\3\2\2\2\u0767\u0768\7\63\2\2\u0768\u0769\5\u012c\u0097"+ - "\2\u0769\u0127\3\2\2\2\u076a\u076c\5\u0160\u00b1\2\u076b\u076a\3\2\2\2"+ - "\u076b\u076c\3\2\2\2\u076c\u076e\3\2\2\2\u076d\u076f\5\u012a\u0096\2\u076e"+ - "\u076d\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0771\7X"+ - "\2\2\u0771\u0772\5\u012c\u0097\2\u0772\u0129\3\2\2\2\u0773\u077b\7O\2"+ - "\2\u0774\u077b\7;\2\2\u0775\u077b\7N\2\2\u0776\u0777\7O\2\2\u0777\u077b"+ - "\7;\2\2\u0778\u0779\7;\2\2\u0779\u077b\7O\2\2\u077a\u0773\3\2\2\2\u077a"+ - "\u0774\3\2\2\2\u077a\u0775\3\2\2\2\u077a\u0776\3\2\2\2\u077a\u0778\3\2"+ - "\2\2\u077b\u012b\3\2\2\2\u077c\u077f\5\u00acW\2\u077d\u077f\7\u0088\2"+ - "\2\u077e\u077c\3\2\2\2\u077e\u077d\3\2\2\2\u077f\u012d\3\2\2\2\u0780\u0782"+ - "\5\u0160\u00b1\2\u0781\u0780\3\2\2\2\u0781\u0782\3\2\2\2\u0782\u078b\3"+ - "\2\2\2\u0783\u0784\7\f\2\2\u0784\u0785\5\u00acW\2\u0785\u0786\5\u0132"+ - "\u009a\2\u0786\u078c\3\2\2\2\u0787\u0788\7S\2\2\u0788\u0789\5\u00acW\2"+ - "\u0789\u078a\5\u0130\u0099\2\u078a\u078c\3\2\2\2\u078b\u0783\3\2\2\2\u078b"+ - "\u0787\3\2\2\2\u078c\u012f\3\2\2\2\u078d\u078f\5\u0160\u00b1\2\u078e\u078d"+ - "\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u0790\3\2\2\2\u0790\u0791\7\f\2\2\u0791"+ - "\u0792\5\u00acW\2\u0792\u0131\3\2\2\2\u0793\u0795\5\u0160\u00b1\2\u0794"+ - "\u0793\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\3\2\2\2\u0796\u0797\7S"+ - "\2\2\u0797\u0798\5\u00acW\2\u0798\u0133\3\2\2\2\u0799\u07b0\7\u0089\2"+ - "\2\u079a\u07b0\7\u008a\2\2\u079b\u07b0\7\u0091\2\2\u079c\u07b0\7\u0092"+ - "\2\2\u079d\u07b0\7\u0099\2\2\u079e\u07b0\7\u009a\2\2\u079f\u07b0\7b\2"+ - "\2\u07a0\u07b0\7,\2\2\u07a1\u07b0\7\u008b\2\2\u07a2\u07b0\7\u008c\2\2"+ - "\u07a3\u07b0\7\u008d\2\2\u07a4\u07b0\7\u008e\2\2\u07a5\u07b0\7\u008f\2"+ - "\2\u07a6\u07b0\7\u0090\2\2\u07a7\u07b0\7\u00aa\2\2\u07a8\u07b0\5\u017a"+ - "\u00be\2\u07a9\u07b0\7\u009e\2\2\u07aa\u07b0\7\u009f\2\2\u07ab\u07b0\7"+ - "\u0095\2\2\u07ac\u07b0\7\u0094\2\2\u07ad\u07b0\7\u00a1\2\2\u07ae\u07b0"+ - "\7\u00a0\2\2\u07af\u0799\3\2\2\2\u07af\u079a\3\2\2\2\u07af\u079b\3\2\2"+ - "\2\u07af\u079c\3\2\2\2\u07af\u079d\3\2\2\2\u07af\u079e\3\2\2\2\u07af\u079f"+ - "\3\2\2\2\u07af\u07a0\3\2\2\2\u07af\u07a1\3\2\2\2\u07af\u07a2\3\2\2\2\u07af"+ - "\u07a3\3\2\2\2\u07af\u07a4\3\2\2\2\u07af\u07a5\3\2\2\2\u07af\u07a6\3\2"+ - "\2\2\u07af\u07a7\3\2\2\2\u07af\u07a8\3\2\2\2\u07af\u07a9\3\2\2\2\u07af"+ - "\u07aa\3\2\2\2\u07af\u07ab\3\2\2\2\u07af\u07ac\3\2\2\2\u07af\u07ad\3\2"+ - "\2\2\u07af\u07ae\3\2\2\2\u07b0\u0135\3\2\2\2\u07b1\u07b2\t\r\2\2\u07b2"+ - "\u07b3\7H\2\2\u07b3\u07b4\5\6\4\2\u07b4\u07b5\7\u0083\2\2\u07b5\u07b6"+ - "\5\u01ae\u00d8\2\u07b6\u07b7\7\u0084\2\2\u07b7\u0137\3\2\2\2\u07b8\u07b9"+ - "\7\u0087\2\2\u07b9\u07ba\t\16\2\2\u07ba\u07bc\7\u0083\2\2\u07bb\u07bd"+ - "\5\32\16\2\u07bc\u07bb\3\2\2\2\u07bc\u07bd\3\2\2\2\u07bd\u07be\3\2\2\2"+ - "\u07be\u07bf\7\u0084\2\2\u07bf\u0139\3\2\2\2\u07c0\u07c3\5\u00acW\2\u07c1"+ - "\u07c3\7\u0088\2\2\u07c2\u07c0\3\2\2\2\u07c2\u07c1\3\2\2\2\u07c3\u013b"+ - "\3\2\2\2\u07c4\u07c5\7\u0087\2\2\u07c5\u07c6\5\u00eex\2\u07c6\u013d\3"+ - "\2\2\2\u07c7\u07cb\7\177\2\2\u07c8\u07ca\5\u0140\u00a1\2\u07c9\u07c8\3"+ - "\2\2\2\u07ca\u07cd\3\2\2\2\u07cb\u07c9\3\2\2\2\u07cb\u07cc\3\2\2\2\u07cc"+ - "\u07ce\3\2\2\2\u07cd\u07cb\3\2\2\2\u07ce\u07cf\7\u0080\2\2\u07cf\u013f"+ - "\3\2\2\2\u07d0\u07d2\5\u0160\u00b1\2\u07d1\u07d0\3\2\2\2\u07d1\u07d2\3"+ - "\2\2\2\u07d2\u07d4\3\2\2\2\u07d3\u07d5\5\u0102\u0082\2\u07d4\u07d3\3\2"+ - "\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07e0\3\2\2\2\u07d6\u07e1\5\u0106\u0084"+ - "\2\u07d7\u07d8\7.\2\2\u07d8\u07da\5\6\4\2\u07d9\u07db\5\u0174\u00bb\2"+ - "\u07da\u07d9\3\2\2\2\u07db\u07dc\3\2\2\2\u07dc\u07da\3\2\2\2\u07dc\u07dd"+ - "\3\2\2\2\u07dd\u07de\3\2\2\2\u07de\u07df\7\u0088\2\2\u07df\u07e1\3\2\2"+ - "\2\u07e0\u07d6\3\2\2\2\u07e0\u07d7\3\2\2\2\u07e1\u0141\3\2\2\2\u07e2\u07ea"+ - "\5\b\5\2\u07e3\u07e5\t\17\2\2\u07e4\u07e3\3\2\2\2\u07e5\u07e8\3\2\2\2"+ - "\u07e6\u07e4\3\2\2\2\u07e6\u07e7\3\2\2\2\u07e7\u07e9\3\2\2\2\u07e8\u07e6"+ - "\3\2\2\2\u07e9\u07eb\5\u0144\u00a3\2\u07ea\u07e6\3\2\2\2\u07eb\u07ec\3"+ - "\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed\3\2\2\2\u07ed\u0143\3\2\2\2\u07ee"+ - "\u07f2\7\u0081\2\2\u07ef\u07f1\7\u0086\2\2\u07f0\u07ef\3\2\2\2\u07f1\u07f4"+ - "\3\2\2\2\u07f2\u07f0\3\2\2\2\u07f2\u07f3\3\2\2\2\u07f3\u07f5\3\2\2\2\u07f4"+ - "\u07f2\3\2\2\2\u07f5\u07f6\7\u0082\2\2\u07f6\u0145\3\2\2\2\u07f7\u0803"+ - "\7\177\2\2\u07f8\u07fd\5\u0112\u008a\2\u07f9\u07fa\7\u0086\2\2\u07fa\u07fc"+ - "\5\u0112\u008a\2\u07fb\u07f9\3\2\2\2\u07fc\u07ff\3\2\2\2\u07fd\u07fb\3"+ - "\2\2\2\u07fd\u07fe\3\2\2\2\u07fe\u0801\3\2\2\2\u07ff\u07fd\3\2\2\2\u0800"+ - "\u0802\7\u0086\2\2\u0801\u0800\3\2\2\2\u0801\u0802\3\2\2\2\u0802\u0804"+ - "\3\2\2\2\u0803\u07f8\3\2\2\2\u0803\u0804\3\2\2\2\u0804\u0805\3\2\2\2\u0805"+ - "\u0806\7\u0080\2\2\u0806\u0147\3\2\2\2\u0807\u0808\7\u0094\2\2\u0808\u080d"+ - "\5\u014a\u00a6\2\u0809\u080a\7\u0086\2\2\u080a\u080c\5\u014a\u00a6\2\u080b"+ - "\u0809\3\2\2\2\u080c\u080f\3\2\2\2\u080d\u080b\3\2\2\2\u080d\u080e\3\2"+ - "\2\2\u080e\u0810\3\2\2\2\u080f\u080d\3\2\2\2\u0810\u0811\7\u0095\2\2\u0811"+ - "\u0149\3\2\2\2\u0812\u0814\5\u0160\u00b1\2\u0813\u0812\3\2\2\2\u0813\u0814"+ - "\3\2\2\2\u0814\u0816\3\2\2\2\u0815\u0817\5\u014c\u00a7\2\u0816\u0815\3"+ - "\2\2\2\u0816\u0817\3\2\2\2\u0817\u0818\3\2\2\2\u0818\u0819\5\u01b4\u00db"+ - "\2\u0819\u014b\3\2\2\2\u081a\u081b\t\20\2\2\u081b\u014d\3\2\2\2\u081c"+ - "\u081d\7\u0087\2\2\u081d\u081e\5\u00eex\2\u081e\u014f\3\2\2\2\u081f\u0823"+ - "\7\177\2\2\u0820\u0822\5\u0152\u00aa\2\u0821\u0820\3\2\2\2\u0822\u0825"+ - "\3\2\2\2\u0823\u0821\3\2\2\2\u0823\u0824\3\2\2\2\u0824\u0826\3\2\2\2\u0825"+ - "\u0823\3\2\2\2\u0826\u0827\7\u0080\2\2\u0827\u0151\3\2\2\2\u0828\u082a"+ - "\5\u0160\u00b1\2\u0829\u0828\3\2\2\2\u0829\u082a\3\2\2\2\u082a\u082c\3"+ - "\2\2\2\u082b\u082d\7D\2\2\u082c\u082b\3\2\2\2\u082c\u082d\3\2\2\2\u082d"+ - "\u086d\3\2\2\2\u082e\u0830\7i\2\2\u082f\u082e\3\2\2\2\u082f\u0830\3\2"+ - "\2\2\u0830\u0836\3\2\2\2\u0831\u0837\7R\2\2\u0832\u0833\7R\2\2\u0833\u0837"+ - "\7Q\2\2\u0834\u0835\7Q\2\2\u0835\u0837\7R\2\2\u0836\u0831\3\2\2\2\u0836"+ - "\u0832\3\2\2\2\u0836\u0834\3\2\2\2\u0836\u0837\3\2\2\2\u0837\u0838\3\2"+ - "\2\2\u0838\u0854\5\6\4\2\u0839\u083b\5\u01b4\u00db\2\u083a\u083c\5\u00e8"+ - "u\2\u083b\u083a\3\2\2\2\u083b\u083c\3\2\2\2\u083c\u083d\3\2\2\2\u083d"+ - "\u083f\7\u0083\2\2\u083e\u0840\5\u011a\u008e\2\u083f\u083e\3\2\2\2\u083f"+ - "\u0840\3\2\2\2\u0840\u0841\3\2\2\2\u0841\u0843\7\u0084\2\2\u0842\u0844"+ - "\5\u00f0y\2\u0843\u0842\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0845\3\2\2"+ - "\2\u0845\u0846\7\u0088\2\2\u0846\u0855\3\2\2\2\u0847\u0848\5\u01b4\u00db"+ - "\2\u0848\u0849\7\177\2\2\u0849\u084a\5\u0154\u00ab\2\u084a\u084b\7\u0080"+ - "\2\2\u084b\u0855\3\2\2\2\u084c\u084d\7`\2\2\u084d\u084e\7\u0081\2\2\u084e"+ - "\u084f\5\u011a\u008e\2\u084f\u0850\7\u0082\2\2\u0850\u0851\7\177\2\2\u0851"+ - "\u0852\5\u0154\u00ab\2\u0852\u0853\7\u0080\2\2\u0853\u0855\3\2\2\2\u0854"+ - "\u0839\3\2\2\2\u0854\u0847\3\2\2\2\u0854\u084c\3\2\2\2\u0855\u086e\3\2"+ - "\2\2\u0856\u0858\7i\2\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858"+ - "\u0859\3\2\2\2\u0859\u085a\7n\2\2\u085a\u085c\5\u01b4\u00db\2\u085b\u085d"+ - "\5\u00e8u\2\u085c\u085b\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085e\3\2\2"+ - "\2\u085e\u0860\7\u0083\2\2\u085f\u0861\5\u011a\u008e\2\u0860\u085f\3\2"+ - "\2\2\u0860\u0861\3\2\2\2\u0861\u0862\3\2\2\2\u0862\u0864\7\u0084\2\2\u0863"+ - "\u0865\5\u00f0y\2\u0864\u0863\3\2\2\2\u0864\u0865\3\2\2\2\u0865\u0866"+ - "\3\2\2\2\u0866\u0867\7\u0088\2\2\u0867\u086e\3\2\2\2\u0868\u0869\7)\2"+ - "\2\u0869\u086a\5\6\4\2\u086a\u086b\5\u01b4\u00db\2\u086b\u086c\7\u0088"+ - "\2\2\u086c\u086e\3\2\2\2\u086d\u082f\3\2\2\2\u086d\u0857\3\2\2\2\u086d"+ - "\u0868\3\2\2\2\u086e\u0153\3\2\2\2\u086f\u0871\5\u0160\u00b1\2\u0870\u086f"+ - "\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0884\3\2\2\2\u0872\u0873\7\63\2\2"+ - "\u0873\u0879\7\u0088\2\2\u0874\u0876\5\u0160\u00b1\2\u0875\u0874\3\2\2"+ - "\2\u0875\u0876\3\2\2\2\u0876\u0877\3\2\2\2\u0877\u0878\7X\2\2\u0878\u087a"+ - "\7\u0088\2\2\u0879\u0875\3\2\2\2\u0879\u087a\3\2\2\2\u087a\u0885\3\2\2"+ - "\2\u087b\u087c\7X\2\2\u087c\u0882\7\u0088\2\2\u087d\u087f\5\u0160\u00b1"+ - "\2\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0881"+ - "\7\63\2\2\u0881\u0883\7\u0088\2\2\u0882\u087e\3\2\2\2\u0882\u0883\3\2"+ - "\2\2\u0883\u0885\3\2\2\2\u0884\u0872\3\2\2\2\u0884\u087b\3\2\2\2\u0885"+ - "\u0155\3\2\2\2\u0886\u0887\7\u0087\2\2\u0887\u0888\5\6\4\2\u0888\u0157"+ - "\3\2\2\2\u0889\u0895\7\177\2\2\u088a\u088f\5\u015a\u00ae\2\u088b\u088c"+ - "\7\u0086\2\2\u088c\u088e\5\u015a\u00ae\2\u088d\u088b\3\2\2\2\u088e\u0891"+ - "\3\2\2\2\u088f\u088d\3\2\2\2\u088f\u0890\3\2\2\2\u0890\u0893\3\2\2\2\u0891"+ - "\u088f\3\2\2\2\u0892\u0894\7\u0086\2\2\u0893\u0892\3\2\2\2\u0893\u0894"+ - "\3\2\2\2\u0894\u0896\3\2\2\2\u0895\u088a\3\2\2\2\u0895\u0896\3\2\2\2\u0896"+ - "\u0897\3\2\2\2\u0897\u0898\7\u0080\2\2\u0898\u0159\3\2\2\2\u0899\u089b"+ - "\5\u0160\u00b1\2\u089a\u0899\3\2\2\2\u089a\u089b\3\2\2\2\u089b\u089c\3"+ - "\2\2\2\u089c\u089f\5\u01b4\u00db\2\u089d\u089e\7\u0093\2\2\u089e\u08a0"+ - "\5\36\20\2\u089f\u089d\3\2\2\2\u089f\u08a0\3\2\2\2\u08a0\u015b\3\2\2\2"+ - "\u08a1\u08a2\7\u0081\2\2\u08a2\u08a3\5\u015e\u00b0\2\u08a3\u08a4\7\u0087"+ - "\2\2\u08a4\u08a6\5\u0166\u00b4\2\u08a5\u08a7\7\u0086\2\2\u08a6\u08a5\3"+ - "\2\2\2\u08a6\u08a7\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8\u08a9\7\u0082\2\2"+ - "\u08a9\u015d\3\2\2\2\u08aa\u08ad\5\u018e\u00c8\2\u08ab\u08ad\5\u01b4\u00db"+ - "\2\u08ac\u08aa\3\2\2\2\u08ac\u08ab\3\2\2\2\u08ad\u015f\3\2\2\2\u08ae\u08b0"+ - "\5\u0162\u00b2\2\u08af\u08ae\3\2\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08af\3"+ - "\2\2\2\u08b1\u08b2\3\2\2\2\u08b2\u0161\3\2\2\2\u08b3\u08b7\7\u0081\2\2"+ - "\u08b4\u08b5\5\u0164\u00b3\2\u08b5\u08b6\7\u0087\2\2\u08b6\u08b8\3\2\2"+ - "\2\u08b7\u08b4\3\2\2\2\u08b7\u08b8\3\2\2\2\u08b8\u08b9\3\2\2\2\u08b9\u08bb"+ - "\5\u0166\u00b4\2\u08ba\u08bc\7\u0086\2\2\u08bb\u08ba\3\2\2\2\u08bb\u08bc"+ - "\3\2\2\2\u08bc\u08bd\3\2\2\2\u08bd\u08be\7\u0082\2\2\u08be\u0163\3\2\2"+ - "\2\u08bf\u08c2\5\u018e\u00c8\2\u08c0\u08c2\5\u01b4\u00db\2\u08c1\u08bf"+ - "\3\2\2\2\u08c1\u08c0\3\2\2\2\u08c2\u0165\3\2\2\2\u08c3\u08c8\5\u0168\u00b5"+ - "\2\u08c4\u08c5\7\u0086\2\2\u08c5\u08c7\5\u0168\u00b5\2\u08c6\u08c4\3\2"+ - "\2\2\u08c7\u08ca\3\2\2\2\u08c8\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9"+ - "\u0167\3\2\2\2\u08ca\u08c8\3\2\2\2\u08cb\u08d8\5\4\3\2\u08cc\u08d5\7\u0083"+ - "\2\2\u08cd\u08d2\5\u016a\u00b6\2\u08ce\u08cf\7\u0086\2\2\u08cf\u08d1\5"+ - "\u016a\u00b6\2\u08d0\u08ce\3\2\2\2\u08d1\u08d4\3\2\2\2\u08d2\u08d0\3\2"+ - "\2\2\u08d2\u08d3\3\2\2\2\u08d3\u08d6\3\2\2\2\u08d4\u08d2\3\2\2\2\u08d5"+ - "\u08cd\3\2\2\2\u08d5\u08d6\3\2\2\2\u08d6\u08d7\3\2\2\2\u08d7\u08d9\7\u0084"+ - "\2\2\u08d8\u08cc\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9\u0169\3\2\2\2\u08da"+ - "\u08db\5\u01b4\u00db\2\u08db\u08dc\7\u0087\2\2\u08dc\u08de\3\2\2\2\u08dd"+ - "\u08da\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\3\2\2\2\u08df\u08e0\5\36"+ - "\20\2\u08e0\u016b\3\2\2\2\u08e1\u08e4\5\16\b\2\u08e2\u08e4\5\26\f\2\u08e3"+ - "\u08e1\3\2\2\2\u08e3\u08e2\3\2\2\2\u08e4\u08e9\3\2\2\2\u08e5\u08e8\5\u0144"+ - "\u00a3\2\u08e6\u08e8\7\u0096\2\2\u08e7\u08e5\3\2\2\2\u08e7\u08e6\3\2\2"+ - "\2\u08e8\u08eb\3\2\2\2\u08e9\u08e7\3\2\2\2\u08e9\u08ea\3\2\2\2\u08ea\u08ec"+ - "\3\2\2\2\u08eb\u08e9\3\2\2\2\u08ec\u08ed\7\u008b\2\2\u08ed\u08f1\3\2\2"+ - "\2\u08ee\u08ef\7n\2\2\u08ef\u08f1\7\u008b\2\2\u08f0\u08e3\3\2\2\2\u08f0"+ - "\u08ee\3\2\2\2\u08f1\u016d\3\2\2\2\u08f2\u08f7\5\u0170\u00b9\2\u08f3\u08f4"+ - "\7\u0086\2\2\u08f4\u08f6\5\u0170\u00b9\2\u08f5\u08f3\3\2\2\2\u08f6\u08f9"+ - "\3\2\2\2\u08f7\u08f5\3\2\2\2\u08f7\u08f8\3\2\2\2\u08f8\u016f\3\2\2\2\u08f9"+ - "\u08f7\3\2\2\2\u08fa\u08fb\5\u01b4\u00db\2\u08fb\u08fc\7\u0093\2\2\u08fc"+ - "\u08fd\5\u0172\u00ba\2\u08fd\u0171\3\2\2\2\u08fe\u0900\7\u008e\2\2\u08ff"+ - "\u08fe\3\2\2\2\u08ff\u0900\3\2\2\2\u0900\u0901\3\2\2\2\u0901\u0904\5\36"+ - "\20\2\u0902\u0904\5\u0176\u00bc\2\u0903\u08ff\3\2\2\2\u0903\u0902\3\2"+ - "\2\2\u0904\u0173\3\2\2\2\u0905\u0906\5\u01b4\u00db\2\u0906\u0907\7\u0081"+ - "\2\2\u0907\u0908\5\36\20\2\u0908\u0909\7\u0082\2\2\u0909\u0175\3\2\2\2"+ - "\u090a\u090b\7[\2\2\u090b\u090c\5\6\4\2\u090c\u090d\7\u0081\2\2\u090d"+ - "\u090e\5\36\20\2\u090e\u090f\7\u0082\2\2\u090f\u0928\3\2\2\2\u0910\u0912"+ - "\7[\2\2\u0911\u0913\5\6\4\2\u0912\u0911\3\2\2\2\u0912\u0913\3\2\2\2\u0913"+ - "\u0914\3\2\2\2\u0914\u0916\7\u0081\2\2\u0915\u0917\5\36\20\2\u0916\u0915"+ - "\3\2\2\2\u0916\u0917\3\2\2\2\u0917\u0918\3\2\2\2\u0918\u0919\7\u0082\2"+ - "\2\u0919\u091a\7\177\2\2\u091a\u091f\5\36\20\2\u091b\u091c\7\u0086\2\2"+ - "\u091c\u091e\5\36\20\2\u091d\u091b\3\2\2\2\u091e\u0921\3\2\2\2\u091f\u091d"+ - "\3\2\2\2\u091f\u0920\3\2\2\2\u0920\u0923\3\2\2\2\u0921\u091f\3\2\2\2\u0922"+ - "\u0924\7\u0086\2\2\u0923\u0922\3\2\2\2\u0923\u0924\3\2\2\2\u0924\u0925"+ - "\3\2\2\2\u0925\u0926\7\u0080\2\2\u0926\u0928\3\2\2\2\u0927\u090a\3\2\2"+ - "\2\u0927\u0910\3\2\2\2\u0928\u0177\3\2\2\2\u0929\u092a\7\u0093\2\2\u092a"+ - "\u092b\7\u0095\2\2\u092b\u092c\6\u00bd\2\3\u092c\u0179\3\2\2\2\u092d\u092e"+ - "\7\u0095\2\2\u092e\u092f\7\u0095\2\2\u092f\u0930\6\u00be\3\3\u0930\u017b"+ - "\3\2\2\2\u0931\u0932\7\u0095\2\2\u0932\u0933\7\u00a1\2\2\u0933\u0934\6"+ - "\u00bf\4\3\u0934\u017d\3\2\2\2\u0935\u093e\5\u0180\u00c1\2\u0936\u093e"+ - "\5\u0182\u00c2\2\u0937\u093e\7v\2\2\u0938\u093e\7w\2\2\u0939\u093e\7x"+ - "\2\2\u093a\u093e\7y\2\2\u093b\u093e\7z\2\2\u093c\u093e\7E\2\2\u093d\u0935"+ - "\3\2\2\2\u093d\u0936\3\2\2\2\u093d\u0937\3\2\2\2\u093d\u0938\3\2\2\2\u093d"+ - "\u0939\3\2\2\2\u093d\u093a\3\2\2\2\u093d\u093b\3\2\2\2\u093d\u093c\3\2"+ - "\2\2\u093e\u017f\3\2\2\2\u093f\u0940\t\21\2\2\u0940\u0181\3\2\2\2\u0941"+ - "\u0946\5\u0184\u00c3\2\u0942\u0946\5\u0186\u00c4\2\u0943\u0946\7{\2\2"+ - "\u0944\u0946\7|\2\2\u0945\u0941\3\2\2\2\u0945\u0942\3\2\2\2\u0945\u0943"+ - "\3\2\2\2\u0945\u0944\3\2\2\2\u0946\u0183\3\2\2\2\u0947\u094b\7}\2\2\u0948"+ - "\u094a\5\u0188\u00c5\2\u0949\u0948\3\2\2\2\u094a\u094d\3\2\2\2\u094b\u0949"+ - "\3\2\2\2\u094b\u094c\3\2\2\2\u094c\u094e\3\2\2\2\u094d\u094b\3\2\2\2\u094e"+ - "\u094f\7\u00b2\2\2\u094f\u0185\3\2\2\2\u0950\u0954\7~\2\2\u0951\u0953"+ - "\5\u018a\u00c6\2\u0952\u0951\3\2\2\2\u0953\u0956\3\2\2\2\u0954\u0952\3"+ - "\2\2\2\u0954\u0955\3\2\2\2\u0955\u0957\3\2\2\2\u0956\u0954\3\2\2\2"; - private static final String _serializedATNSegment1 = - "\u0957\u0958\7\u00b2\2\2\u0958\u0187\3\2\2\2\u0959\u095e\5\u018c\u00c7"+ - "\2\u095a\u095e\7\u00ae\2\2\u095b\u095e\7\u00b0\2\2\u095c\u095e\7\u00b3"+ - "\2\2\u095d\u0959\3\2\2\2\u095d\u095a\3\2\2\2\u095d\u095b\3\2\2\2\u095d"+ - "\u095c\3\2\2\2\u095e\u0189\3\2\2\2\u095f\u0964\5\u018c\u00c7\2\u0960\u0964"+ - "\7\u00ae\2\2\u0961\u0964\7\u00b1\2\2\u0962\u0964\7\u00b4\2\2\u0963\u095f"+ - "\3\2\2\2\u0963\u0960\3\2\2\2\u0963\u0961\3\2\2\2\u0963\u0962\3\2\2\2\u0964"+ - "\u018b\3\2\2\2\u0965\u096a\5\36\20\2\u0966\u0967\7\u0086\2\2\u0967\u0969"+ - "\5\36\20\2\u0968\u0966\3\2\2\2\u0969\u096c\3\2\2\2\u096a\u0968\3\2\2\2"+ - "\u096a\u096b\3\2\2\2\u096b\u0973\3\2\2\2\u096c\u096a\3\2\2\2\u096d\u096f"+ - "\7\u0087\2\2\u096e\u0970\7\u00b6\2\2\u096f\u096e\3\2\2\2\u0970\u0971\3"+ - "\2\2\2\u0971\u096f\3\2\2\2\u0971\u0972\3\2\2\2\u0972\u0974\3\2\2\2\u0973"+ - "\u096d\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u018d\3\2\2\2\u0975\u0976\t\22"+ - "\2\2\u0976\u018f\3\2\2\2\u0977\u0978\7\34\2\2\u0978\u097a\5\u01b4\u00db"+ - "\2\u0979\u097b\5\u00e8u\2\u097a\u0979\3\2\2\2\u097a\u097b\3\2\2\2\u097b"+ - "\u097d\3\2\2\2\u097c\u097e\5\u00ecw\2\u097d\u097c\3\2\2\2\u097d\u097e"+ - "\3\2\2\2\u097e\u0980\3\2\2\2\u097f\u0981\5\u00f0y\2\u0980\u097f\3\2\2"+ - "\2\u0980\u0981\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0984\5\u00fc\177\2\u0983"+ - "\u0985\7\u0088\2\2\u0984\u0983\3\2\2\2\u0984\u0985\3\2\2\2\u0985\u0191"+ - "\3\2\2\2\u0986\u0988\t\23\2\2\u0987\u0986\3\2\2\2\u0987\u0988\3\2\2\2"+ - "\u0988\u0989\3\2\2\2\u0989\u098a\7^\2\2\u098a\u098c\5\u01b4\u00db\2\u098b"+ - "\u098d\5\u00e8u\2\u098c\u098b\3\2\2\2\u098c\u098d\3\2\2\2\u098d\u098f"+ - "\3\2\2\2\u098e\u0990\5\u013c\u009f\2\u098f\u098e\3\2\2\2\u098f\u0990\3"+ - "\2\2\2\u0990\u0992\3\2\2\2\u0991\u0993\5\u00f0y\2\u0992\u0991\3\2\2\2"+ - "\u0992\u0993\3\2\2\2\u0993\u0994\3\2\2\2\u0994\u0996\5\u013e\u00a0\2\u0995"+ - "\u0997\7\u0088\2\2\u0996\u0995\3\2\2\2\u0996\u0997\3\2\2\2\u0997\u0193"+ - "\3\2\2\2\u0998\u0999\7:\2\2\u0999\u099b\5\u01b4\u00db\2\u099a\u099c\5"+ - "\u0148\u00a5\2\u099b\u099a\3\2\2\2\u099b\u099c\3\2\2\2\u099c\u099e\3\2"+ - "\2\2\u099d\u099f\5\u014e\u00a8\2\u099e\u099d\3\2\2\2\u099e\u099f\3\2\2"+ - "\2\u099f\u09a1\3\2\2\2\u09a0\u09a2\5\u00f0y\2\u09a1\u09a0\3\2\2\2\u09a1"+ - "\u09a2\3\2\2\2\u09a2\u09a3\3\2\2\2\u09a3\u09a5\5\u00fc\177\2\u09a4\u09a6"+ - "\7\u0088\2\2\u09a5\u09a4\3\2\2\2\u09a5\u09a6\3\2\2\2\u09a6\u0195\3\2\2"+ - "\2\u09a7\u09a8\7\'\2\2\u09a8\u09aa\5\u01b4\u00db\2\u09a9\u09ab\5\u0156"+ - "\u00ac\2\u09aa\u09a9\3\2\2\2\u09aa\u09ab\3\2\2\2\u09ab\u09ac\3\2\2\2\u09ac"+ - "\u09ae\5\u0158\u00ad\2\u09ad\u09af\7\u0088\2\2\u09ae\u09ad\3\2\2\2\u09ae"+ - "\u09af\3\2\2\2\u09af\u0197\3\2\2\2\u09b0\u09b1\7!\2\2\u09b1\u09b2\5\u0114"+ - "\u008b\2\u09b2\u09b4\5\u01b4\u00db\2\u09b3\u09b5\5\u0148\u00a5\2\u09b4"+ - "\u09b3\3\2\2\2\u09b4\u09b5\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b8\7\u0083"+ - "\2\2\u09b7\u09b9\5\u011a\u008e\2\u09b8\u09b7\3\2\2\2\u09b8\u09b9\3\2\2"+ - "\2\u09b9\u09ba\3\2\2\2\u09ba\u09bc\7\u0084\2\2\u09bb\u09bd\5\u00f0y\2"+ - "\u09bc\u09bb\3\2\2\2\u09bc\u09bd\3\2\2\2\u09bd\u09be\3\2\2\2\u09be\u09bf"+ - "\7\u0088\2\2\u09bf\u0199\3\2\2\2\u09c0\u09c1\7)\2\2\u09c1\u09ca\5\6\4"+ - "\2\u09c2\u09c3\5\u010e\u0088\2\u09c3\u09c4\7\u0088\2\2\u09c4\u09cb\3\2"+ - "\2\2\u09c5\u09c6\5\u0116\u008c\2\u09c6\u09c7\7\177\2\2\u09c7\u09c8\5\u012e"+ - "\u0098\2\u09c8\u09c9\7\u0080\2\2\u09c9\u09cb\3\2\2\2\u09ca\u09c2\3\2\2"+ - "\2\u09ca\u09c5\3\2\2\2\u09cb\u019b\3\2\2\2\u09cc\u09cd\5\u010e\u0088\2"+ - "\u09cd\u09ce\7\u0088\2\2\u09ce\u019d\3\2\2\2\u09cf\u09dd\5\u0116\u008c"+ - "\2\u09d0\u09d1\7\177\2\2\u09d1\u09d2\5\u0124\u0093\2\u09d2\u09d7\7\u0080"+ - "\2\2\u09d3\u09d4\7\u0093\2\2\u09d4\u09d5\5\u0112\u008a\2\u09d5\u09d6\7"+ - "\u0088\2\2\u09d6\u09d8\3\2\2\2\u09d7\u09d3\3\2\2\2\u09d7\u09d8\3\2\2\2"+ - "\u09d8\u09de\3\2\2\2\u09d9\u09da\5\u0178\u00bd\2\u09da\u09db\5L\'\2\u09db"+ - "\u09dc\7\u0088\2\2\u09dc\u09de\3\2\2\2\u09dd\u09d0\3\2\2\2\u09dd\u09d9"+ - "\3\2\2\2\u09de\u019f\3\2\2\2\u09df\u09e0\7\35\2\2\u09e0\u09e1\5\6\4\2"+ - "\u09e1\u09e2\5\u010a\u0086\2\u09e2\u09e3\7\u0088\2\2\u09e3\u01a1\3\2\2"+ - "\2\u09e4\u09e5\7`\2\2\u09e5\u09e6\7\u0081\2\2\u09e6\u09e7\5\u011a\u008e"+ - "\2\u09e7\u09f0\7\u0082\2\2\u09e8\u09e9\7\177\2\2\u09e9\u09ea\5\u0124\u0093"+ - "\2\u09ea\u09eb\7\u0080\2\2\u09eb\u09f1\3\2\2\2\u09ec\u09ed\5\u0178\u00bd"+ - "\2\u09ed\u09ee\5L\'\2\u09ee\u09ef\7\u0088\2\2\u09ef\u09f1\3\2\2\2\u09f0"+ - "\u09e8\3\2\2\2\u09f0\u09ec\3\2\2\2\u09f1\u01a3\3\2\2\2\u09f2\u09f3\7\u0092"+ - "\2\2\u09f3\u09f4\5\u01b4\u00db\2\u09f4\u09f5\7\u0083\2\2\u09f5\u09f6\7"+ - "\u0084\2\2\u09f6\u09f7\5\u013a\u009e\2\u09f7\u01a5\3\2\2\2\u09f8\u09f9"+ - "\5\u01b4\u00db\2\u09f9\u09fb\7\u0083\2\2\u09fa\u09fc\5\u011a\u008e\2\u09fb"+ - "\u09fa\3\2\2\2\u09fb\u09fc\3\2\2\2\u09fc\u09fd\3\2\2\2\u09fd\u09ff\7\u0084"+ - "\2\2\u09fe\u0a00\5\u0138\u009d\2\u09ff\u09fe\3\2\2\2\u09ff\u0a00\3\2\2"+ - "\2\u0a00\u0a01\3\2\2\2\u0a01\u0a02\5\u013a\u009e\2\u0a02\u01a7\3\2\2\2"+ - "\u0a03\u0a05\5\u01aa\u00d6\2\u0a04\u0a06\5\u00e8u\2\u0a05\u0a04\3\2\2"+ - "\2\u0a05\u0a06\3\2\2\2\u0a06\u0a07\3\2\2\2\u0a07\u0a09\7\u0083\2\2\u0a08"+ - "\u0a0a\5\u011a\u008e\2\u0a09\u0a08\3\2\2\2\u0a09\u0a0a\3\2\2\2\u0a0a\u0a0b"+ - "\3\2\2\2\u0a0b\u0a0d\7\u0084\2\2\u0a0c\u0a0e\5\u00f0y\2\u0a0d\u0a0c\3"+ - "\2\2\2\u0a0d\u0a0e\3\2\2\2\u0a0e\u0a14\3\2\2\2\u0a0f\u0a15\5\u0118\u008d"+ - "\2\u0a10\u0a11\5\u0178\u00bd\2\u0a11\u0a12\5L\'\2\u0a12\u0a13\7\u0088"+ - "\2\2\u0a13\u0a15\3\2\2\2\u0a14\u0a0f\3\2\2\2\u0a14\u0a10\3\2\2\2\u0a15"+ - "\u01a9\3\2\2\2\u0a16\u0a1c\5\u01b4\u00db\2\u0a17\u0a18\5\u01b4\u00db\2"+ - "\u0a18\u0a19\7\u0097\2\2\u0a19\u0a1a\5\u01b4\u00db\2\u0a1a\u0a1c\3\2\2"+ - "\2\u0a1b\u0a16\3\2\2\2\u0a1b\u0a17\3\2\2\2\u0a1c\u0a24\3\2\2\2\u0a1d\u0a1f"+ - "\5\30\r\2\u0a1e\u0a1d\3\2\2\2\u0a1e\u0a1f\3\2\2\2\u0a1f\u0a20\3\2\2\2"+ - "\u0a20\u0a21\7\u0085\2\2\u0a21\u0a23\5\u01b4\u00db\2\u0a22\u0a1e\3\2\2"+ - "\2\u0a23\u0a26\3\2\2\2\u0a24\u0a22\3\2\2\2\u0a24\u0a25\3\2\2\2\u0a25\u01ab"+ - "\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a27\u0a28\7H\2\2\u0a28\u0a29\5\u0134\u009b"+ - "\2\u0a29\u0a2b\7\u0083\2\2\u0a2a\u0a2c\78\2\2\u0a2b\u0a2a\3\2\2\2\u0a2b"+ - "\u0a2c\3\2\2\2\u0a2c\u0a2d\3\2\2\2\u0a2d\u0a33\5\u01ae\u00d8\2\u0a2e\u0a30"+ - "\7\u0086\2\2\u0a2f\u0a31\78\2\2\u0a30\u0a2f\3\2\2\2\u0a30\u0a31\3\2\2"+ - "\2\u0a31\u0a32\3\2\2\2\u0a32\u0a34\5\u01ae\u00d8\2\u0a33\u0a2e\3\2\2\2"+ - "\u0a33\u0a34\3\2\2\2\u0a34\u0a35\3\2\2\2\u0a35\u0a3b\7\u0084\2\2\u0a36"+ - "\u0a3c\5\u013a\u009e\2\u0a37\u0a38\5\u0178\u00bd\2\u0a38\u0a39\5L\'\2"+ - "\u0a39\u0a3a\7\u0088\2\2\u0a3a\u0a3c\3\2\2\2\u0a3b\u0a36\3\2\2\2\u0a3b"+ - "\u0a37\3\2\2\2\u0a3c\u01ad\3\2\2\2\u0a3d\u0a3e\5\6\4\2\u0a3e\u0a41\5\u01b4"+ - "\u00db\2\u0a3f\u0a40\7\u0093\2\2\u0a40\u0a42\5\36\20\2\u0a41\u0a3f\3\2"+ - "\2\2\u0a41\u0a42\3\2\2\2\u0a42\u01af\3\2\2\2\u0a43\u0a45\7\u0083\2\2\u0a44"+ - "\u0a46\5\32\16\2\u0a45\u0a44\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46\u0a47\3"+ - "\2\2\2\u0a47\u0a48\7\u0084\2\2\u0a48\u01b1\3\2\2\2\u0a49\u0a4b\7\u0083"+ - "\2\2\u0a4a\u0a4c\5\32\16\2\u0a4b\u0a4a\3\2\2\2\u0a4b\u0a4c\3\2\2\2\u0a4c"+ - "\u0a4d\3\2\2\2\u0a4d\u0a4f\7\u0084\2\2\u0a4e\u0a50\5Z.\2\u0a4f\u0a4e\3"+ - "\2\2\2\u0a4f\u0a50\3\2\2\2\u0a50\u01b3\3\2\2\2\u0a51\u0a52\t\24\2\2\u0a52"+ - "\u01b5\3\2\2\2\u015a\u01b7\u01ba\u01bd\u01c2\u01c6\u01cc\u01cf\u01d4\u01d8"+ - "\u01df\u01e1\u01e9\u01f1\u01f7\u01fb\u0200\u020a\u0212\u021c\u0222\u0225"+ - "\u0229\u0231\u0236\u0240\u024d\u0255\u025b\u025d\u0264\u026c\u0274\u027c"+ - "\u0284\u028c\u0296\u0298\u029e\u02a3\u02ab\u02b3\u02bb\u02bd\u02c0\u02c7"+ - "\u02cc\u02d3\u02d7\u02d9\u02f5\u02f9\u02fe\u0302\u030a\u030d\u0312\u0316"+ - "\u031a\u0320\u032e\u0334\u0340\u0344\u0349\u034d\u0353\u035b\u0364\u0376"+ - "\u0379\u037e\u0381\u0390\u0396\u039a\u03a0\u03a5\u03a8\u03b0\u03b8\u03c3"+ - "\u03c8\u03cd\u03cf\u03d8\u03e0\u03e7\u03ef\u03f3\u03fc\u0401\u0403\u040c"+ - "\u0414\u0418\u041d\u041f\u0424\u0428\u042f\u0437\u0439\u043d\u0440\u0443"+ - "\u044b\u0455\u0466\u046d\u0471\u047b\u0480\u0487\u0490\u0495\u049c\u04a8"+ - "\u04b3\u04bb\u04c0\u04c9\u04d2\u04db\u04e1\u04e6\u04ea\u04ee\u04f2\u04f6"+ - "\u04fd\u0505\u0512\u051c\u0532\u0536\u053a\u053f\u0553\u0558\u055d\u0564"+ - "\u0567\u057d\u0589\u058d\u0595\u059d\u05a4\u05a8\u05ad\u05b0\u05b5\u05bd"+ - "\u05c2\u05c9\u05cf\u05d7\u05df\u05e2\u05e9\u05f0\u05f4\u05f7\u05fd\u0601"+ - "\u0607\u0615\u061b\u0622\u0627\u062a\u062d\u0634\u063e\u064f\u0654\u0658"+ - "\u065b\u065e\u0665\u066b\u0673\u0679\u0683\u068b\u0691\u069c\u06a0\u06a2"+ - "\u06a7\u06ab\u06b2\u06bb\u06c2\u06c5\u06c8\u06cc\u06d1\u06de\u06e8\u06ef"+ - "\u06fb\u0702\u070e\u0714\u0718\u071c\u0722\u0728\u072a\u0731\u0735\u0738"+ - "\u073c\u0746\u0749\u0750\u0753\u0758\u075d\u075f\u0762\u0765\u076b\u076e"+ - "\u077a\u077e\u0781\u078b\u078e\u0794\u07af\u07bc\u07c2\u07cb\u07d1\u07d4"+ - "\u07dc\u07e0\u07e6\u07ec\u07f2\u07fd\u0801\u0803\u080d\u0813\u0816\u0823"+ - "\u0829\u082c\u082f\u0836\u083b\u083f\u0843\u0854\u0857\u085c\u0860\u0864"+ - "\u086d\u0870\u0875\u0879\u087e\u0882\u0884\u088f\u0893\u0895\u089a\u089f"+ - "\u08a6\u08ac\u08b1\u08b7\u08bb\u08c1\u08c8\u08d2\u08d5\u08d8\u08dd\u08e3"+ - "\u08e7\u08e9\u08f0\u08f7\u08ff\u0903\u0912\u0916\u091f\u0923\u0927\u093d"+ - "\u0945\u094b\u0954\u095d\u0963\u096a\u0971\u0973\u097a\u097d\u0980\u0984"+ - "\u0987\u098c\u098f\u0992\u0996\u099b\u099e\u09a1\u09a5\u09aa\u09ae\u09b4"+ - "\u09b8\u09bc\u09ca\u09d7\u09dd\u09f0\u09fb\u09ff\u0a05\u0a09\u0a0d\u0a14"+ - "\u0a1b\u0a1e\u0a24\u0a2b\u0a30\u0a33\u0a3b\u0a41\u0a45\u0a4b\u0a4f"; - public static final String _serializedATN = Utils.join( - new String[] { - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.interp deleted file mode 100644 index 2c866a4..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.interp +++ /dev/null @@ -1,666 +0,0 @@ -token literal names: -null -null -null -null -null -null -'...' -'.' -',' -'(' -')' -'[' -']' -'{' -'}' -'*' -'%' -'/' -'+' -'-' -'++' -'--' -'&&' -'||' -null -'!' -':' -';' -'=' -'+=' -'-=' -'*=' -'/=' -'%=' -'->' -'=>' -'..' -'::' -';;' -'#' -'@' -null -null -'?' -'<' -'>' -'<=' -'>=' -'!=' -'!==' -'as?' -'==' -'===' -'\'' -null -null -null -null -null -'package' -'import' -'class' -'interface' -'fun' -'object' -'val' -'var' -'typealias' -'constructor' -'by' -'companion' -'init' -'this' -'super' -'typeof' -'where' -'if' -'else' -'when' -'try' -'catch' -'finally' -'for' -'do' -'while' -'throw' -'return' -'continue' -'break' -'as' -'is' -'in' -null -null -'out' -'get' -'set' -'dynamic' -'@file' -'@field' -'@property' -'@get' -'@set' -'@receiver' -'@param' -'@setparam' -'@delegate' -'public' -'private' -'protected' -'internal' -'enum' -'sealed' -'annotation' -'data' -'inner' -'tailrec' -'operator' -'inline' -'infix' -'external' -'suspend' -'override' -'abstract' -'final' -'open' -'const' -'lateinit' -'vararg' -'noinline' -'crossinline' -'reified' -'expect' -'actual' -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 - -token symbolic names: -null -ShebangLine -DelimitedComment -LineComment -WS -NL -RESERVED -DOT -COMMA -LPAREN -RPAREN -LSQUARE -RSQUARE -LCURL -RCURL -MULT -MOD -DIV -ADD -SUB -INCR -DECR -CONJ -DISJ -EXCL_WS -EXCL_NO_WS -COLON -SEMICOLON -ASSIGNMENT -ADD_ASSIGNMENT -SUB_ASSIGNMENT -MULT_ASSIGNMENT -DIV_ASSIGNMENT -MOD_ASSIGNMENT -ARROW -DOUBLE_ARROW -RANGE -COLONCOLON -DOUBLE_SEMICOLON -HASH -AT -AT_WS -QUEST_WS -QUEST_NO_WS -LANGLE -RANGLE -LE -GE -EXCL_EQ -EXCL_EQEQ -AS_SAFE -EQEQ -EQEQEQ -SINGLE_QUOTE -RETURN_AT -CONTINUE_AT -BREAK_AT -THIS_AT -SUPER_AT -PACKAGE -IMPORT -CLASS -INTERFACE -FUN -OBJECT -VAL -VAR -TYPE_ALIAS -CONSTRUCTOR -BY -COMPANION -INIT -THIS -SUPER -TYPEOF -WHERE -IF -ELSE -WHEN -TRY -CATCH -FINALLY -FOR -DO -WHILE -THROW -RETURN -CONTINUE -BREAK -AS -IS -IN -NOT_IS -NOT_IN -OUT -GETTER -SETTER -DYNAMIC -AT_FILE -AT_FIELD -AT_PROPERTY -AT_GET -AT_SET -AT_RECEIVER -AT_PARAM -AT_SETPARAM -AT_DELEGATE -PUBLIC -PRIVATE -PROTECTED -INTERNAL -ENUM -SEALED -ANNOTATION -DATA -INNER -TAILREC -OPERATOR -INLINE -INFIX -EXTERNAL -SUSPEND -OVERRIDE -ABSTRACT -FINAL -OPEN -CONST -LATEINIT -VARARG -NOINLINE -CROSSINLINE -REIFIED -EXPECT -ACTUAL -QUOTE_OPEN -TRIPLE_QUOTE_OPEN -RealLiteral -FloatLiteral -DoubleLiteral -LongLiteral -IntegerLiteral -HexLiteral -BinLiteral -BooleanLiteral -NullLiteral -Identifier -IdentifierAt -FieldIdentifier -CharacterLiteral -ErrorCharacter -UNICODE_CLASS_LL -UNICODE_CLASS_LM -UNICODE_CLASS_LO -UNICODE_CLASS_LT -UNICODE_CLASS_LU -UNICODE_CLASS_ND -UNICODE_CLASS_NL -Inside_Comment -Inside_WS -Inside_NL -QUOTE_CLOSE -LineStrRef -LineStrText -LineStrEscapedChar -LineStrExprStart -TRIPLE_QUOTE_CLOSE -MultiLineStringQuote -MultiLineStrRef -MultiLineStrText -MultiLineStrExprStart - -rule names: -ShebangLine -DelimitedComment -LineComment -WS -NL -Hidden -RESERVED -DOT -COMMA -LPAREN -RPAREN -LSQUARE -RSQUARE -LCURL -RCURL -MULT -MOD -DIV -ADD -SUB -INCR -DECR -CONJ -DISJ -EXCL_WS -EXCL_NO_WS -COLON -SEMICOLON -ASSIGNMENT -ADD_ASSIGNMENT -SUB_ASSIGNMENT -MULT_ASSIGNMENT -DIV_ASSIGNMENT -MOD_ASSIGNMENT -ARROW -DOUBLE_ARROW -RANGE -COLONCOLON -DOUBLE_SEMICOLON -HASH -AT -AT_WS -QUEST_WS -QUEST_NO_WS -LANGLE -RANGLE -LE -GE -EXCL_EQ -EXCL_EQEQ -AS_SAFE -EQEQ -EQEQEQ -SINGLE_QUOTE -RETURN_AT -CONTINUE_AT -BREAK_AT -THIS_AT -SUPER_AT -PACKAGE -IMPORT -CLASS -INTERFACE -FUN -OBJECT -VAL -VAR -TYPE_ALIAS -CONSTRUCTOR -BY -COMPANION -INIT -THIS -SUPER -TYPEOF -WHERE -IF -ELSE -WHEN -TRY -CATCH -FINALLY -FOR -DO -WHILE -THROW -RETURN -CONTINUE -BREAK -AS -IS -IN -NOT_IS -NOT_IN -OUT -GETTER -SETTER -DYNAMIC -AT_FILE -AT_FIELD -AT_PROPERTY -AT_GET -AT_SET -AT_RECEIVER -AT_PARAM -AT_SETPARAM -AT_DELEGATE -PUBLIC -PRIVATE -PROTECTED -INTERNAL -ENUM -SEALED -ANNOTATION -DATA -INNER -TAILREC -OPERATOR -INLINE -INFIX -EXTERNAL -SUSPEND -OVERRIDE -ABSTRACT -FINAL -OPEN -CONST -LATEINIT -VARARG -NOINLINE -CROSSINLINE -REIFIED -EXPECT -ACTUAL -QUOTE_OPEN -TRIPLE_QUOTE_OPEN -RealLiteral -FloatLiteral -DecDigitOrSeparator -DecDigits -DoubleExponent -DoubleLiteral -LongLiteral -IntegerLiteral -UnicodeDigit -DecDigit -DecDigitNoZero -HexDigitOrSeparator -HexLiteral -HexDigit -BinDigitOrSeparator -BinLiteral -BinDigit -BooleanLiteral -NullLiteral -Identifier -IdentifierOrSoftKey -IdentifierAt -FieldIdentifier -CharacterLiteral -EscapeSeq -UniCharacterLiteral -EscapedIdentifier -Letter -ErrorCharacter -UNICODE_CLASS_LL -UNICODE_CLASS_LM -UNICODE_CLASS_LO -UNICODE_CLASS_LT -UNICODE_CLASS_LU -UNICODE_CLASS_ND -UNICODE_CLASS_NL -Inside_RPAREN -Inside_RSQUARE -Inside_LPAREN -Inside_LSQUARE -Inside_LCURL -Inside_RCURL -Inside_DOT -Inside_COMMA -Inside_MULT -Inside_MOD -Inside_DIV -Inside_ADD -Inside_SUB -Inside_INCR -Inside_DECR -Inside_CONJ -Inside_DISJ -Inside_EXCL_WS -Inside_EXCL_NO_WS -Inside_COLON -Inside_SEMICOLON -Inside_ASSIGNMENT -Inside_ADD_ASSIGNMENT -Inside_SUB_ASSIGNMENT -Inside_MULT_ASSIGNMENT -Inside_DIV_ASSIGNMENT -Inside_MOD_ASSIGNMENT -Inside_ARROW -Inside_DOUBLE_ARROW -Inside_RANGE -Inside_RESERVED -Inside_COLONCOLON -Inside_DOUBLE_SEMICOLON -Inside_HASH -Inside_AT -Inside_QUEST_WS -Inside_QUEST_NO_WS -Inside_LANGLE -Inside_RANGLE -Inside_LE -Inside_GE -Inside_EXCL_EQ -Inside_EXCL_EQEQ -Inside_IS -Inside_NOT_IS -Inside_NOT_IN -Inside_AS -Inside_AS_SAFE -Inside_EQEQ -Inside_EQEQEQ -Inside_SINGLE_QUOTE -Inside_QUOTE_OPEN -Inside_TRIPLE_QUOTE_OPEN -Inside_VAL -Inside_VAR -Inside_FUN -Inside_OBJECT -Inside_SUPER -Inside_IN -Inside_OUT -Inside_AT_FIELD -Inside_AT_FILE -Inside_AT_PROPERTY -Inside_AT_GET -Inside_AT_SET -Inside_AT_RECEIVER -Inside_AT_PARAM -Inside_AT_SETPARAM -Inside_AT_DELEGATE -Inside_THROW -Inside_RETURN -Inside_CONTINUE -Inside_BREAK -Inside_RETURN_AT -Inside_CONTINUE_AT -Inside_BREAK_AT -Inside_IF -Inside_ELSE -Inside_WHEN -Inside_TRY -Inside_CATCH -Inside_FINALLY -Inside_FOR -Inside_DO -Inside_WHILE -Inside_PUBLIC -Inside_PRIVATE -Inside_PROTECTED -Inside_INTERNAL -Inside_ENUM -Inside_SEALED -Inside_ANNOTATION -Inside_DATA -Inside_INNER -Inside_TAILREC -Inside_OPERATOR -Inside_INLINE -Inside_INFIX -Inside_EXTERNAL -Inside_SUSPEND -Inside_OVERRIDE -Inside_ABSTRACT -Inside_FINAL -Inside_OPEN -Inside_CONST -Inside_LATEINIT -Inside_VARARG -Inside_NOINLINE -Inside_CROSSINLINE -Inside_REIFIED -Inside_EXPECT -Inside_ACTUAL -Inside_BooleanLiteral -Inside_IntegerLiteral -Inside_HexLiteral -Inside_BinLiteral -Inside_CharacterLiteral -Inside_RealLiteral -Inside_NullLiteral -Inside_LongLiteral -Inside_Identifier -Inside_IdentifierAt -Inside_Comment -Inside_WS -Inside_NL -QUOTE_CLOSE -LineStrRef -LineStrText -LineStrEscapedChar -LineStrExprStart -TRIPLE_QUOTE_CLOSE -MultiLineStringQuote -MultiLineStrRef -MultiLineStrText -MultiLineStrExprStart -MultiLineNL - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE -Inside -LineString -MultiLineString - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 171, 2198, 8, 1, 8, 1, 8, 1, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223, 4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228, 9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232, 4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237, 9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241, 4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 4, 246, 9, 246, 4, 247, 9, 247, 4, 248, 9, 248, 4, 249, 9, 249, 4, 250, 9, 250, 4, 251, 9, 251, 4, 252, 9, 252, 4, 253, 9, 253, 4, 254, 9, 254, 4, 255, 9, 255, 4, 256, 9, 256, 4, 257, 9, 257, 4, 258, 9, 258, 4, 259, 9, 259, 4, 260, 9, 260, 4, 261, 9, 261, 4, 262, 9, 262, 4, 263, 9, 263, 4, 264, 9, 264, 4, 265, 9, 265, 4, 266, 9, 266, 4, 267, 9, 267, 4, 268, 9, 268, 4, 269, 9, 269, 4, 270, 9, 270, 4, 271, 9, 271, 4, 272, 9, 272, 4, 273, 9, 273, 4, 274, 9, 274, 4, 275, 9, 275, 4, 276, 9, 276, 4, 277, 9, 277, 4, 278, 9, 278, 4, 279, 9, 279, 4, 280, 9, 280, 4, 281, 9, 281, 4, 282, 9, 282, 4, 283, 9, 283, 4, 284, 9, 284, 4, 285, 9, 285, 4, 286, 9, 286, 4, 287, 9, 287, 4, 288, 9, 288, 4, 289, 9, 289, 4, 290, 9, 290, 4, 291, 9, 291, 4, 292, 9, 292, 4, 293, 9, 293, 4, 294, 9, 294, 4, 295, 9, 295, 4, 296, 9, 296, 4, 297, 9, 297, 4, 298, 9, 298, 4, 299, 9, 299, 4, 300, 9, 300, 4, 301, 9, 301, 4, 302, 9, 302, 4, 303, 9, 303, 4, 304, 9, 304, 4, 305, 9, 305, 4, 306, 9, 306, 4, 307, 9, 307, 4, 308, 9, 308, 4, 309, 9, 309, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 627, 10, 2, 12, 2, 14, 2, 630, 11, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 637, 10, 3, 12, 3, 14, 3, 640, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 651, 10, 4, 12, 4, 14, 4, 654, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 5, 6, 665, 10, 6, 5, 6, 667, 10, 6, 3, 7, 3, 7, 3, 7, 5, 7, 672, 10, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 5, 43, 776, 10, 43, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 5, 94, 1062, 10, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 5, 95, 1070, 10, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 5, 138, 1383, 10, 138, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 5, 139, 1391, 10, 139, 3, 140, 3, 140, 5, 140, 1395, 10, 140, 3, 141, 3, 141, 7, 141, 1399, 10, 141, 12, 141, 14, 141, 1402, 11, 141, 3, 141, 3, 141, 3, 141, 5, 141, 1407, 10, 141, 3, 142, 3, 142, 5, 142, 1411, 10, 142, 3, 142, 3, 142, 3, 143, 5, 143, 1416, 10, 143, 3, 143, 3, 143, 3, 143, 5, 143, 1421, 10, 143, 3, 143, 3, 143, 3, 143, 5, 143, 1426, 10, 143, 3, 144, 3, 144, 3, 144, 5, 144, 1431, 10, 144, 3, 144, 3, 144, 3, 145, 3, 145, 7, 145, 1437, 10, 145, 12, 145, 14, 145, 1440, 11, 145, 3, 145, 3, 145, 3, 145, 5, 145, 1445, 10, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 148, 3, 148, 3, 149, 3, 149, 5, 149, 1455, 10, 149, 3, 150, 3, 150, 3, 150, 3, 150, 7, 150, 1461, 10, 150, 12, 150, 14, 150, 1464, 11, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 1471, 10, 150, 3, 151, 3, 151, 3, 152, 3, 152, 5, 152, 1477, 10, 152, 3, 153, 3, 153, 3, 153, 3, 153, 7, 153, 1483, 10, 153, 12, 153, 14, 153, 1486, 11, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1493, 10, 153, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 1506, 10, 155, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 5, 157, 1515, 10, 157, 3, 157, 3, 157, 3, 157, 7, 157, 1520, 10, 157, 12, 157, 14, 157, 1523, 11, 157, 3, 157, 3, 157, 6, 157, 1527, 10, 157, 13, 157, 14, 157, 1528, 3, 157, 5, 157, 1532, 10, 157, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 5, 158, 1574, 10, 158, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 5, 161, 1585, 10, 161, 3, 161, 3, 161, 3, 162, 3, 162, 5, 162, 1591, 10, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 5, 165, 1609, 10, 165, 3, 166, 3, 166, 3, 167, 3, 167, 3, 168, 3, 168, 3, 169, 3, 169, 3, 170, 3, 170, 3, 171, 3, 171, 3, 172, 3, 172, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 182, 3, 182, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 3, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 5, 191, 1704, 10, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 3, 204, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 208, 3, 208, 3, 209, 3, 209, 3, 209, 5, 209, 1779, 10, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 3, 212, 3, 213, 3, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 215, 3, 215, 3, 216, 3, 216, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 3, 218, 3, 218, 3, 218, 3, 218, 3, 219, 3, 219, 3, 219, 3, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 221, 3, 221, 3, 221, 3, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 224, 3, 224, 3, 224, 3, 224, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 230, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 3, 231, 3, 231, 3, 232, 3, 232, 3, 232, 3, 232, 3, 233, 3, 233, 3, 233, 3, 233, 3, 234, 3, 234, 3, 234, 3, 234, 3, 235, 3, 235, 3, 235, 3, 235, 3, 236, 3, 236, 3, 236, 3, 236, 3, 237, 3, 237, 3, 237, 3, 237, 3, 238, 3, 238, 3, 238, 3, 238, 3, 239, 3, 239, 3, 239, 3, 239, 3, 240, 3, 240, 3, 240, 3, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 242, 3, 242, 3, 242, 3, 242, 3, 243, 3, 243, 3, 243, 3, 243, 3, 244, 3, 244, 3, 244, 3, 244, 3, 245, 3, 245, 3, 245, 3, 245, 3, 246, 3, 246, 3, 246, 3, 246, 3, 247, 3, 247, 3, 247, 3, 247, 3, 248, 3, 248, 3, 248, 3, 248, 3, 249, 3, 249, 3, 249, 3, 249, 3, 250, 3, 250, 3, 250, 3, 250, 3, 251, 3, 251, 3, 251, 3, 251, 3, 252, 3, 252, 3, 252, 3, 252, 3, 253, 3, 253, 3, 253, 3, 253, 3, 254, 3, 254, 3, 254, 3, 254, 3, 255, 3, 255, 3, 255, 3, 255, 3, 256, 3, 256, 3, 256, 3, 256, 3, 257, 3, 257, 3, 257, 3, 257, 3, 258, 3, 258, 3, 258, 3, 258, 3, 259, 3, 259, 3, 259, 3, 259, 3, 260, 3, 260, 3, 260, 3, 260, 3, 261, 3, 261, 3, 261, 3, 261, 3, 262, 3, 262, 3, 262, 3, 262, 3, 263, 3, 263, 3, 263, 3, 263, 3, 264, 3, 264, 3, 264, 3, 264, 3, 265, 3, 265, 3, 265, 3, 265, 3, 266, 3, 266, 3, 266, 3, 266, 3, 267, 3, 267, 3, 267, 3, 267, 3, 268, 3, 268, 3, 268, 3, 268, 3, 269, 3, 269, 3, 269, 3, 269, 3, 270, 3, 270, 3, 270, 3, 270, 3, 271, 3, 271, 3, 271, 3, 271, 3, 272, 3, 272, 3, 272, 3, 272, 3, 273, 3, 273, 3, 273, 3, 273, 3, 274, 3, 274, 3, 274, 3, 274, 3, 275, 3, 275, 3, 275, 3, 275, 3, 276, 3, 276, 3, 276, 3, 276, 3, 277, 3, 277, 3, 277, 3, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 279, 3, 279, 3, 279, 3, 279, 3, 280, 3, 280, 3, 280, 3, 280, 3, 281, 3, 281, 3, 281, 3, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 283, 3, 283, 3, 283, 3, 283, 3, 284, 3, 284, 3, 284, 3, 284, 3, 285, 3, 285, 3, 285, 3, 285, 3, 286, 3, 286, 3, 286, 3, 286, 3, 287, 3, 287, 3, 287, 3, 287, 3, 288, 3, 288, 3, 288, 3, 288, 3, 289, 3, 289, 3, 289, 3, 289, 3, 290, 3, 290, 3, 290, 3, 290, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 3, 292, 3, 292, 3, 292, 3, 293, 3, 293, 3, 293, 3, 293, 3, 294, 3, 294, 3, 294, 3, 294, 3, 295, 3, 295, 3, 295, 3, 295, 3, 296, 3, 296, 5, 296, 2131, 10, 296, 3, 296, 3, 296, 3, 297, 3, 297, 3, 297, 3, 297, 3, 298, 3, 298, 3, 298, 3, 298, 3, 299, 3, 299, 3, 299, 3, 299, 3, 300, 3, 300, 3, 301, 6, 301, 2150, 10, 301, 13, 301, 14, 301, 2151, 3, 301, 5, 301, 2155, 10, 301, 3, 302, 3, 302, 5, 302, 2159, 10, 302, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 304, 5, 304, 2167, 10, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 305, 6, 305, 2176, 10, 305, 13, 305, 14, 305, 2177, 3, 306, 3, 306, 3, 307, 6, 307, 2183, 10, 307, 13, 307, 14, 307, 2184, 3, 307, 5, 307, 2188, 10, 307, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 309, 3, 309, 3, 309, 3, 309, 3, 638, 2, 310, 6, 3, 8, 4, 10, 5, 12, 6, 14, 7, 16, 2, 18, 8, 20, 9, 22, 10, 24, 11, 26, 12, 28, 13, 30, 14, 32, 15, 34, 16, 36, 17, 38, 18, 40, 19, 42, 20, 44, 21, 46, 22, 48, 23, 50, 24, 52, 25, 54, 26, 56, 27, 58, 28, 60, 29, 62, 30, 64, 31, 66, 32, 68, 33, 70, 34, 72, 35, 74, 36, 76, 37, 78, 38, 80, 39, 82, 40, 84, 41, 86, 42, 88, 43, 90, 44, 92, 45, 94, 46, 96, 47, 98, 48, 100, 49, 102, 50, 104, 51, 106, 52, 108, 53, 110, 54, 112, 55, 114, 56, 116, 57, 118, 58, 120, 59, 122, 60, 124, 61, 126, 62, 128, 63, 130, 64, 132, 65, 134, 66, 136, 67, 138, 68, 140, 69, 142, 70, 144, 71, 146, 72, 148, 73, 150, 74, 152, 75, 154, 76, 156, 77, 158, 78, 160, 79, 162, 80, 164, 81, 166, 82, 168, 83, 170, 84, 172, 85, 174, 86, 176, 87, 178, 88, 180, 89, 182, 90, 184, 91, 186, 92, 188, 93, 190, 94, 192, 95, 194, 96, 196, 97, 198, 98, 200, 99, 202, 100, 204, 101, 206, 102, 208, 103, 210, 104, 212, 105, 214, 106, 216, 107, 218, 108, 220, 109, 222, 110, 224, 111, 226, 112, 228, 113, 230, 114, 232, 115, 234, 116, 236, 117, 238, 118, 240, 119, 242, 120, 244, 121, 246, 122, 248, 123, 250, 124, 252, 125, 254, 126, 256, 127, 258, 128, 260, 129, 262, 130, 264, 131, 266, 132, 268, 133, 270, 134, 272, 135, 274, 136, 276, 137, 278, 138, 280, 139, 282, 2, 284, 2, 286, 2, 288, 140, 290, 141, 292, 142, 294, 2, 296, 2, 298, 2, 300, 2, 302, 143, 304, 2, 306, 2, 308, 144, 310, 2, 312, 145, 314, 146, 316, 147, 318, 2, 320, 148, 322, 149, 324, 150, 326, 2, 328, 2, 330, 2, 332, 2, 334, 151, 336, 152, 338, 153, 340, 154, 342, 155, 344, 156, 346, 157, 348, 158, 350, 2, 352, 2, 354, 2, 356, 2, 358, 2, 360, 2, 362, 2, 364, 2, 366, 2, 368, 2, 370, 2, 372, 2, 374, 2, 376, 2, 378, 2, 380, 2, 382, 2, 384, 2, 386, 2, 388, 2, 390, 2, 392, 2, 394, 2, 396, 2, 398, 2, 400, 2, 402, 2, 404, 2, 406, 2, 408, 2, 410, 2, 412, 2, 414, 2, 416, 2, 418, 2, 420, 2, 422, 2, 424, 2, 426, 2, 428, 2, 430, 2, 432, 2, 434, 2, 436, 2, 438, 2, 440, 2, 442, 2, 444, 2, 446, 2, 448, 2, 450, 2, 452, 2, 454, 2, 456, 2, 458, 2, 460, 2, 462, 2, 464, 2, 466, 2, 468, 2, 470, 2, 472, 2, 474, 2, 476, 2, 478, 2, 480, 2, 482, 2, 484, 2, 486, 2, 488, 2, 490, 2, 492, 2, 494, 2, 496, 2, 498, 2, 500, 2, 502, 2, 504, 2, 506, 2, 508, 2, 510, 2, 512, 2, 514, 2, 516, 2, 518, 2, 520, 2, 522, 2, 524, 2, 526, 2, 528, 2, 530, 2, 532, 2, 534, 2, 536, 2, 538, 2, 540, 2, 542, 2, 544, 2, 546, 2, 548, 2, 550, 2, 552, 2, 554, 2, 556, 2, 558, 2, 560, 2, 562, 2, 564, 2, 566, 2, 568, 2, 570, 2, 572, 2, 574, 2, 576, 2, 578, 2, 580, 2, 582, 2, 584, 2, 586, 2, 588, 2, 590, 2, 592, 2, 594, 159, 596, 160, 598, 161, 600, 162, 602, 163, 604, 164, 606, 165, 608, 166, 610, 167, 612, 168, 614, 169, 616, 170, 618, 171, 620, 2, 6, 2, 3, 4, 5, 23, 4, 2, 12, 12, 15, 15, 5, 2, 11, 11, 14, 14, 34, 34, 4, 2, 72, 72, 104, 104, 4, 2, 71, 71, 103, 103, 4, 2, 45, 45, 47, 47, 4, 2, 90, 90, 122, 122, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 9, 2, 12, 12, 15, 15, 62, 62, 64, 64, 93, 93, 95, 95, 98, 98, 6, 2, 12, 12, 15, 15, 41, 41, 94, 94, 10, 2, 36, 36, 38, 38, 41, 41, 94, 94, 100, 100, 112, 112, 116, 116, 118, 118, 584, 2, 99, 124, 183, 183, 225, 248, 250, 257, 259, 259, 261, 261, 263, 263, 265, 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279, 281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, 295, 297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, 311, 311, 313, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, 326, 328, 328, 330, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, 343, 343, 345, 345, 347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, 357, 359, 359, 361, 361, 363, 363, 365, 365, 367, 367, 369, 369, 371, 371, 373, 373, 375, 375, 377, 377, 380, 380, 382, 382, 384, 386, 389, 389, 391, 391, 394, 394, 398, 399, 404, 404, 407, 407, 411, 413, 416, 416, 419, 419, 421, 421, 423, 423, 426, 426, 428, 429, 431, 431, 434, 434, 438, 438, 440, 440, 443, 444, 447, 449, 456, 456, 459, 459, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 478, 479, 481, 481, 483, 483, 485, 485, 487, 487, 489, 489, 491, 491, 493, 493, 495, 495, 497, 498, 501, 501, 503, 503, 507, 507, 509, 509, 511, 511, 513, 513, 515, 515, 517, 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527, 529, 529, 531, 531, 533, 533, 535, 535, 537, 537, 539, 539, 541, 541, 543, 543, 545, 545, 547, 547, 549, 549, 551, 551, 553, 553, 555, 555, 557, 557, 559, 559, 561, 561, 563, 563, 565, 571, 574, 574, 577, 578, 580, 580, 585, 585, 587, 587, 589, 589, 591, 591, 593, 661, 663, 689, 883, 883, 885, 885, 889, 889, 893, 895, 914, 914, 942, 976, 978, 979, 983, 985, 987, 987, 989, 989, 991, 991, 993, 993, 995, 995, 997, 997, 999, 999, 1001, 1001, 1003, 1003, 1005, 1005, 1007, 1007, 1009, 1013, 1015, 1015, 1018, 1018, 1021, 1022, 1074, 1121, 1123, 1123, 1125, 1125, 1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, 1135, 1135, 1137, 1137, 1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, 1147, 1147, 1149, 1149, 1151, 1151, 1153, 1153, 1155, 1155, 1165, 1165, 1167, 1167, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175, 1177, 1177, 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187, 1189, 1189, 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199, 1201, 1201, 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211, 1213, 1213, 1215, 1215, 1217, 1217, 1220, 1220, 1222, 1222, 1224, 1224, 1226, 1226, 1228, 1228, 1230, 1230, 1232, 1233, 1235, 1235, 1237, 1237, 1239, 1239, 1241, 1241, 1243, 1243, 1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, 1253, 1253, 1255, 1255, 1257, 1257, 1259, 1259, 1261, 1261, 1263, 1263, 1265, 1265, 1267, 1267, 1269, 1269, 1271, 1271, 1273, 1273, 1275, 1275, 1277, 1277, 1279, 1279, 1281, 1281, 1283, 1283, 1285, 1285, 1287, 1287, 1289, 1289, 1291, 1291, 1293, 1293, 1295, 1295, 1297, 1297, 1299, 1299, 1301, 1301, 1303, 1303, 1305, 1305, 1307, 1307, 1309, 1309, 1311, 1311, 1313, 1313, 1315, 1315, 1317, 1317, 1319, 1319, 1321, 1321, 1379, 1417, 7426, 7469, 7533, 7545, 7547, 7580, 7683, 7683, 7685, 7685, 7687, 7687, 7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699, 7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711, 7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723, 7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735, 7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747, 7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759, 7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771, 7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783, 7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795, 7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807, 7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819, 7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7829, 7831, 7839, 7841, 7841, 7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, 7853, 7853, 7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, 7865, 7865, 7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, 7877, 7877, 7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, 7889, 7889, 7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, 7901, 7901, 7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, 7913, 7913, 7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, 7925, 7925, 7927, 7927, 7929, 7929, 7931, 7931, 7933, 7933, 7935, 7935, 7937, 7945, 7954, 7959, 7970, 7977, 7986, 7993, 8002, 8007, 8018, 8025, 8034, 8041, 8050, 8063, 8066, 8073, 8082, 8089, 8098, 8105, 8114, 8118, 8120, 8121, 8128, 8128, 8132, 8134, 8136, 8137, 8146, 8149, 8152, 8153, 8162, 8169, 8180, 8182, 8184, 8185, 8460, 8460, 8464, 8465, 8469, 8469, 8497, 8497, 8502, 8502, 8507, 8507, 8510, 8511, 8520, 8523, 8528, 8528, 8582, 8582, 11314, 11360, 11363, 11363, 11367, 11368, 11370, 11370, 11372, 11372, 11374, 11374, 11379, 11379, 11381, 11382, 11384, 11389, 11395, 11395, 11397, 11397, 11399, 11399, 11401, 11401, 11403, 11403, 11405, 11405, 11407, 11407, 11409, 11409, 11411, 11411, 11413, 11413, 11415, 11415, 11417, 11417, 11419, 11419, 11421, 11421, 11423, 11423, 11425, 11425, 11427, 11427, 11429, 11429, 11431, 11431, 11433, 11433, 11435, 11435, 11437, 11437, 11439, 11439, 11441, 11441, 11443, 11443, 11445, 11445, 11447, 11447, 11449, 11449, 11451, 11451, 11453, 11453, 11455, 11455, 11457, 11457, 11459, 11459, 11461, 11461, 11463, 11463, 11465, 11465, 11467, 11467, 11469, 11469, 11471, 11471, 11473, 11473, 11475, 11475, 11477, 11477, 11479, 11479, 11481, 11481, 11483, 11483, 11485, 11485, 11487, 11487, 11489, 11489, 11491, 11491, 11493, 11494, 11502, 11502, 11504, 11504, 11509, 11509, 11522, 11559, 11561, 11561, 11567, 11567, 42563, 42563, 42565, 42565, 42567, 42567, 42569, 42569, 42571, 42571, 42573, 42573, 42575, 42575, 42577, 42577, 42579, 42579, 42581, 42581, 42583, 42583, 42585, 42585, 42587, 42587, 42589, 42589, 42591, 42591, 42593, 42593, 42595, 42595, 42597, 42597, 42599, 42599, 42601, 42601, 42603, 42603, 42605, 42605, 42607, 42607, 42627, 42627, 42629, 42629, 42631, 42631, 42633, 42633, 42635, 42635, 42637, 42637, 42639, 42639, 42641, 42641, 42643, 42643, 42645, 42645, 42647, 42647, 42649, 42649, 42789, 42789, 42791, 42791, 42793, 42793, 42795, 42795, 42797, 42797, 42799, 42799, 42801, 42803, 42805, 42805, 42807, 42807, 42809, 42809, 42811, 42811, 42813, 42813, 42815, 42815, 42817, 42817, 42819, 42819, 42821, 42821, 42823, 42823, 42825, 42825, 42827, 42827, 42829, 42829, 42831, 42831, 42833, 42833, 42835, 42835, 42837, 42837, 42839, 42839, 42841, 42841, 42843, 42843, 42845, 42845, 42847, 42847, 42849, 42849, 42851, 42851, 42853, 42853, 42855, 42855, 42857, 42857, 42859, 42859, 42861, 42861, 42863, 42863, 42865, 42865, 42867, 42874, 42876, 42876, 42878, 42878, 42881, 42881, 42883, 42883, 42885, 42885, 42887, 42887, 42889, 42889, 42894, 42894, 42896, 42896, 42899, 42899, 42901, 42901, 42915, 42915, 42917, 42917, 42919, 42919, 42921, 42921, 42923, 42923, 43004, 43004, 64258, 64264, 64277, 64281, 65347, 65372, 53, 2, 690, 707, 712, 723, 738, 742, 750, 750, 752, 752, 886, 886, 892, 892, 1371, 1371, 1602, 1602, 1767, 1768, 2038, 2039, 2044, 2044, 2076, 2076, 2086, 2086, 2090, 2090, 2419, 2419, 3656, 3656, 3784, 3784, 4350, 4350, 6105, 6105, 6213, 6213, 6825, 6825, 7290, 7295, 7470, 7532, 7546, 7546, 7581, 7617, 8307, 8307, 8321, 8321, 8338, 8350, 11390, 11391, 11633, 11633, 11825, 11825, 12295, 12295, 12339, 12343, 12349, 12349, 12447, 12448, 12542, 12544, 40983, 40983, 42234, 42239, 42510, 42510, 42625, 42625, 42777, 42785, 42866, 42866, 42890, 42890, 43002, 43003, 43473, 43473, 43634, 43634, 43743, 43743, 43765, 43766, 65394, 65394, 65440, 65441, 289, 2, 172, 172, 188, 188, 445, 445, 450, 453, 662, 662, 1490, 1516, 1522, 1524, 1570, 1601, 1603, 1612, 1648, 1649, 1651, 1749, 1751, 1751, 1776, 1777, 1788, 1790, 1793, 1793, 1810, 1810, 1812, 1841, 1871, 1959, 1971, 1971, 1996, 2028, 2050, 2071, 2114, 2138, 2210, 2210, 2212, 2222, 2310, 2363, 2367, 2367, 2386, 2386, 2394, 2403, 2420, 2425, 2427, 2433, 2439, 2446, 2449, 2450, 2453, 2474, 2476, 2482, 2484, 2484, 2488, 2491, 2495, 2495, 2512, 2512, 2526, 2527, 2529, 2531, 2546, 2547, 2567, 2572, 2577, 2578, 2581, 2602, 2604, 2610, 2612, 2613, 2615, 2616, 2618, 2619, 2651, 2654, 2656, 2656, 2676, 2678, 2695, 2703, 2705, 2707, 2709, 2730, 2732, 2738, 2740, 2741, 2743, 2747, 2751, 2751, 2770, 2770, 2786, 2787, 2823, 2830, 2833, 2834, 2837, 2858, 2860, 2866, 2868, 2869, 2871, 2875, 2879, 2879, 2910, 2911, 2913, 2915, 2931, 2931, 2949, 2949, 2951, 2956, 2960, 2962, 2964, 2967, 2971, 2972, 2974, 2974, 2976, 2977, 2981, 2982, 2986, 2988, 2992, 3003, 3026, 3026, 3079, 3086, 3088, 3090, 3092, 3114, 3116, 3125, 3127, 3131, 3135, 3135, 3162, 3163, 3170, 3171, 3207, 3214, 3216, 3218, 3220, 3242, 3244, 3253, 3255, 3259, 3263, 3263, 3296, 3296, 3298, 3299, 3315, 3316, 3335, 3342, 3344, 3346, 3348, 3388, 3391, 3391, 3408, 3408, 3426, 3427, 3452, 3457, 3463, 3480, 3484, 3507, 3509, 3517, 3519, 3519, 3522, 3528, 3587, 3634, 3636, 3637, 3650, 3655, 3715, 3716, 3718, 3718, 3721, 3722, 3724, 3724, 3727, 3727, 3734, 3737, 3739, 3745, 3747, 3749, 3751, 3751, 3753, 3753, 3756, 3757, 3759, 3762, 3764, 3765, 3775, 3775, 3778, 3782, 3806, 3809, 3842, 3842, 3906, 3913, 3915, 3950, 3978, 3982, 4098, 4140, 4161, 4161, 4178, 4183, 4188, 4191, 4195, 4195, 4199, 4200, 4208, 4210, 4215, 4227, 4240, 4240, 4306, 4348, 4351, 4682, 4684, 4687, 4690, 4696, 4698, 4698, 4700, 4703, 4706, 4746, 4748, 4751, 4754, 4786, 4788, 4791, 4794, 4800, 4802, 4802, 4804, 4807, 4810, 4824, 4826, 4882, 4884, 4887, 4890, 4956, 4994, 5009, 5026, 5110, 5123, 5742, 5745, 5761, 5763, 5788, 5794, 5868, 5890, 5902, 5904, 5907, 5922, 5939, 5954, 5971, 5986, 5998, 6000, 6002, 6018, 6069, 6110, 6110, 6178, 6212, 6214, 6265, 6274, 6314, 6316, 6316, 6322, 6391, 6402, 6430, 6482, 6511, 6514, 6518, 6530, 6573, 6595, 6601, 6658, 6680, 6690, 6742, 6919, 6965, 6983, 6989, 7045, 7074, 7088, 7089, 7100, 7143, 7170, 7205, 7247, 7249, 7260, 7289, 7403, 7406, 7408, 7411, 7415, 7416, 8503, 8506, 11570, 11625, 11650, 11672, 11682, 11688, 11690, 11696, 11698, 11704, 11706, 11712, 11714, 11720, 11722, 11728, 11730, 11736, 11738, 11744, 12296, 12296, 12350, 12350, 12355, 12440, 12449, 12449, 12451, 12540, 12545, 12545, 12551, 12591, 12595, 12688, 12706, 12732, 12786, 12801, 13314, 19895, 19970, 40910, 40962, 40982, 40984, 42126, 42194, 42233, 42242, 42509, 42514, 42529, 42540, 42541, 42608, 42608, 42658, 42727, 43005, 43011, 43013, 43015, 43017, 43020, 43022, 43044, 43074, 43125, 43140, 43189, 43252, 43257, 43261, 43261, 43276, 43303, 43314, 43336, 43362, 43390, 43398, 43444, 43522, 43562, 43586, 43588, 43590, 43597, 43618, 43633, 43635, 43640, 43644, 43644, 43650, 43697, 43699, 43699, 43703, 43704, 43707, 43711, 43714, 43714, 43716, 43716, 43741, 43742, 43746, 43756, 43764, 43764, 43779, 43784, 43787, 43792, 43795, 43800, 43810, 43816, 43818, 43824, 43970, 44004, 44034, 44034, 55205, 55205, 55218, 55240, 55245, 55293, 63746, 64111, 64114, 64219, 64287, 64287, 64289, 64298, 64300, 64312, 64314, 64318, 64320, 64320, 64322, 64323, 64325, 64326, 64328, 64435, 64469, 64831, 64850, 64913, 64916, 64969, 65010, 65021, 65138, 65142, 65144, 65278, 65384, 65393, 65395, 65439, 65442, 65472, 65476, 65481, 65484, 65489, 65492, 65497, 65500, 65502, 12, 2, 455, 455, 458, 458, 461, 461, 500, 500, 8074, 8081, 8090, 8097, 8106, 8113, 8126, 8126, 8142, 8142, 8190, 8190, 578, 2, 67, 92, 194, 216, 218, 224, 258, 258, 260, 260, 262, 262, 264, 264, 266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, 278, 280, 280, 282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, 294, 294, 296, 296, 298, 298, 300, 300, 302, 302, 304, 304, 306, 306, 308, 308, 310, 310, 312, 312, 315, 315, 317, 317, 319, 319, 321, 321, 323, 323, 325, 325, 327, 327, 329, 329, 332, 332, 334, 334, 336, 336, 338, 338, 340, 340, 342, 342, 344, 344, 346, 346, 348, 348, 350, 350, 352, 352, 354, 354, 356, 356, 358, 358, 360, 360, 362, 362, 364, 364, 366, 366, 368, 368, 370, 370, 372, 372, 374, 374, 376, 376, 378, 379, 381, 381, 383, 383, 387, 388, 390, 390, 392, 393, 395, 397, 400, 403, 405, 406, 408, 410, 414, 415, 417, 418, 420, 420, 422, 422, 424, 425, 427, 427, 430, 430, 432, 433, 435, 437, 439, 439, 441, 442, 446, 446, 454, 454, 457, 457, 460, 460, 463, 463, 465, 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 477, 477, 480, 480, 482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 496, 496, 499, 499, 502, 502, 504, 506, 508, 508, 510, 510, 512, 512, 514, 514, 516, 516, 518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, 530, 532, 532, 534, 534, 536, 536, 538, 538, 540, 540, 542, 542, 544, 544, 546, 546, 548, 548, 550, 550, 552, 552, 554, 554, 556, 556, 558, 558, 560, 560, 562, 562, 564, 564, 572, 573, 575, 576, 579, 579, 581, 584, 586, 586, 588, 588, 590, 590, 592, 592, 882, 882, 884, 884, 888, 888, 904, 904, 906, 908, 910, 910, 912, 913, 915, 931, 933, 941, 977, 977, 980, 982, 986, 986, 988, 988, 990, 990, 992, 992, 994, 994, 996, 996, 998, 998, 1000, 1000, 1002, 1002, 1004, 1004, 1006, 1006, 1008, 1008, 1014, 1014, 1017, 1017, 1019, 1020, 1023, 1073, 1122, 1122, 1124, 1124, 1126, 1126, 1128, 1128, 1130, 1130, 1132, 1132, 1134, 1134, 1136, 1136, 1138, 1138, 1140, 1140, 1142, 1142, 1144, 1144, 1146, 1146, 1148, 1148, 1150, 1150, 1152, 1152, 1154, 1154, 1164, 1164, 1166, 1166, 1168, 1168, 1170, 1170, 1172, 1172, 1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184, 1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196, 1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208, 1210, 1210, 1212, 1212, 1214, 1214, 1216, 1216, 1218, 1219, 1221, 1221, 1223, 1223, 1225, 1225, 1227, 1227, 1229, 1229, 1231, 1231, 1234, 1234, 1236, 1236, 1238, 1238, 1240, 1240, 1242, 1242, 1244, 1244, 1246, 1246, 1248, 1248, 1250, 1250, 1252, 1252, 1254, 1254, 1256, 1256, 1258, 1258, 1260, 1260, 1262, 1262, 1264, 1264, 1266, 1266, 1268, 1268, 1270, 1270, 1272, 1272, 1274, 1274, 1276, 1276, 1278, 1278, 1280, 1280, 1282, 1282, 1284, 1284, 1286, 1286, 1288, 1288, 1290, 1290, 1292, 1292, 1294, 1294, 1296, 1296, 1298, 1298, 1300, 1300, 1302, 1302, 1304, 1304, 1306, 1306, 1308, 1308, 1310, 1310, 1312, 1312, 1314, 1314, 1316, 1316, 1318, 1318, 1320, 1320, 1331, 1368, 4258, 4295, 4297, 4297, 4303, 4303, 7682, 7682, 7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694, 7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706, 7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718, 7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730, 7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742, 7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754, 7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766, 7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778, 7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790, 7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802, 7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814, 7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826, 7828, 7828, 7830, 7830, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, 7848, 7848, 7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, 7860, 7860, 7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, 7872, 7872, 7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, 7884, 7884, 7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, 7896, 7896, 7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, 7908, 7908, 7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, 7920, 7920, 7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7930, 7930, 7932, 7932, 7934, 7934, 7936, 7936, 7946, 7953, 7962, 7967, 7978, 7985, 7994, 8001, 8010, 8015, 8027, 8027, 8029, 8029, 8031, 8031, 8033, 8033, 8042, 8049, 8122, 8125, 8138, 8141, 8154, 8157, 8170, 8174, 8186, 8189, 8452, 8452, 8457, 8457, 8461, 8463, 8466, 8468, 8471, 8471, 8475, 8479, 8486, 8486, 8488, 8488, 8490, 8490, 8492, 8495, 8498, 8501, 8512, 8513, 8519, 8519, 8581, 8581, 11266, 11312, 11362, 11362, 11364, 11366, 11369, 11369, 11371, 11371, 11373, 11373, 11375, 11378, 11380, 11380, 11383, 11383, 11392, 11394, 11396, 11396, 11398, 11398, 11400, 11400, 11402, 11402, 11404, 11404, 11406, 11406, 11408, 11408, 11410, 11410, 11412, 11412, 11414, 11414, 11416, 11416, 11418, 11418, 11420, 11420, 11422, 11422, 11424, 11424, 11426, 11426, 11428, 11428, 11430, 11430, 11432, 11432, 11434, 11434, 11436, 11436, 11438, 11438, 11440, 11440, 11442, 11442, 11444, 11444, 11446, 11446, 11448, 11448, 11450, 11450, 11452, 11452, 11454, 11454, 11456, 11456, 11458, 11458, 11460, 11460, 11462, 11462, 11464, 11464, 11466, 11466, 11468, 11468, 11470, 11470, 11472, 11472, 11474, 11474, 11476, 11476, 11478, 11478, 11480, 11480, 11482, 11482, 11484, 11484, 11486, 11486, 11488, 11488, 11490, 11490, 11492, 11492, 11501, 11501, 11503, 11503, 11508, 11508, 42562, 42562, 42564, 42564, 42566, 42566, 42568, 42568, 42570, 42570, 42572, 42572, 42574, 42574, 42576, 42576, 42578, 42578, 42580, 42580, 42582, 42582, 42584, 42584, 42586, 42586, 42588, 42588, 42590, 42590, 42592, 42592, 42594, 42594, 42596, 42596, 42598, 42598, 42600, 42600, 42602, 42602, 42604, 42604, 42606, 42606, 42626, 42626, 42628, 42628, 42630, 42630, 42632, 42632, 42634, 42634, 42636, 42636, 42638, 42638, 42640, 42640, 42642, 42642, 42644, 42644, 42646, 42646, 42648, 42648, 42788, 42788, 42790, 42790, 42792, 42792, 42794, 42794, 42796, 42796, 42798, 42798, 42800, 42800, 42804, 42804, 42806, 42806, 42808, 42808, 42810, 42810, 42812, 42812, 42814, 42814, 42816, 42816, 42818, 42818, 42820, 42820, 42822, 42822, 42824, 42824, 42826, 42826, 42828, 42828, 42830, 42830, 42832, 42832, 42834, 42834, 42836, 42836, 42838, 42838, 42840, 42840, 42842, 42842, 42844, 42844, 42846, 42846, 42848, 42848, 42850, 42850, 42852, 42852, 42854, 42854, 42856, 42856, 42858, 42858, 42860, 42860, 42862, 42862, 42864, 42864, 42875, 42875, 42877, 42877, 42879, 42880, 42882, 42882, 42884, 42884, 42886, 42886, 42888, 42888, 42893, 42893, 42895, 42895, 42898, 42898, 42900, 42900, 42914, 42914, 42916, 42916, 42918, 42918, 42920, 42920, 42922, 42922, 42924, 42924, 65315, 65340, 37, 2, 50, 59, 1634, 1643, 1778, 1787, 1986, 1995, 2408, 2417, 2536, 2545, 2664, 2673, 2792, 2801, 2920, 2929, 3048, 3057, 3176, 3185, 3304, 3313, 3432, 3441, 3666, 3675, 3794, 3803, 3874, 3883, 4162, 4171, 4242, 4251, 6114, 6123, 6162, 6171, 6472, 6481, 6610, 6619, 6786, 6795, 6802, 6811, 6994, 7003, 7090, 7099, 7234, 7243, 7250, 7259, 42530, 42539, 43218, 43227, 43266, 43275, 43474, 43483, 43602, 43611, 44018, 44027, 65298, 65307, 9, 2, 5872, 5874, 8546, 8580, 8583, 8586, 12297, 12297, 12323, 12331, 12346, 12348, 42728, 42737, 5, 2, 36, 36, 38, 38, 94, 94, 4, 2, 36, 36, 38, 38, 2, 2271, 2, 6, 3, 2, 2, 2, 2, 8, 3, 2, 2, 2, 2, 10, 3, 2, 2, 2, 2, 12, 3, 2, 2, 2, 2, 14, 3, 2, 2, 2, 2, 18, 3, 2, 2, 2, 2, 20, 3, 2, 2, 2, 2, 22, 3, 2, 2, 2, 2, 24, 3, 2, 2, 2, 2, 26, 3, 2, 2, 2, 2, 28, 3, 2, 2, 2, 2, 30, 3, 2, 2, 2, 2, 32, 3, 2, 2, 2, 2, 34, 3, 2, 2, 2, 2, 36, 3, 2, 2, 2, 2, 38, 3, 2, 2, 2, 2, 40, 3, 2, 2, 2, 2, 42, 3, 2, 2, 2, 2, 44, 3, 2, 2, 2, 2, 46, 3, 2, 2, 2, 2, 48, 3, 2, 2, 2, 2, 50, 3, 2, 2, 2, 2, 52, 3, 2, 2, 2, 2, 54, 3, 2, 2, 2, 2, 56, 3, 2, 2, 2, 2, 58, 3, 2, 2, 2, 2, 60, 3, 2, 2, 2, 2, 62, 3, 2, 2, 2, 2, 64, 3, 2, 2, 2, 2, 66, 3, 2, 2, 2, 2, 68, 3, 2, 2, 2, 2, 70, 3, 2, 2, 2, 2, 72, 3, 2, 2, 2, 2, 74, 3, 2, 2, 2, 2, 76, 3, 2, 2, 2, 2, 78, 3, 2, 2, 2, 2, 80, 3, 2, 2, 2, 2, 82, 3, 2, 2, 2, 2, 84, 3, 2, 2, 2, 2, 86, 3, 2, 2, 2, 2, 88, 3, 2, 2, 2, 2, 90, 3, 2, 2, 2, 2, 92, 3, 2, 2, 2, 2, 94, 3, 2, 2, 2, 2, 96, 3, 2, 2, 2, 2, 98, 3, 2, 2, 2, 2, 100, 3, 2, 2, 2, 2, 102, 3, 2, 2, 2, 2, 104, 3, 2, 2, 2, 2, 106, 3, 2, 2, 2, 2, 108, 3, 2, 2, 2, 2, 110, 3, 2, 2, 2, 2, 112, 3, 2, 2, 2, 2, 114, 3, 2, 2, 2, 2, 116, 3, 2, 2, 2, 2, 118, 3, 2, 2, 2, 2, 120, 3, 2, 2, 2, 2, 122, 3, 2, 2, 2, 2, 124, 3, 2, 2, 2, 2, 126, 3, 2, 2, 2, 2, 128, 3, 2, 2, 2, 2, 130, 3, 2, 2, 2, 2, 132, 3, 2, 2, 2, 2, 134, 3, 2, 2, 2, 2, 136, 3, 2, 2, 2, 2, 138, 3, 2, 2, 2, 2, 140, 3, 2, 2, 2, 2, 142, 3, 2, 2, 2, 2, 144, 3, 2, 2, 2, 2, 146, 3, 2, 2, 2, 2, 148, 3, 2, 2, 2, 2, 150, 3, 2, 2, 2, 2, 152, 3, 2, 2, 2, 2, 154, 3, 2, 2, 2, 2, 156, 3, 2, 2, 2, 2, 158, 3, 2, 2, 2, 2, 160, 3, 2, 2, 2, 2, 162, 3, 2, 2, 2, 2, 164, 3, 2, 2, 2, 2, 166, 3, 2, 2, 2, 2, 168, 3, 2, 2, 2, 2, 170, 3, 2, 2, 2, 2, 172, 3, 2, 2, 2, 2, 174, 3, 2, 2, 2, 2, 176, 3, 2, 2, 2, 2, 178, 3, 2, 2, 2, 2, 180, 3, 2, 2, 2, 2, 182, 3, 2, 2, 2, 2, 184, 3, 2, 2, 2, 2, 186, 3, 2, 2, 2, 2, 188, 3, 2, 2, 2, 2, 190, 3, 2, 2, 2, 2, 192, 3, 2, 2, 2, 2, 194, 3, 2, 2, 2, 2, 196, 3, 2, 2, 2, 2, 198, 3, 2, 2, 2, 2, 200, 3, 2, 2, 2, 2, 202, 3, 2, 2, 2, 2, 204, 3, 2, 2, 2, 2, 206, 3, 2, 2, 2, 2, 208, 3, 2, 2, 2, 2, 210, 3, 2, 2, 2, 2, 212, 3, 2, 2, 2, 2, 214, 3, 2, 2, 2, 2, 216, 3, 2, 2, 2, 2, 218, 3, 2, 2, 2, 2, 220, 3, 2, 2, 2, 2, 222, 3, 2, 2, 2, 2, 224, 3, 2, 2, 2, 2, 226, 3, 2, 2, 2, 2, 228, 3, 2, 2, 2, 2, 230, 3, 2, 2, 2, 2, 232, 3, 2, 2, 2, 2, 234, 3, 2, 2, 2, 2, 236, 3, 2, 2, 2, 2, 238, 3, 2, 2, 2, 2, 240, 3, 2, 2, 2, 2, 242, 3, 2, 2, 2, 2, 244, 3, 2, 2, 2, 2, 246, 3, 2, 2, 2, 2, 248, 3, 2, 2, 2, 2, 250, 3, 2, 2, 2, 2, 252, 3, 2, 2, 2, 2, 254, 3, 2, 2, 2, 2, 256, 3, 2, 2, 2, 2, 258, 3, 2, 2, 2, 2, 260, 3, 2, 2, 2, 2, 262, 3, 2, 2, 2, 2, 264, 3, 2, 2, 2, 2, 266, 3, 2, 2, 2, 2, 268, 3, 2, 2, 2, 2, 270, 3, 2, 2, 2, 2, 272, 3, 2, 2, 2, 2, 274, 3, 2, 2, 2, 2, 276, 3, 2, 2, 2, 2, 278, 3, 2, 2, 2, 2, 280, 3, 2, 2, 2, 2, 288, 3, 2, 2, 2, 2, 290, 3, 2, 2, 2, 2, 292, 3, 2, 2, 2, 2, 302, 3, 2, 2, 2, 2, 308, 3, 2, 2, 2, 2, 312, 3, 2, 2, 2, 2, 314, 3, 2, 2, 2, 2, 316, 3, 2, 2, 2, 2, 320, 3, 2, 2, 2, 2, 322, 3, 2, 2, 2, 2, 324, 3, 2, 2, 2, 2, 334, 3, 2, 2, 2, 2, 336, 3, 2, 2, 2, 2, 338, 3, 2, 2, 2, 2, 340, 3, 2, 2, 2, 2, 342, 3, 2, 2, 2, 2, 344, 3, 2, 2, 2, 2, 346, 3, 2, 2, 2, 2, 348, 3, 2, 2, 2, 3, 350, 3, 2, 2, 2, 3, 352, 3, 2, 2, 2, 3, 354, 3, 2, 2, 2, 3, 356, 3, 2, 2, 2, 3, 358, 3, 2, 2, 2, 3, 360, 3, 2, 2, 2, 3, 362, 3, 2, 2, 2, 3, 364, 3, 2, 2, 2, 3, 366, 3, 2, 2, 2, 3, 368, 3, 2, 2, 2, 3, 370, 3, 2, 2, 2, 3, 372, 3, 2, 2, 2, 3, 374, 3, 2, 2, 2, 3, 376, 3, 2, 2, 2, 3, 378, 3, 2, 2, 2, 3, 380, 3, 2, 2, 2, 3, 382, 3, 2, 2, 2, 3, 384, 3, 2, 2, 2, 3, 386, 3, 2, 2, 2, 3, 388, 3, 2, 2, 2, 3, 390, 3, 2, 2, 2, 3, 392, 3, 2, 2, 2, 3, 394, 3, 2, 2, 2, 3, 396, 3, 2, 2, 2, 3, 398, 3, 2, 2, 2, 3, 400, 3, 2, 2, 2, 3, 402, 3, 2, 2, 2, 3, 404, 3, 2, 2, 2, 3, 406, 3, 2, 2, 2, 3, 408, 3, 2, 2, 2, 3, 410, 3, 2, 2, 2, 3, 412, 3, 2, 2, 2, 3, 414, 3, 2, 2, 2, 3, 416, 3, 2, 2, 2, 3, 418, 3, 2, 2, 2, 3, 420, 3, 2, 2, 2, 3, 422, 3, 2, 2, 2, 3, 424, 3, 2, 2, 2, 3, 426, 3, 2, 2, 2, 3, 428, 3, 2, 2, 2, 3, 430, 3, 2, 2, 2, 3, 432, 3, 2, 2, 2, 3, 434, 3, 2, 2, 2, 3, 436, 3, 2, 2, 2, 3, 438, 3, 2, 2, 2, 3, 440, 3, 2, 2, 2, 3, 442, 3, 2, 2, 2, 3, 444, 3, 2, 2, 2, 3, 446, 3, 2, 2, 2, 3, 448, 3, 2, 2, 2, 3, 450, 3, 2, 2, 2, 3, 452, 3, 2, 2, 2, 3, 454, 3, 2, 2, 2, 3, 456, 3, 2, 2, 2, 3, 458, 3, 2, 2, 2, 3, 460, 3, 2, 2, 2, 3, 462, 3, 2, 2, 2, 3, 464, 3, 2, 2, 2, 3, 466, 3, 2, 2, 2, 3, 468, 3, 2, 2, 2, 3, 470, 3, 2, 2, 2, 3, 472, 3, 2, 2, 2, 3, 474, 3, 2, 2, 2, 3, 476, 3, 2, 2, 2, 3, 478, 3, 2, 2, 2, 3, 480, 3, 2, 2, 2, 3, 482, 3, 2, 2, 2, 3, 484, 3, 2, 2, 2, 3, 486, 3, 2, 2, 2, 3, 488, 3, 2, 2, 2, 3, 490, 3, 2, 2, 2, 3, 492, 3, 2, 2, 2, 3, 494, 3, 2, 2, 2, 3, 496, 3, 2, 2, 2, 3, 498, 3, 2, 2, 2, 3, 500, 3, 2, 2, 2, 3, 502, 3, 2, 2, 2, 3, 504, 3, 2, 2, 2, 3, 506, 3, 2, 2, 2, 3, 508, 3, 2, 2, 2, 3, 510, 3, 2, 2, 2, 3, 512, 3, 2, 2, 2, 3, 514, 3, 2, 2, 2, 3, 516, 3, 2, 2, 2, 3, 518, 3, 2, 2, 2, 3, 520, 3, 2, 2, 2, 3, 522, 3, 2, 2, 2, 3, 524, 3, 2, 2, 2, 3, 526, 3, 2, 2, 2, 3, 528, 3, 2, 2, 2, 3, 530, 3, 2, 2, 2, 3, 532, 3, 2, 2, 2, 3, 534, 3, 2, 2, 2, 3, 536, 3, 2, 2, 2, 3, 538, 3, 2, 2, 2, 3, 540, 3, 2, 2, 2, 3, 542, 3, 2, 2, 2, 3, 544, 3, 2, 2, 2, 3, 546, 3, 2, 2, 2, 3, 548, 3, 2, 2, 2, 3, 550, 3, 2, 2, 2, 3, 552, 3, 2, 2, 2, 3, 554, 3, 2, 2, 2, 3, 556, 3, 2, 2, 2, 3, 558, 3, 2, 2, 2, 3, 560, 3, 2, 2, 2, 3, 562, 3, 2, 2, 2, 3, 564, 3, 2, 2, 2, 3, 566, 3, 2, 2, 2, 3, 568, 3, 2, 2, 2, 3, 570, 3, 2, 2, 2, 3, 572, 3, 2, 2, 2, 3, 574, 3, 2, 2, 2, 3, 576, 3, 2, 2, 2, 3, 578, 3, 2, 2, 2, 3, 580, 3, 2, 2, 2, 3, 582, 3, 2, 2, 2, 3, 584, 3, 2, 2, 2, 3, 586, 3, 2, 2, 2, 3, 588, 3, 2, 2, 2, 3, 590, 3, 2, 2, 2, 3, 592, 3, 2, 2, 2, 3, 594, 3, 2, 2, 2, 3, 596, 3, 2, 2, 2, 3, 598, 3, 2, 2, 2, 4, 600, 3, 2, 2, 2, 4, 602, 3, 2, 2, 2, 4, 604, 3, 2, 2, 2, 4, 606, 3, 2, 2, 2, 4, 608, 3, 2, 2, 2, 5, 610, 3, 2, 2, 2, 5, 612, 3, 2, 2, 2, 5, 614, 3, 2, 2, 2, 5, 616, 3, 2, 2, 2, 5, 618, 3, 2, 2, 2, 5, 620, 3, 2, 2, 2, 6, 622, 3, 2, 2, 2, 8, 631, 3, 2, 2, 2, 10, 646, 3, 2, 2, 2, 12, 657, 3, 2, 2, 2, 14, 666, 3, 2, 2, 2, 16, 671, 3, 2, 2, 2, 18, 673, 3, 2, 2, 2, 20, 677, 3, 2, 2, 2, 22, 679, 3, 2, 2, 2, 24, 681, 3, 2, 2, 2, 26, 685, 3, 2, 2, 2, 28, 689, 3, 2, 2, 2, 30, 693, 3, 2, 2, 2, 32, 697, 3, 2, 2, 2, 34, 701, 3, 2, 2, 2, 36, 705, 3, 2, 2, 2, 38, 707, 3, 2, 2, 2, 40, 709, 3, 2, 2, 2, 42, 711, 3, 2, 2, 2, 44, 713, 3, 2, 2, 2, 46, 715, 3, 2, 2, 2, 48, 718, 3, 2, 2, 2, 50, 721, 3, 2, 2, 2, 52, 724, 3, 2, 2, 2, 54, 727, 3, 2, 2, 2, 56, 730, 3, 2, 2, 2, 58, 732, 3, 2, 2, 2, 60, 734, 3, 2, 2, 2, 62, 736, 3, 2, 2, 2, 64, 738, 3, 2, 2, 2, 66, 741, 3, 2, 2, 2, 68, 744, 3, 2, 2, 2, 70, 747, 3, 2, 2, 2, 72, 750, 3, 2, 2, 2, 74, 753, 3, 2, 2, 2, 76, 756, 3, 2, 2, 2, 78, 759, 3, 2, 2, 2, 80, 762, 3, 2, 2, 2, 82, 765, 3, 2, 2, 2, 84, 768, 3, 2, 2, 2, 86, 770, 3, 2, 2, 2, 88, 772, 3, 2, 2, 2, 90, 777, 3, 2, 2, 2, 92, 780, 3, 2, 2, 2, 94, 782, 3, 2, 2, 2, 96, 784, 3, 2, 2, 2, 98, 786, 3, 2, 2, 2, 100, 789, 3, 2, 2, 2, 102, 792, 3, 2, 2, 2, 104, 795, 3, 2, 2, 2, 106, 799, 3, 2, 2, 2, 108, 803, 3, 2, 2, 2, 110, 806, 3, 2, 2, 2, 112, 810, 3, 2, 2, 2, 114, 812, 3, 2, 2, 2, 116, 822, 3, 2, 2, 2, 118, 834, 3, 2, 2, 2, 120, 843, 3, 2, 2, 2, 122, 851, 3, 2, 2, 2, 124, 860, 3, 2, 2, 2, 126, 868, 3, 2, 2, 2, 128, 875, 3, 2, 2, 2, 130, 881, 3, 2, 2, 2, 132, 891, 3, 2, 2, 2, 134, 895, 3, 2, 2, 2, 136, 902, 3, 2, 2, 2, 138, 906, 3, 2, 2, 2, 140, 910, 3, 2, 2, 2, 142, 920, 3, 2, 2, 2, 144, 932, 3, 2, 2, 2, 146, 935, 3, 2, 2, 2, 148, 945, 3, 2, 2, 2, 150, 950, 3, 2, 2, 2, 152, 955, 3, 2, 2, 2, 154, 961, 3, 2, 2, 2, 156, 968, 3, 2, 2, 2, 158, 974, 3, 2, 2, 2, 160, 977, 3, 2, 2, 2, 162, 982, 3, 2, 2, 2, 164, 987, 3, 2, 2, 2, 166, 991, 3, 2, 2, 2, 168, 997, 3, 2, 2, 2, 170, 1005, 3, 2, 2, 2, 172, 1009, 3, 2, 2, 2, 174, 1012, 3, 2, 2, 2, 176, 1018, 3, 2, 2, 2, 178, 1024, 3, 2, 2, 2, 180, 1031, 3, 2, 2, 2, 182, 1040, 3, 2, 2, 2, 184, 1046, 3, 2, 2, 2, 186, 1049, 3, 2, 2, 2, 188, 1052, 3, 2, 2, 2, 190, 1055, 3, 2, 2, 2, 192, 1063, 3, 2, 2, 2, 194, 1071, 3, 2, 2, 2, 196, 1075, 3, 2, 2, 2, 198, 1079, 3, 2, 2, 2, 200, 1083, 3, 2, 2, 2, 202, 1091, 3, 2, 2, 2, 204, 1097, 3, 2, 2, 2, 206, 1104, 3, 2, 2, 2, 208, 1114, 3, 2, 2, 2, 210, 1119, 3, 2, 2, 2, 212, 1124, 3, 2, 2, 2, 214, 1134, 3, 2, 2, 2, 216, 1141, 3, 2, 2, 2, 218, 1151, 3, 2, 2, 2, 220, 1161, 3, 2, 2, 2, 222, 1168, 3, 2, 2, 2, 224, 1176, 3, 2, 2, 2, 226, 1186, 3, 2, 2, 2, 228, 1195, 3, 2, 2, 2, 230, 1200, 3, 2, 2, 2, 232, 1207, 3, 2, 2, 2, 234, 1218, 3, 2, 2, 2, 236, 1223, 3, 2, 2, 2, 238, 1229, 3, 2, 2, 2, 240, 1237, 3, 2, 2, 2, 242, 1246, 3, 2, 2, 2, 244, 1253, 3, 2, 2, 2, 246, 1259, 3, 2, 2, 2, 248, 1268, 3, 2, 2, 2, 250, 1276, 3, 2, 2, 2, 252, 1285, 3, 2, 2, 2, 254, 1294, 3, 2, 2, 2, 256, 1300, 3, 2, 2, 2, 258, 1305, 3, 2, 2, 2, 260, 1311, 3, 2, 2, 2, 262, 1320, 3, 2, 2, 2, 264, 1327, 3, 2, 2, 2, 266, 1336, 3, 2, 2, 2, 268, 1348, 3, 2, 2, 2, 270, 1356, 3, 2, 2, 2, 272, 1363, 3, 2, 2, 2, 274, 1370, 3, 2, 2, 2, 276, 1374, 3, 2, 2, 2, 278, 1382, 3, 2, 2, 2, 280, 1390, 3, 2, 2, 2, 282, 1394, 3, 2, 2, 2, 284, 1406, 3, 2, 2, 2, 286, 1408, 3, 2, 2, 2, 288, 1425, 3, 2, 2, 2, 290, 1430, 3, 2, 2, 2, 292, 1444, 3, 2, 2, 2, 294, 1446, 3, 2, 2, 2, 296, 1448, 3, 2, 2, 2, 298, 1450, 3, 2, 2, 2, 300, 1454, 3, 2, 2, 2, 302, 1470, 3, 2, 2, 2, 304, 1472, 3, 2, 2, 2, 306, 1476, 3, 2, 2, 2, 308, 1492, 3, 2, 2, 2, 310, 1494, 3, 2, 2, 2, 312, 1505, 3, 2, 2, 2, 314, 1507, 3, 2, 2, 2, 316, 1531, 3, 2, 2, 2, 318, 1573, 3, 2, 2, 2, 320, 1575, 3, 2, 2, 2, 322, 1578, 3, 2, 2, 2, 324, 1581, 3, 2, 2, 2, 326, 1590, 3, 2, 2, 2, 328, 1592, 3, 2, 2, 2, 330, 1599, 3, 2, 2, 2, 332, 1608, 3, 2, 2, 2, 334, 1610, 3, 2, 2, 2, 336, 1612, 3, 2, 2, 2, 338, 1614, 3, 2, 2, 2, 340, 1616, 3, 2, 2, 2, 342, 1618, 3, 2, 2, 2, 344, 1620, 3, 2, 2, 2, 346, 1622, 3, 2, 2, 2, 348, 1624, 3, 2, 2, 2, 350, 1626, 3, 2, 2, 2, 352, 1631, 3, 2, 2, 2, 354, 1636, 3, 2, 2, 2, 356, 1641, 3, 2, 2, 2, 358, 1646, 3, 2, 2, 2, 360, 1651, 3, 2, 2, 2, 362, 1656, 3, 2, 2, 2, 364, 1660, 3, 2, 2, 2, 366, 1664, 3, 2, 2, 2, 368, 1668, 3, 2, 2, 2, 370, 1672, 3, 2, 2, 2, 372, 1676, 3, 2, 2, 2, 374, 1680, 3, 2, 2, 2, 376, 1684, 3, 2, 2, 2, 378, 1688, 3, 2, 2, 2, 380, 1692, 3, 2, 2, 2, 382, 1696, 3, 2, 2, 2, 384, 1700, 3, 2, 2, 2, 386, 1707, 3, 2, 2, 2, 388, 1711, 3, 2, 2, 2, 390, 1715, 3, 2, 2, 2, 392, 1719, 3, 2, 2, 2, 394, 1723, 3, 2, 2, 2, 396, 1727, 3, 2, 2, 2, 398, 1731, 3, 2, 2, 2, 400, 1735, 3, 2, 2, 2, 402, 1739, 3, 2, 2, 2, 404, 1743, 3, 2, 2, 2, 406, 1747, 3, 2, 2, 2, 408, 1751, 3, 2, 2, 2, 410, 1755, 3, 2, 2, 2, 412, 1759, 3, 2, 2, 2, 414, 1763, 3, 2, 2, 2, 416, 1767, 3, 2, 2, 2, 418, 1771, 3, 2, 2, 2, 420, 1775, 3, 2, 2, 2, 422, 1782, 3, 2, 2, 2, 424, 1786, 3, 2, 2, 2, 426, 1790, 3, 2, 2, 2, 428, 1794, 3, 2, 2, 2, 430, 1798, 3, 2, 2, 2, 432, 1802, 3, 2, 2, 2, 434, 1806, 3, 2, 2, 2, 436, 1810, 3, 2, 2, 2, 438, 1814, 3, 2, 2, 2, 440, 1818, 3, 2, 2, 2, 442, 1822, 3, 2, 2, 2, 444, 1826, 3, 2, 2, 2, 446, 1830, 3, 2, 2, 2, 448, 1834, 3, 2, 2, 2, 450, 1838, 3, 2, 2, 2, 452, 1842, 3, 2, 2, 2, 454, 1847, 3, 2, 2, 2, 456, 1852, 3, 2, 2, 2, 458, 1856, 3, 2, 2, 2, 460, 1860, 3, 2, 2, 2, 462, 1864, 3, 2, 2, 2, 464, 1868, 3, 2, 2, 2, 466, 1872, 3, 2, 2, 2, 468, 1876, 3, 2, 2, 2, 470, 1880, 3, 2, 2, 2, 472, 1884, 3, 2, 2, 2, 474, 1888, 3, 2, 2, 2, 476, 1892, 3, 2, 2, 2, 478, 1896, 3, 2, 2, 2, 480, 1900, 3, 2, 2, 2, 482, 1904, 3, 2, 2, 2, 484, 1908, 3, 2, 2, 2, 486, 1912, 3, 2, 2, 2, 488, 1916, 3, 2, 2, 2, 490, 1920, 3, 2, 2, 2, 492, 1924, 3, 2, 2, 2, 494, 1928, 3, 2, 2, 2, 496, 1932, 3, 2, 2, 2, 498, 1936, 3, 2, 2, 2, 500, 1940, 3, 2, 2, 2, 502, 1944, 3, 2, 2, 2, 504, 1948, 3, 2, 2, 2, 506, 1952, 3, 2, 2, 2, 508, 1956, 3, 2, 2, 2, 510, 1960, 3, 2, 2, 2, 512, 1964, 3, 2, 2, 2, 514, 1968, 3, 2, 2, 2, 516, 1972, 3, 2, 2, 2, 518, 1976, 3, 2, 2, 2, 520, 1980, 3, 2, 2, 2, 522, 1984, 3, 2, 2, 2, 524, 1988, 3, 2, 2, 2, 526, 1992, 3, 2, 2, 2, 528, 1996, 3, 2, 2, 2, 530, 2000, 3, 2, 2, 2, 532, 2004, 3, 2, 2, 2, 534, 2008, 3, 2, 2, 2, 536, 2012, 3, 2, 2, 2, 538, 2016, 3, 2, 2, 2, 540, 2020, 3, 2, 2, 2, 542, 2024, 3, 2, 2, 2, 544, 2028, 3, 2, 2, 2, 546, 2032, 3, 2, 2, 2, 548, 2036, 3, 2, 2, 2, 550, 2040, 3, 2, 2, 2, 552, 2044, 3, 2, 2, 2, 554, 2048, 3, 2, 2, 2, 556, 2052, 3, 2, 2, 2, 558, 2056, 3, 2, 2, 2, 560, 2060, 3, 2, 2, 2, 562, 2064, 3, 2, 2, 2, 564, 2068, 3, 2, 2, 2, 566, 2072, 3, 2, 2, 2, 568, 2076, 3, 2, 2, 2, 570, 2080, 3, 2, 2, 2, 572, 2084, 3, 2, 2, 2, 574, 2088, 3, 2, 2, 2, 576, 2092, 3, 2, 2, 2, 578, 2096, 3, 2, 2, 2, 580, 2100, 3, 2, 2, 2, 582, 2104, 3, 2, 2, 2, 584, 2108, 3, 2, 2, 2, 586, 2112, 3, 2, 2, 2, 588, 2116, 3, 2, 2, 2, 590, 2120, 3, 2, 2, 2, 592, 2124, 3, 2, 2, 2, 594, 2130, 3, 2, 2, 2, 596, 2134, 3, 2, 2, 2, 598, 2138, 3, 2, 2, 2, 600, 2142, 3, 2, 2, 2, 602, 2146, 3, 2, 2, 2, 604, 2154, 3, 2, 2, 2, 606, 2158, 3, 2, 2, 2, 608, 2160, 3, 2, 2, 2, 610, 2166, 3, 2, 2, 2, 612, 2175, 3, 2, 2, 2, 614, 2179, 3, 2, 2, 2, 616, 2187, 3, 2, 2, 2, 618, 2189, 3, 2, 2, 2, 620, 2194, 3, 2, 2, 2, 622, 623, 7, 37, 2, 2, 623, 624, 7, 35, 2, 2, 624, 628, 3, 2, 2, 2, 625, 627, 10, 2, 2, 2, 626, 625, 3, 2, 2, 2, 627, 630, 3, 2, 2, 2, 628, 626, 3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 7, 3, 2, 2, 2, 630, 628, 3, 2, 2, 2, 631, 632, 7, 49, 2, 2, 632, 633, 7, 44, 2, 2, 633, 638, 3, 2, 2, 2, 634, 637, 5, 8, 3, 2, 635, 637, 11, 2, 2, 2, 636, 634, 3, 2, 2, 2, 636, 635, 3, 2, 2, 2, 637, 640, 3, 2, 2, 2, 638, 639, 3, 2, 2, 2, 638, 636, 3, 2, 2, 2, 639, 641, 3, 2, 2, 2, 640, 638, 3, 2, 2, 2, 641, 642, 7, 44, 2, 2, 642, 643, 7, 49, 2, 2, 643, 644, 3, 2, 2, 2, 644, 645, 8, 3, 2, 2, 645, 9, 3, 2, 2, 2, 646, 647, 7, 49, 2, 2, 647, 648, 7, 49, 2, 2, 648, 652, 3, 2, 2, 2, 649, 651, 10, 2, 2, 2, 650, 649, 3, 2, 2, 2, 651, 654, 3, 2, 2, 2, 652, 650, 3, 2, 2, 2, 652, 653, 3, 2, 2, 2, 653, 655, 3, 2, 2, 2, 654, 652, 3, 2, 2, 2, 655, 656, 8, 4, 2, 2, 656, 11, 3, 2, 2, 2, 657, 658, 9, 3, 2, 2, 658, 659, 3, 2, 2, 2, 659, 660, 8, 5, 2, 2, 660, 13, 3, 2, 2, 2, 661, 667, 7, 12, 2, 2, 662, 664, 7, 15, 2, 2, 663, 665, 7, 12, 2, 2, 664, 663, 3, 2, 2, 2, 664, 665, 3, 2, 2, 2, 665, 667, 3, 2, 2, 2, 666, 661, 3, 2, 2, 2, 666, 662, 3, 2, 2, 2, 667, 15, 3, 2, 2, 2, 668, 672, 5, 8, 3, 2, 669, 672, 5, 10, 4, 2, 670, 672, 5, 12, 5, 2, 671, 668, 3, 2, 2, 2, 671, 669, 3, 2, 2, 2, 671, 670, 3, 2, 2, 2, 672, 17, 3, 2, 2, 2, 673, 674, 7, 48, 2, 2, 674, 675, 7, 48, 2, 2, 675, 676, 7, 48, 2, 2, 676, 19, 3, 2, 2, 2, 677, 678, 7, 48, 2, 2, 678, 21, 3, 2, 2, 2, 679, 680, 7, 46, 2, 2, 680, 23, 3, 2, 2, 2, 681, 682, 7, 42, 2, 2, 682, 683, 3, 2, 2, 2, 683, 684, 8, 11, 3, 2, 684, 25, 3, 2, 2, 2, 685, 686, 7, 43, 2, 2, 686, 687, 3, 2, 2, 2, 687, 688, 8, 12, 4, 2, 688, 27, 3, 2, 2, 2, 689, 690, 7, 93, 2, 2, 690, 691, 3, 2, 2, 2, 691, 692, 8, 13, 3, 2, 692, 29, 3, 2, 2, 2, 693, 694, 7, 95, 2, 2, 694, 695, 3, 2, 2, 2, 695, 696, 8, 14, 4, 2, 696, 31, 3, 2, 2, 2, 697, 698, 7, 125, 2, 2, 698, 699, 3, 2, 2, 2, 699, 700, 8, 15, 5, 2, 700, 33, 3, 2, 2, 2, 701, 702, 7, 127, 2, 2, 702, 703, 3, 2, 2, 2, 703, 704, 8, 16, 4, 2, 704, 35, 3, 2, 2, 2, 705, 706, 7, 44, 2, 2, 706, 37, 3, 2, 2, 2, 707, 708, 7, 39, 2, 2, 708, 39, 3, 2, 2, 2, 709, 710, 7, 49, 2, 2, 710, 41, 3, 2, 2, 2, 711, 712, 7, 45, 2, 2, 712, 43, 3, 2, 2, 2, 713, 714, 7, 47, 2, 2, 714, 45, 3, 2, 2, 2, 715, 716, 7, 45, 2, 2, 716, 717, 7, 45, 2, 2, 717, 47, 3, 2, 2, 2, 718, 719, 7, 47, 2, 2, 719, 720, 7, 47, 2, 2, 720, 49, 3, 2, 2, 2, 721, 722, 7, 40, 2, 2, 722, 723, 7, 40, 2, 2, 723, 51, 3, 2, 2, 2, 724, 725, 7, 126, 2, 2, 725, 726, 7, 126, 2, 2, 726, 53, 3, 2, 2, 2, 727, 728, 7, 35, 2, 2, 728, 729, 5, 16, 7, 2, 729, 55, 3, 2, 2, 2, 730, 731, 7, 35, 2, 2, 731, 57, 3, 2, 2, 2, 732, 733, 7, 60, 2, 2, 733, 59, 3, 2, 2, 2, 734, 735, 7, 61, 2, 2, 735, 61, 3, 2, 2, 2, 736, 737, 7, 63, 2, 2, 737, 63, 3, 2, 2, 2, 738, 739, 7, 45, 2, 2, 739, 740, 7, 63, 2, 2, 740, 65, 3, 2, 2, 2, 741, 742, 7, 47, 2, 2, 742, 743, 7, 63, 2, 2, 743, 67, 3, 2, 2, 2, 744, 745, 7, 44, 2, 2, 745, 746, 7, 63, 2, 2, 746, 69, 3, 2, 2, 2, 747, 748, 7, 49, 2, 2, 748, 749, 7, 63, 2, 2, 749, 71, 3, 2, 2, 2, 750, 751, 7, 39, 2, 2, 751, 752, 7, 63, 2, 2, 752, 73, 3, 2, 2, 2, 753, 754, 7, 47, 2, 2, 754, 755, 7, 64, 2, 2, 755, 75, 3, 2, 2, 2, 756, 757, 7, 63, 2, 2, 757, 758, 7, 64, 2, 2, 758, 77, 3, 2, 2, 2, 759, 760, 7, 48, 2, 2, 760, 761, 7, 48, 2, 2, 761, 79, 3, 2, 2, 2, 762, 763, 7, 60, 2, 2, 763, 764, 7, 60, 2, 2, 764, 81, 3, 2, 2, 2, 765, 766, 7, 61, 2, 2, 766, 767, 7, 61, 2, 2, 767, 83, 3, 2, 2, 2, 768, 769, 7, 37, 2, 2, 769, 85, 3, 2, 2, 2, 770, 771, 7, 66, 2, 2, 771, 87, 3, 2, 2, 2, 772, 775, 5, 86, 42, 2, 773, 776, 5, 16, 7, 2, 774, 776, 5, 14, 6, 2, 775, 773, 3, 2, 2, 2, 775, 774, 3, 2, 2, 2, 776, 89, 3, 2, 2, 2, 777, 778, 7, 65, 2, 2, 778, 779, 5, 16, 7, 2, 779, 91, 3, 2, 2, 2, 780, 781, 7, 65, 2, 2, 781, 93, 3, 2, 2, 2, 782, 783, 7, 62, 2, 2, 783, 95, 3, 2, 2, 2, 784, 785, 7, 64, 2, 2, 785, 97, 3, 2, 2, 2, 786, 787, 7, 62, 2, 2, 787, 788, 7, 63, 2, 2, 788, 99, 3, 2, 2, 2, 789, 790, 7, 64, 2, 2, 790, 791, 7, 63, 2, 2, 791, 101, 3, 2, 2, 2, 792, 793, 7, 35, 2, 2, 793, 794, 7, 63, 2, 2, 794, 103, 3, 2, 2, 2, 795, 796, 7, 35, 2, 2, 796, 797, 7, 63, 2, 2, 797, 798, 7, 63, 2, 2, 798, 105, 3, 2, 2, 2, 799, 800, 7, 99, 2, 2, 800, 801, 7, 117, 2, 2, 801, 802, 7, 65, 2, 2, 802, 107, 3, 2, 2, 2, 803, 804, 7, 63, 2, 2, 804, 805, 7, 63, 2, 2, 805, 109, 3, 2, 2, 2, 806, 807, 7, 63, 2, 2, 807, 808, 7, 63, 2, 2, 808, 809, 7, 63, 2, 2, 809, 111, 3, 2, 2, 2, 810, 811, 7, 41, 2, 2, 811, 113, 3, 2, 2, 2, 812, 813, 7, 116, 2, 2, 813, 814, 7, 103, 2, 2, 814, 815, 7, 118, 2, 2, 815, 816, 7, 119, 2, 2, 816, 817, 7, 116, 2, 2, 817, 818, 7, 112, 2, 2, 818, 819, 7, 66, 2, 2, 819, 820, 3, 2, 2, 2, 820, 821, 5, 316, 157, 2, 821, 115, 3, 2, 2, 2, 822, 823, 7, 101, 2, 2, 823, 824, 7, 113, 2, 2, 824, 825, 7, 112, 2, 2, 825, 826, 7, 118, 2, 2, 826, 827, 7, 107, 2, 2, 827, 828, 7, 112, 2, 2, 828, 829, 7, 119, 2, 2, 829, 830, 7, 103, 2, 2, 830, 831, 7, 66, 2, 2, 831, 832, 3, 2, 2, 2, 832, 833, 5, 316, 157, 2, 833, 117, 3, 2, 2, 2, 834, 835, 7, 100, 2, 2, 835, 836, 7, 116, 2, 2, 836, 837, 7, 103, 2, 2, 837, 838, 7, 99, 2, 2, 838, 839, 7, 109, 2, 2, 839, 840, 7, 66, 2, 2, 840, 841, 3, 2, 2, 2, 841, 842, 5, 316, 157, 2, 842, 119, 3, 2, 2, 2, 843, 844, 7, 118, 2, 2, 844, 845, 7, 106, 2, 2, 845, 846, 7, 107, 2, 2, 846, 847, 7, 117, 2, 2, 847, 848, 7, 66, 2, 2, 848, 849, 3, 2, 2, 2, 849, 850, 5, 316, 157, 2, 850, 121, 3, 2, 2, 2, 851, 852, 7, 117, 2, 2, 852, 853, 7, 119, 2, 2, 853, 854, 7, 114, 2, 2, 854, 855, 7, 103, 2, 2, 855, 856, 7, 116, 2, 2, 856, 857, 7, 66, 2, 2, 857, 858, 3, 2, 2, 2, 858, 859, 5, 316, 157, 2, 859, 123, 3, 2, 2, 2, 860, 861, 7, 114, 2, 2, 861, 862, 7, 99, 2, 2, 862, 863, 7, 101, 2, 2, 863, 864, 7, 109, 2, 2, 864, 865, 7, 99, 2, 2, 865, 866, 7, 105, 2, 2, 866, 867, 7, 103, 2, 2, 867, 125, 3, 2, 2, 2, 868, 869, 7, 107, 2, 2, 869, 870, 7, 111, 2, 2, 870, 871, 7, 114, 2, 2, 871, 872, 7, 113, 2, 2, 872, 873, 7, 116, 2, 2, 873, 874, 7, 118, 2, 2, 874, 127, 3, 2, 2, 2, 875, 876, 7, 101, 2, 2, 876, 877, 7, 110, 2, 2, 877, 878, 7, 99, 2, 2, 878, 879, 7, 117, 2, 2, 879, 880, 7, 117, 2, 2, 880, 129, 3, 2, 2, 2, 881, 882, 7, 107, 2, 2, 882, 883, 7, 112, 2, 2, 883, 884, 7, 118, 2, 2, 884, 885, 7, 103, 2, 2, 885, 886, 7, 116, 2, 2, 886, 887, 7, 104, 2, 2, 887, 888, 7, 99, 2, 2, 888, 889, 7, 101, 2, 2, 889, 890, 7, 103, 2, 2, 890, 131, 3, 2, 2, 2, 891, 892, 7, 104, 2, 2, 892, 893, 7, 119, 2, 2, 893, 894, 7, 112, 2, 2, 894, 133, 3, 2, 2, 2, 895, 896, 7, 113, 2, 2, 896, 897, 7, 100, 2, 2, 897, 898, 7, 108, 2, 2, 898, 899, 7, 103, 2, 2, 899, 900, 7, 101, 2, 2, 900, 901, 7, 118, 2, 2, 901, 135, 3, 2, 2, 2, 902, 903, 7, 120, 2, 2, 903, 904, 7, 99, 2, 2, 904, 905, 7, 110, 2, 2, 905, 137, 3, 2, 2, 2, 906, 907, 7, 120, 2, 2, 907, 908, 7, 99, 2, 2, 908, 909, 7, 116, 2, 2, 909, 139, 3, 2, 2, 2, 910, 911, 7, 118, 2, 2, 911, 912, 7, 123, 2, 2, 912, 913, 7, 114, 2, 2, 913, 914, 7, 103, 2, 2, 914, 915, 7, 99, 2, 2, 915, 916, 7, 110, 2, 2, 916, 917, 7, 107, 2, 2, 917, 918, 7, 99, 2, 2, 918, 919, 7, 117, 2, 2, 919, 141, 3, 2, 2, 2, 920, 921, 7, 101, 2, 2, 921, 922, 7, 113, 2, 2, 922, 923, 7, 112, 2, 2, 923, 924, 7, 117, 2, 2, 924, 925, 7, 118, 2, 2, 925, 926, 7, 116, 2, 2, 926, 927, 7, 119, 2, 2, 927, 928, 7, 101, 2, 2, 928, 929, 7, 118, 2, 2, 929, 930, 7, 113, 2, 2, 930, 931, 7, 116, 2, 2, 931, 143, 3, 2, 2, 2, 932, 933, 7, 100, 2, 2, 933, 934, 7, 123, 2, 2, 934, 145, 3, 2, 2, 2, 935, 936, 7, 101, 2, 2, 936, 937, 7, 113, 2, 2, 937, 938, 7, 111, 2, 2, 938, 939, 7, 114, 2, 2, 939, 940, 7, 99, 2, 2, 940, 941, 7, 112, 2, 2, 941, 942, 7, 107, 2, 2, 942, 943, 7, 113, 2, 2, 943, 944, 7, 112, 2, 2, 944, 147, 3, 2, 2, 2, 945, 946, 7, 107, 2, 2, 946, 947, 7, 112, 2, 2, 947, 948, 7, 107, 2, 2, 948, 949, 7, 118, 2, 2, 949, 149, 3, 2, 2, 2, 950, 951, 7, 118, 2, 2, 951, 952, 7, 106, 2, 2, 952, 953, 7, 107, 2, 2, 953, 954, 7, 117, 2, 2, 954, 151, 3, 2, 2, 2, 955, 956, 7, 117, 2, 2, 956, 957, 7, 119, 2, 2, 957, 958, 7, 114, 2, 2, 958, 959, 7, 103, 2, 2, 959, 960, 7, 116, 2, 2, 960, 153, 3, 2, 2, 2, 961, 962, 7, 118, 2, 2, 962, 963, 7, 123, 2, 2, 963, 964, 7, 114, 2, 2, 964, 965, 7, 103, 2, 2, 965, 966, 7, 113, 2, 2, 966, 967, 7, 104, 2, 2, 967, 155, 3, 2, 2, 2, 968, 969, 7, 121, 2, 2, 969, 970, 7, 106, 2, 2, 970, 971, 7, 103, 2, 2, 971, 972, 7, 116, 2, 2, 972, 973, 7, 103, 2, 2, 973, 157, 3, 2, 2, 2, 974, 975, 7, 107, 2, 2, 975, 976, 7, 104, 2, 2, 976, 159, 3, 2, 2, 2, 977, 978, 7, 103, 2, 2, 978, 979, 7, 110, 2, 2, 979, 980, 7, 117, 2, 2, 980, 981, 7, 103, 2, 2, 981, 161, 3, 2, 2, 2, 982, 983, 7, 121, 2, 2, 983, 984, 7, 106, 2, 2, 984, 985, 7, 103, 2, 2, 985, 986, 7, 112, 2, 2, 986, 163, 3, 2, 2, 2, 987, 988, 7, 118, 2, 2, 988, 989, 7, 116, 2, 2, 989, 990, 7, 123, 2, 2, 990, 165, 3, 2, 2, 2, 991, 992, 7, 101, 2, 2, 992, 993, 7, 99, 2, 2, 993, 994, 7, 118, 2, 2, 994, 995, 7, 101, 2, 2, 995, 996, 7, 106, 2, 2, 996, 167, 3, 2, 2, 2, 997, 998, 7, 104, 2, 2, 998, 999, 7, 107, 2, 2, 999, 1000, 7, 112, 2, 2, 1000, 1001, 7, 99, 2, 2, 1001, 1002, 7, 110, 2, 2, 1002, 1003, 7, 110, 2, 2, 1003, 1004, 7, 123, 2, 2, 1004, 169, 3, 2, 2, 2, 1005, 1006, 7, 104, 2, 2, 1006, 1007, 7, 113, 2, 2, 1007, 1008, 7, 116, 2, 2, 1008, 171, 3, 2, 2, 2, 1009, 1010, 7, 102, 2, 2, 1010, 1011, 7, 113, 2, 2, 1011, 173, 3, 2, 2, 2, 1012, 1013, 7, 121, 2, 2, 1013, 1014, 7, 106, 2, 2, 1014, 1015, 7, 107, 2, 2, 1015, 1016, 7, 110, 2, 2, 1016, 1017, 7, 103, 2, 2, 1017, 175, 3, 2, 2, 2, 1018, 1019, 7, 118, 2, 2, 1019, 1020, 7, 106, 2, 2, 1020, 1021, 7, 116, 2, 2, 1021, 1022, 7, 113, 2, 2, 1022, 1023, 7, 121, 2, 2, 1023, 177, 3, 2, 2, 2, 1024, 1025, 7, 116, 2, 2, 1025, 1026, 7, 103, 2, 2, 1026, 1027, 7, 118, 2, 2, 1027, 1028, 7, 119, 2, 2, 1028, 1029, 7, 116, 2, 2, 1029, 1030, 7, 112, 2, 2, 1030, 179, 3, 2, 2, 2, 1031, 1032, 7, 101, 2, 2, 1032, 1033, 7, 113, 2, 2, 1033, 1034, 7, 112, 2, 2, 1034, 1035, 7, 118, 2, 2, 1035, 1036, 7, 107, 2, 2, 1036, 1037, 7, 112, 2, 2, 1037, 1038, 7, 119, 2, 2, 1038, 1039, 7, 103, 2, 2, 1039, 181, 3, 2, 2, 2, 1040, 1041, 7, 100, 2, 2, 1041, 1042, 7, 116, 2, 2, 1042, 1043, 7, 103, 2, 2, 1043, 1044, 7, 99, 2, 2, 1044, 1045, 7, 109, 2, 2, 1045, 183, 3, 2, 2, 2, 1046, 1047, 7, 99, 2, 2, 1047, 1048, 7, 117, 2, 2, 1048, 185, 3, 2, 2, 2, 1049, 1050, 7, 107, 2, 2, 1050, 1051, 7, 117, 2, 2, 1051, 187, 3, 2, 2, 2, 1052, 1053, 7, 107, 2, 2, 1053, 1054, 7, 112, 2, 2, 1054, 189, 3, 2, 2, 2, 1055, 1056, 7, 35, 2, 2, 1056, 1057, 7, 107, 2, 2, 1057, 1058, 7, 117, 2, 2, 1058, 1061, 3, 2, 2, 2, 1059, 1062, 5, 16, 7, 2, 1060, 1062, 5, 14, 6, 2, 1061, 1059, 3, 2, 2, 2, 1061, 1060, 3, 2, 2, 2, 1062, 191, 3, 2, 2, 2, 1063, 1064, 7, 35, 2, 2, 1064, 1065, 7, 107, 2, 2, 1065, 1066, 7, 112, 2, 2, 1066, 1069, 3, 2, 2, 2, 1067, 1070, 5, 16, 7, 2, 1068, 1070, 5, 14, 6, 2, 1069, 1067, 3, 2, 2, 2, 1069, 1068, 3, 2, 2, 2, 1070, 193, 3, 2, 2, 2, 1071, 1072, 7, 113, 2, 2, 1072, 1073, 7, 119, 2, 2, 1073, 1074, 7, 118, 2, 2, 1074, 195, 3, 2, 2, 2, 1075, 1076, 7, 105, 2, 2, 1076, 1077, 7, 103, 2, 2, 1077, 1078, 7, 118, 2, 2, 1078, 197, 3, 2, 2, 2, 1079, 1080, 7, 117, 2, 2, 1080, 1081, 7, 103, 2, 2, 1081, 1082, 7, 118, 2, 2, 1082, 199, 3, 2, 2, 2, 1083, 1084, 7, 102, 2, 2, 1084, 1085, 7, 123, 2, 2, 1085, 1086, 7, 112, 2, 2, 1086, 1087, 7, 99, 2, 2, 1087, 1088, 7, 111, 2, 2, 1088, 1089, 7, 107, 2, 2, 1089, 1090, 7, 101, 2, 2, 1090, 201, 3, 2, 2, 2, 1091, 1092, 7, 66, 2, 2, 1092, 1093, 7, 104, 2, 2, 1093, 1094, 7, 107, 2, 2, 1094, 1095, 7, 110, 2, 2, 1095, 1096, 7, 103, 2, 2, 1096, 203, 3, 2, 2, 2, 1097, 1098, 7, 66, 2, 2, 1098, 1099, 7, 104, 2, 2, 1099, 1100, 7, 107, 2, 2, 1100, 1101, 7, 103, 2, 2, 1101, 1102, 7, 110, 2, 2, 1102, 1103, 7, 102, 2, 2, 1103, 205, 3, 2, 2, 2, 1104, 1105, 7, 66, 2, 2, 1105, 1106, 7, 114, 2, 2, 1106, 1107, 7, 116, 2, 2, 1107, 1108, 7, 113, 2, 2, 1108, 1109, 7, 114, 2, 2, 1109, 1110, 7, 103, 2, 2, 1110, 1111, 7, 116, 2, 2, 1111, 1112, 7, 118, 2, 2, 1112, 1113, 7, 123, 2, 2, 1113, 207, 3, 2, 2, 2, 1114, 1115, 7, 66, 2, 2, 1115, 1116, 7, 105, 2, 2, 1116, 1117, 7, 103, 2, 2, 1117, 1118, 7, 118, 2, 2, 1118, 209, 3, 2, 2, 2, 1119, 1120, 7, 66, 2, 2, 1120, 1121, 7, 117, 2, 2, 1121, 1122, 7, 103, 2, 2, 1122, 1123, 7, 118, 2, 2, 1123, 211, 3, 2, 2, 2, 1124, 1125, 7, 66, 2, 2, 1125, 1126, 7, 116, 2, 2, 1126, 1127, 7, 103, 2, 2, 1127, 1128, 7, 101, 2, 2, 1128, 1129, 7, 103, 2, 2, 1129, 1130, 7, 107, 2, 2, 1130, 1131, 7, 120, 2, 2, 1131, 1132, 7, 103, 2, 2, 1132, 1133, 7, 116, 2, 2, 1133, 213, 3, 2, 2, 2, 1134, 1135, 7, 66, 2, 2, 1135, 1136, 7, 114, 2, 2, 1136, 1137, 7, 99, 2, 2, 1137, 1138, 7, 116, 2, 2, 1138, 1139, 7, 99, 2, 2, 1139, 1140, 7, 111, 2, 2, 1140, 215, 3, 2, 2, 2, 1141, 1142, 7, 66, 2, 2, 1142, 1143, 7, 117, 2, 2, 1143, 1144, 7, 103, 2, 2, 1144, 1145, 7, 118, 2, 2, 1145, 1146, 7, 114, 2, 2, 1146, 1147, 7, 99, 2, 2, 1147, 1148, 7, 116, 2, 2, 1148, 1149, 7, 99, 2, 2, 1149, 1150, 7, 111, 2, 2, 1150, 217, 3, 2, 2, 2, 1151, 1152, 7, 66, 2, 2, 1152, 1153, 7, 102, 2, 2, 1153, 1154, 7, 103, 2, 2, 1154, 1155, 7, 110, 2, 2, 1155, 1156, 7, 103, 2, 2, 1156, 1157, 7, 105, 2, 2, 1157, 1158, 7, 99, 2, 2, 1158, 1159, 7, 118, 2, 2, 1159, 1160, 7, 103, 2, 2, 1160, 219, 3, 2, 2, 2, 1161, 1162, 7, 114, 2, 2, 1162, 1163, 7, 119, 2, 2, 1163, 1164, 7, 100, 2, 2, 1164, 1165, 7, 110, 2, 2, 1165, 1166, 7, 107, 2, 2, 1166, 1167, 7, 101, 2, 2, 1167, 221, 3, 2, 2, 2, 1168, 1169, 7, 114, 2, 2, 1169, 1170, 7, 116, 2, 2, 1170, 1171, 7, 107, 2, 2, 1171, 1172, 7, 120, 2, 2, 1172, 1173, 7, 99, 2, 2, 1173, 1174, 7, 118, 2, 2, 1174, 1175, 7, 103, 2, 2, 1175, 223, 3, 2, 2, 2, 1176, 1177, 7, 114, 2, 2, 1177, 1178, 7, 116, 2, 2, 1178, 1179, 7, 113, 2, 2, 1179, 1180, 7, 118, 2, 2, 1180, 1181, 7, 103, 2, 2, 1181, 1182, 7, 101, 2, 2, 1182, 1183, 7, 118, 2, 2, 1183, 1184, 7, 103, 2, 2, 1184, 1185, 7, 102, 2, 2, 1185, 225, 3, 2, 2, 2, 1186, 1187, 7, 107, 2, 2, 1187, 1188, 7, 112, 2, 2, 1188, 1189, 7, 118, 2, 2, 1189, 1190, 7, 103, 2, 2, 1190, 1191, 7, 116, 2, 2, 1191, 1192, 7, 112, 2, 2, 1192, 1193, 7, 99, 2, 2, 1193, 1194, 7, 110, 2, 2, 1194, 227, 3, 2, 2, 2, 1195, 1196, 7, 103, 2, 2, 1196, 1197, 7, 112, 2, 2, 1197, 1198, 7, 119, 2, 2, 1198, 1199, 7, 111, 2, 2, 1199, 229, 3, 2, 2, 2, 1200, 1201, 7, 117, 2, 2, 1201, 1202, 7, 103, 2, 2, 1202, 1203, 7, 99, 2, 2, 1203, 1204, 7, 110, 2, 2, 1204, 1205, 7, 103, 2, 2, 1205, 1206, 7, 102, 2, 2, 1206, 231, 3, 2, 2, 2, 1207, 1208, 7, 99, 2, 2, 1208, 1209, 7, 112, 2, 2, 1209, 1210, 7, 112, 2, 2, 1210, 1211, 7, 113, 2, 2, 1211, 1212, 7, 118, 2, 2, 1212, 1213, 7, 99, 2, 2, 1213, 1214, 7, 118, 2, 2, 1214, 1215, 7, 107, 2, 2, 1215, 1216, 7, 113, 2, 2, 1216, 1217, 7, 112, 2, 2, 1217, 233, 3, 2, 2, 2, 1218, 1219, 7, 102, 2, 2, 1219, 1220, 7, 99, 2, 2, 1220, 1221, 7, 118, 2, 2, 1221, 1222, 7, 99, 2, 2, 1222, 235, 3, 2, 2, 2, 1223, 1224, 7, 107, 2, 2, 1224, 1225, 7, 112, 2, 2, 1225, 1226, 7, 112, 2, 2, 1226, 1227, 7, 103, 2, 2, 1227, 1228, 7, 116, 2, 2, 1228, 237, 3, 2, 2, 2, 1229, 1230, 7, 118, 2, 2, 1230, 1231, 7, 99, 2, 2, 1231, 1232, 7, 107, 2, 2, 1232, 1233, 7, 110, 2, 2, 1233, 1234, 7, 116, 2, 2, 1234, 1235, 7, 103, 2, 2, 1235, 1236, 7, 101, 2, 2, 1236, 239, 3, 2, 2, 2, 1237, 1238, 7, 113, 2, 2, 1238, 1239, 7, 114, 2, 2, 1239, 1240, 7, 103, 2, 2, 1240, 1241, 7, 116, 2, 2, 1241, 1242, 7, 99, 2, 2, 1242, 1243, 7, 118, 2, 2, 1243, 1244, 7, 113, 2, 2, 1244, 1245, 7, 116, 2, 2, 1245, 241, 3, 2, 2, 2, 1246, 1247, 7, 107, 2, 2, 1247, 1248, 7, 112, 2, 2, 1248, 1249, 7, 110, 2, 2, 1249, 1250, 7, 107, 2, 2, 1250, 1251, 7, 112, 2, 2, 1251, 1252, 7, 103, 2, 2, 1252, 243, 3, 2, 2, 2, 1253, 1254, 7, 107, 2, 2, 1254, 1255, 7, 112, 2, 2, 1255, 1256, 7, 104, 2, 2, 1256, 1257, 7, 107, 2, 2, 1257, 1258, 7, 122, 2, 2, 1258, 245, 3, 2, 2, 2, 1259, 1260, 7, 103, 2, 2, 1260, 1261, 7, 122, 2, 2, 1261, 1262, 7, 118, 2, 2, 1262, 1263, 7, 103, 2, 2, 1263, 1264, 7, 116, 2, 2, 1264, 1265, 7, 112, 2, 2, 1265, 1266, 7, 99, 2, 2, 1266, 1267, 7, 110, 2, 2, 1267, 247, 3, 2, 2, 2, 1268, 1269, 7, 117, 2, 2, 1269, 1270, 7, 119, 2, 2, 1270, 1271, 7, 117, 2, 2, 1271, 1272, 7, 114, 2, 2, 1272, 1273, 7, 103, 2, 2, 1273, 1274, 7, 112, 2, 2, 1274, 1275, 7, 102, 2, 2, 1275, 249, 3, 2, 2, 2, 1276, 1277, 7, 113, 2, 2, 1277, 1278, 7, 120, 2, 2, 1278, 1279, 7, 103, 2, 2, 1279, 1280, 7, 116, 2, 2, 1280, 1281, 7, 116, 2, 2, 1281, 1282, 7, 107, 2, 2, 1282, 1283, 7, 102, 2, 2, 1283, 1284, 7, 103, 2, 2, 1284, 251, 3, 2, 2, 2, 1285, 1286, 7, 99, 2, 2, 1286, 1287, 7, 100, 2, 2, 1287, 1288, 7, 117, 2, 2, 1288, 1289, 7, 118, 2, 2, 1289, 1290, 7, 116, 2, 2, 1290, 1291, 7, 99, 2, 2, 1291, 1292, 7, 101, 2, 2, 1292, 1293, 7, 118, 2, 2, 1293, 253, 3, 2, 2, 2, 1294, 1295, 7, 104, 2, 2, 1295, 1296, 7, 107, 2, 2, 1296, 1297, 7, 112, 2, 2, 1297, 1298, 7, 99, 2, 2, 1298, 1299, 7, 110, 2, 2, 1299, 255, 3, 2, 2, 2, 1300, 1301, 7, 113, 2, 2, 1301, 1302, 7, 114, 2, 2, 1302, 1303, 7, 103, 2, 2, 1303, 1304, 7, 112, 2, 2, 1304, 257, 3, 2, 2, 2, 1305, 1306, 7, 101, 2, 2, 1306, 1307, 7, 113, 2, 2, 1307, 1308, 7, 112, 2, 2, 1308, 1309, 7, 117, 2, 2, 1309, 1310, 7, 118, 2, 2, 1310, 259, 3, 2, 2, 2, 1311, 1312, 7, 110, 2, 2, 1312, 1313, 7, 99, 2, 2, 1313, 1314, 7, 118, 2, 2, 1314, 1315, 7, 103, 2, 2, 1315, 1316, 7, 107, 2, 2, 1316, 1317, 7, 112, 2, 2, 1317, 1318, 7, 107, 2, 2, 1318, 1319, 7, 118, 2, 2, 1319, 261, 3, 2, 2, 2, 1320, 1321, 7, 120, 2, 2, 1321, 1322, 7, 99, 2, 2, 1322, 1323, 7, 116, 2, 2, 1323, 1324, 7, 99, 2, 2, 1324, 1325, 7, 116, 2, 2, 1325, 1326, 7, 105, 2, 2, 1326, 263, 3, 2, 2, 2, 1327, 1328, 7, 112, 2, 2, 1328, 1329, 7, 113, 2, 2, 1329, 1330, 7, 107, 2, 2, 1330, 1331, 7, 112, 2, 2, 1331, 1332, 7, 110, 2, 2, 1332, 1333, 7, 107, 2, 2, 1333, 1334, 7, 112, 2, 2, 1334, 1335, 7, 103, 2, 2, 1335, 265, 3, 2, 2, 2, 1336, 1337, 7, 101, 2, 2, 1337, 1338, 7, 116, 2, 2, 1338, 1339, 7, 113, 2, 2, 1339, 1340, 7, 117, 2, 2, 1340, 1341, 7, 117, 2, 2, 1341, 1342, 7, 107, 2, 2, 1342, 1343, 7, 112, 2, 2, 1343, 1344, 7, 110, 2, 2, 1344, 1345, 7, 107, 2, 2, 1345, 1346, 7, 112, 2, 2, 1346, 1347, 7, 103, 2, 2, 1347, 267, 3, 2, 2, 2, 1348, 1349, 7, 116, 2, 2, 1349, 1350, 7, 103, 2, 2, 1350, 1351, 7, 107, 2, 2, 1351, 1352, 7, 104, 2, 2, 1352, 1353, 7, 107, 2, 2, 1353, 1354, 7, 103, 2, 2, 1354, 1355, 7, 102, 2, 2, 1355, 269, 3, 2, 2, 2, 1356, 1357, 7, 103, 2, 2, 1357, 1358, 7, 122, 2, 2, 1358, 1359, 7, 114, 2, 2, 1359, 1360, 7, 103, 2, 2, 1360, 1361, 7, 101, 2, 2, 1361, 1362, 7, 118, 2, 2, 1362, 271, 3, 2, 2, 2, 1363, 1364, 7, 99, 2, 2, 1364, 1365, 7, 101, 2, 2, 1365, 1366, 7, 118, 2, 2, 1366, 1367, 7, 119, 2, 2, 1367, 1368, 7, 99, 2, 2, 1368, 1369, 7, 110, 2, 2, 1369, 273, 3, 2, 2, 2, 1370, 1371, 7, 36, 2, 2, 1371, 1372, 3, 2, 2, 2, 1372, 1373, 8, 136, 6, 2, 1373, 275, 3, 2, 2, 2, 1374, 1375, 7, 36, 2, 2, 1375, 1376, 7, 36, 2, 2, 1376, 1377, 7, 36, 2, 2, 1377, 1378, 3, 2, 2, 2, 1378, 1379, 8, 137, 7, 2, 1379, 277, 3, 2, 2, 2, 1380, 1383, 5, 280, 139, 2, 1381, 1383, 5, 288, 143, 2, 1382, 1380, 3, 2, 2, 2, 1382, 1381, 3, 2, 2, 2, 1383, 279, 3, 2, 2, 2, 1384, 1385, 5, 288, 143, 2, 1385, 1386, 9, 4, 2, 2, 1386, 1391, 3, 2, 2, 2, 1387, 1388, 5, 284, 141, 2, 1388, 1389, 9, 4, 2, 2, 1389, 1391, 3, 2, 2, 2, 1390, 1384, 3, 2, 2, 2, 1390, 1387, 3, 2, 2, 2, 1391, 281, 3, 2, 2, 2, 1392, 1395, 5, 296, 147, 2, 1393, 1395, 7, 97, 2, 2, 1394, 1392, 3, 2, 2, 2, 1394, 1393, 3, 2, 2, 2, 1395, 283, 3, 2, 2, 2, 1396, 1400, 5, 296, 147, 2, 1397, 1399, 5, 282, 140, 2, 1398, 1397, 3, 2, 2, 2, 1399, 1402, 3, 2, 2, 2, 1400, 1398, 3, 2, 2, 2, 1400, 1401, 3, 2, 2, 2, 1401, 1403, 3, 2, 2, 2, 1402, 1400, 3, 2, 2, 2, 1403, 1404, 5, 296, 147, 2, 1404, 1407, 3, 2, 2, 2, 1405, 1407, 5, 296, 147, 2, 1406, 1396, 3, 2, 2, 2, 1406, 1405, 3, 2, 2, 2, 1407, 285, 3, 2, 2, 2, 1408, 1410, 9, 5, 2, 2, 1409, 1411, 9, 6, 2, 2, 1410, 1409, 3, 2, 2, 2, 1410, 1411, 3, 2, 2, 2, 1411, 1412, 3, 2, 2, 2, 1412, 1413, 5, 284, 141, 2, 1413, 287, 3, 2, 2, 2, 1414, 1416, 5, 284, 141, 2, 1415, 1414, 3, 2, 2, 2, 1415, 1416, 3, 2, 2, 2, 1416, 1417, 3, 2, 2, 2, 1417, 1418, 7, 48, 2, 2, 1418, 1420, 5, 284, 141, 2, 1419, 1421, 5, 286, 142, 2, 1420, 1419, 3, 2, 2, 2, 1420, 1421, 3, 2, 2, 2, 1421, 1426, 3, 2, 2, 2, 1422, 1423, 5, 284, 141, 2, 1423, 1424, 5, 286, 142, 2, 1424, 1426, 3, 2, 2, 2, 1425, 1415, 3, 2, 2, 2, 1425, 1422, 3, 2, 2, 2, 1426, 289, 3, 2, 2, 2, 1427, 1431, 5, 292, 145, 2, 1428, 1431, 5, 302, 150, 2, 1429, 1431, 5, 308, 153, 2, 1430, 1427, 3, 2, 2, 2, 1430, 1428, 3, 2, 2, 2, 1430, 1429, 3, 2, 2, 2, 1431, 1432, 3, 2, 2, 2, 1432, 1433, 7, 78, 2, 2, 1433, 291, 3, 2, 2, 2, 1434, 1438, 5, 298, 148, 2, 1435, 1437, 5, 282, 140, 2, 1436, 1435, 3, 2, 2, 2, 1437, 1440, 3, 2, 2, 2, 1438, 1436, 3, 2, 2, 2, 1438, 1439, 3, 2, 2, 2, 1439, 1441, 3, 2, 2, 2, 1440, 1438, 3, 2, 2, 2, 1441, 1442, 5, 296, 147, 2, 1442, 1445, 3, 2, 2, 2, 1443, 1445, 5, 296, 147, 2, 1444, 1434, 3, 2, 2, 2, 1444, 1443, 3, 2, 2, 2, 1445, 293, 3, 2, 2, 2, 1446, 1447, 5, 346, 172, 2, 1447, 295, 3, 2, 2, 2, 1448, 1449, 4, 50, 59, 2, 1449, 297, 3, 2, 2, 2, 1450, 1451, 4, 51, 59, 2, 1451, 299, 3, 2, 2, 2, 1452, 1455, 5, 304, 151, 2, 1453, 1455, 7, 97, 2, 2, 1454, 1452, 3, 2, 2, 2, 1454, 1453, 3, 2, 2, 2, 1455, 301, 3, 2, 2, 2, 1456, 1457, 7, 50, 2, 2, 1457, 1458, 9, 7, 2, 2, 1458, 1462, 5, 304, 151, 2, 1459, 1461, 5, 300, 149, 2, 1460, 1459, 3, 2, 2, 2, 1461, 1464, 3, 2, 2, 2, 1462, 1460, 3, 2, 2, 2, 1462, 1463, 3, 2, 2, 2, 1463, 1465, 3, 2, 2, 2, 1464, 1462, 3, 2, 2, 2, 1465, 1466, 5, 304, 151, 2, 1466, 1471, 3, 2, 2, 2, 1467, 1468, 7, 50, 2, 2, 1468, 1469, 9, 7, 2, 2, 1469, 1471, 5, 304, 151, 2, 1470, 1456, 3, 2, 2, 2, 1470, 1467, 3, 2, 2, 2, 1471, 303, 3, 2, 2, 2, 1472, 1473, 9, 8, 2, 2, 1473, 305, 3, 2, 2, 2, 1474, 1477, 5, 310, 154, 2, 1475, 1477, 7, 97, 2, 2, 1476, 1474, 3, 2, 2, 2, 1476, 1475, 3, 2, 2, 2, 1477, 307, 3, 2, 2, 2, 1478, 1479, 7, 50, 2, 2, 1479, 1480, 9, 9, 2, 2, 1480, 1484, 5, 310, 154, 2, 1481, 1483, 5, 306, 152, 2, 1482, 1481, 3, 2, 2, 2, 1483, 1486, 3, 2, 2, 2, 1484, 1482, 3, 2, 2, 2, 1484, 1485, 3, 2, 2, 2, 1485, 1487, 3, 2, 2, 2, 1486, 1484, 3, 2, 2, 2, 1487, 1488, 5, 310, 154, 2, 1488, 1493, 3, 2, 2, 2, 1489, 1490, 7, 50, 2, 2, 1490, 1491, 9, 9, 2, 2, 1491, 1493, 5, 310, 154, 2, 1492, 1478, 3, 2, 2, 2, 1492, 1489, 3, 2, 2, 2, 1493, 309, 3, 2, 2, 2, 1494, 1495, 9, 10, 2, 2, 1495, 311, 3, 2, 2, 2, 1496, 1497, 7, 118, 2, 2, 1497, 1498, 7, 116, 2, 2, 1498, 1499, 7, 119, 2, 2, 1499, 1506, 7, 103, 2, 2, 1500, 1501, 7, 104, 2, 2, 1501, 1502, 7, 99, 2, 2, 1502, 1503, 7, 110, 2, 2, 1503, 1504, 7, 117, 2, 2, 1504, 1506, 7, 103, 2, 2, 1505, 1496, 3, 2, 2, 2, 1505, 1500, 3, 2, 2, 2, 1506, 313, 3, 2, 2, 2, 1507, 1508, 7, 112, 2, 2, 1508, 1509, 7, 119, 2, 2, 1509, 1510, 7, 110, 2, 2, 1510, 1511, 7, 110, 2, 2, 1511, 315, 3, 2, 2, 2, 1512, 1515, 5, 332, 165, 2, 1513, 1515, 7, 97, 2, 2, 1514, 1512, 3, 2, 2, 2, 1514, 1513, 3, 2, 2, 2, 1515, 1521, 3, 2, 2, 2, 1516, 1520, 5, 332, 165, 2, 1517, 1520, 7, 97, 2, 2, 1518, 1520, 5, 294, 146, 2, 1519, 1516, 3, 2, 2, 2, 1519, 1517, 3, 2, 2, 2, 1519, 1518, 3, 2, 2, 2, 1520, 1523, 3, 2, 2, 2, 1521, 1519, 3, 2, 2, 2, 1521, 1522, 3, 2, 2, 2, 1522, 1532, 3, 2, 2, 2, 1523, 1521, 3, 2, 2, 2, 1524, 1526, 7, 98, 2, 2, 1525, 1527, 10, 11, 2, 2, 1526, 1525, 3, 2, 2, 2, 1527, 1528, 3, 2, 2, 2, 1528, 1526, 3, 2, 2, 2, 1528, 1529, 3, 2, 2, 2, 1529, 1530, 3, 2, 2, 2, 1530, 1532, 7, 98, 2, 2, 1531, 1514, 3, 2, 2, 2, 1531, 1524, 3, 2, 2, 2, 1532, 317, 3, 2, 2, 2, 1533, 1574, 5, 316, 157, 2, 1534, 1574, 5, 252, 125, 2, 1535, 1574, 5, 232, 115, 2, 1536, 1574, 5, 144, 71, 2, 1537, 1574, 5, 166, 82, 2, 1538, 1574, 5, 146, 72, 2, 1539, 1574, 5, 142, 70, 2, 1540, 1574, 5, 266, 132, 2, 1541, 1574, 5, 234, 116, 2, 1542, 1574, 5, 200, 99, 2, 1543, 1574, 5, 228, 113, 2, 1544, 1574, 5, 246, 122, 2, 1545, 1574, 5, 254, 126, 2, 1546, 1574, 5, 168, 83, 2, 1547, 1574, 5, 196, 97, 2, 1548, 1574, 5, 126, 62, 2, 1549, 1574, 5, 244, 121, 2, 1550, 1574, 5, 148, 73, 2, 1551, 1574, 5, 242, 120, 2, 1552, 1574, 5, 236, 117, 2, 1553, 1574, 5, 226, 112, 2, 1554, 1574, 5, 260, 129, 2, 1555, 1574, 5, 264, 131, 2, 1556, 1574, 5, 256, 127, 2, 1557, 1574, 5, 240, 119, 2, 1558, 1574, 5, 194, 96, 2, 1559, 1574, 5, 250, 124, 2, 1560, 1574, 5, 222, 110, 2, 1561, 1574, 5, 224, 111, 2, 1562, 1574, 5, 220, 109, 2, 1563, 1574, 5, 268, 133, 2, 1564, 1574, 5, 230, 114, 2, 1565, 1574, 5, 238, 118, 2, 1566, 1574, 5, 198, 98, 2, 1567, 1574, 5, 262, 130, 2, 1568, 1574, 5, 156, 77, 2, 1569, 1574, 5, 270, 134, 2, 1570, 1574, 5, 272, 135, 2, 1571, 1574, 5, 258, 128, 2, 1572, 1574, 5, 248, 123, 2, 1573, 1533, 3, 2, 2, 2, 1573, 1534, 3, 2, 2, 2, 1573, 1535, 3, 2, 2, 2, 1573, 1536, 3, 2, 2, 2, 1573, 1537, 3, 2, 2, 2, 1573, 1538, 3, 2, 2, 2, 1573, 1539, 3, 2, 2, 2, 1573, 1540, 3, 2, 2, 2, 1573, 1541, 3, 2, 2, 2, 1573, 1542, 3, 2, 2, 2, 1573, 1543, 3, 2, 2, 2, 1573, 1544, 3, 2, 2, 2, 1573, 1545, 3, 2, 2, 2, 1573, 1546, 3, 2, 2, 2, 1573, 1547, 3, 2, 2, 2, 1573, 1548, 3, 2, 2, 2, 1573, 1549, 3, 2, 2, 2, 1573, 1550, 3, 2, 2, 2, 1573, 1551, 3, 2, 2, 2, 1573, 1552, 3, 2, 2, 2, 1573, 1553, 3, 2, 2, 2, 1573, 1554, 3, 2, 2, 2, 1573, 1555, 3, 2, 2, 2, 1573, 1556, 3, 2, 2, 2, 1573, 1557, 3, 2, 2, 2, 1573, 1558, 3, 2, 2, 2, 1573, 1559, 3, 2, 2, 2, 1573, 1560, 3, 2, 2, 2, 1573, 1561, 3, 2, 2, 2, 1573, 1562, 3, 2, 2, 2, 1573, 1563, 3, 2, 2, 2, 1573, 1564, 3, 2, 2, 2, 1573, 1565, 3, 2, 2, 2, 1573, 1566, 3, 2, 2, 2, 1573, 1567, 3, 2, 2, 2, 1573, 1568, 3, 2, 2, 2, 1573, 1569, 3, 2, 2, 2, 1573, 1570, 3, 2, 2, 2, 1573, 1571, 3, 2, 2, 2, 1573, 1572, 3, 2, 2, 2, 1574, 319, 3, 2, 2, 2, 1575, 1576, 5, 318, 158, 2, 1576, 1577, 7, 66, 2, 2, 1577, 321, 3, 2, 2, 2, 1578, 1579, 7, 38, 2, 2, 1579, 1580, 5, 318, 158, 2, 1580, 323, 3, 2, 2, 2, 1581, 1584, 7, 41, 2, 2, 1582, 1585, 5, 326, 162, 2, 1583, 1585, 10, 12, 2, 2, 1584, 1582, 3, 2, 2, 2, 1584, 1583, 3, 2, 2, 2, 1585, 1586, 3, 2, 2, 2, 1586, 1587, 7, 41, 2, 2, 1587, 325, 3, 2, 2, 2, 1588, 1591, 5, 328, 163, 2, 1589, 1591, 5, 330, 164, 2, 1590, 1588, 3, 2, 2, 2, 1590, 1589, 3, 2, 2, 2, 1591, 327, 3, 2, 2, 2, 1592, 1593, 7, 94, 2, 2, 1593, 1594, 7, 119, 2, 2, 1594, 1595, 5, 304, 151, 2, 1595, 1596, 5, 304, 151, 2, 1596, 1597, 5, 304, 151, 2, 1597, 1598, 5, 304, 151, 2, 1598, 329, 3, 2, 2, 2, 1599, 1600, 7, 94, 2, 2, 1600, 1601, 9, 13, 2, 2, 1601, 331, 3, 2, 2, 2, 1602, 1609, 5, 336, 167, 2, 1603, 1609, 5, 338, 168, 2, 1604, 1609, 5, 340, 169, 2, 1605, 1609, 5, 342, 170, 2, 1606, 1609, 5, 344, 171, 2, 1607, 1609, 5, 348, 173, 2, 1608, 1602, 3, 2, 2, 2, 1608, 1603, 3, 2, 2, 2, 1608, 1604, 3, 2, 2, 2, 1608, 1605, 3, 2, 2, 2, 1608, 1606, 3, 2, 2, 2, 1608, 1607, 3, 2, 2, 2, 1609, 333, 3, 2, 2, 2, 1610, 1611, 11, 2, 2, 2, 1611, 335, 3, 2, 2, 2, 1612, 1613, 9, 14, 2, 2, 1613, 337, 3, 2, 2, 2, 1614, 1615, 9, 15, 2, 2, 1615, 339, 3, 2, 2, 2, 1616, 1617, 9, 16, 2, 2, 1617, 341, 3, 2, 2, 2, 1618, 1619, 9, 17, 2, 2, 1619, 343, 3, 2, 2, 2, 1620, 1621, 9, 18, 2, 2, 1621, 345, 3, 2, 2, 2, 1622, 1623, 9, 19, 2, 2, 1623, 347, 3, 2, 2, 2, 1624, 1625, 9, 20, 2, 2, 1625, 349, 3, 2, 2, 2, 1626, 1627, 5, 26, 12, 2, 1627, 1628, 3, 2, 2, 2, 1628, 1629, 8, 174, 4, 2, 1629, 1630, 8, 174, 8, 2, 1630, 351, 3, 2, 2, 2, 1631, 1632, 5, 30, 14, 2, 1632, 1633, 3, 2, 2, 2, 1633, 1634, 8, 175, 4, 2, 1634, 1635, 8, 175, 9, 2, 1635, 353, 3, 2, 2, 2, 1636, 1637, 5, 24, 11, 2, 1637, 1638, 3, 2, 2, 2, 1638, 1639, 8, 176, 3, 2, 1639, 1640, 8, 176, 10, 2, 1640, 355, 3, 2, 2, 2, 1641, 1642, 5, 28, 13, 2, 1642, 1643, 3, 2, 2, 2, 1643, 1644, 8, 177, 3, 2, 1644, 1645, 8, 177, 11, 2, 1645, 357, 3, 2, 2, 2, 1646, 1647, 5, 32, 15, 2, 1647, 1648, 3, 2, 2, 2, 1648, 1649, 8, 178, 5, 2, 1649, 1650, 8, 178, 12, 2, 1650, 359, 3, 2, 2, 2, 1651, 1652, 5, 34, 16, 2, 1652, 1653, 3, 2, 2, 2, 1653, 1654, 8, 179, 4, 2, 1654, 1655, 8, 179, 13, 2, 1655, 361, 3, 2, 2, 2, 1656, 1657, 5, 20, 9, 2, 1657, 1658, 3, 2, 2, 2, 1658, 1659, 8, 180, 14, 2, 1659, 363, 3, 2, 2, 2, 1660, 1661, 5, 22, 10, 2, 1661, 1662, 3, 2, 2, 2, 1662, 1663, 8, 181, 15, 2, 1663, 365, 3, 2, 2, 2, 1664, 1665, 5, 36, 17, 2, 1665, 1666, 3, 2, 2, 2, 1666, 1667, 8, 182, 16, 2, 1667, 367, 3, 2, 2, 2, 1668, 1669, 5, 38, 18, 2, 1669, 1670, 3, 2, 2, 2, 1670, 1671, 8, 183, 17, 2, 1671, 369, 3, 2, 2, 2, 1672, 1673, 5, 40, 19, 2, 1673, 1674, 3, 2, 2, 2, 1674, 1675, 8, 184, 18, 2, 1675, 371, 3, 2, 2, 2, 1676, 1677, 5, 42, 20, 2, 1677, 1678, 3, 2, 2, 2, 1678, 1679, 8, 185, 19, 2, 1679, 373, 3, 2, 2, 2, 1680, 1681, 5, 44, 21, 2, 1681, 1682, 3, 2, 2, 2, 1682, 1683, 8, 186, 20, 2, 1683, 375, 3, 2, 2, 2, 1684, 1685, 5, 46, 22, 2, 1685, 1686, 3, 2, 2, 2, 1686, 1687, 8, 187, 21, 2, 1687, 377, 3, 2, 2, 2, 1688, 1689, 5, 48, 23, 2, 1689, 1690, 3, 2, 2, 2, 1690, 1691, 8, 188, 22, 2, 1691, 379, 3, 2, 2, 2, 1692, 1693, 5, 50, 24, 2, 1693, 1694, 3, 2, 2, 2, 1694, 1695, 8, 189, 23, 2, 1695, 381, 3, 2, 2, 2, 1696, 1697, 5, 52, 25, 2, 1697, 1698, 3, 2, 2, 2, 1698, 1699, 8, 190, 24, 2, 1699, 383, 3, 2, 2, 2, 1700, 1703, 7, 35, 2, 2, 1701, 1704, 5, 16, 7, 2, 1702, 1704, 5, 14, 6, 2, 1703, 1701, 3, 2, 2, 2, 1703, 1702, 3, 2, 2, 2, 1704, 1705, 3, 2, 2, 2, 1705, 1706, 8, 191, 25, 2, 1706, 385, 3, 2, 2, 2, 1707, 1708, 5, 56, 27, 2, 1708, 1709, 3, 2, 2, 2, 1709, 1710, 8, 192, 26, 2, 1710, 387, 3, 2, 2, 2, 1711, 1712, 5, 58, 28, 2, 1712, 1713, 3, 2, 2, 2, 1713, 1714, 8, 193, 27, 2, 1714, 389, 3, 2, 2, 2, 1715, 1716, 5, 60, 29, 2, 1716, 1717, 3, 2, 2, 2, 1717, 1718, 8, 194, 28, 2, 1718, 391, 3, 2, 2, 2, 1719, 1720, 5, 62, 30, 2, 1720, 1721, 3, 2, 2, 2, 1721, 1722, 8, 195, 29, 2, 1722, 393, 3, 2, 2, 2, 1723, 1724, 5, 64, 31, 2, 1724, 1725, 3, 2, 2, 2, 1725, 1726, 8, 196, 30, 2, 1726, 395, 3, 2, 2, 2, 1727, 1728, 5, 66, 32, 2, 1728, 1729, 3, 2, 2, 2, 1729, 1730, 8, 197, 31, 2, 1730, 397, 3, 2, 2, 2, 1731, 1732, 5, 68, 33, 2, 1732, 1733, 3, 2, 2, 2, 1733, 1734, 8, 198, 32, 2, 1734, 399, 3, 2, 2, 2, 1735, 1736, 5, 70, 34, 2, 1736, 1737, 3, 2, 2, 2, 1737, 1738, 8, 199, 33, 2, 1738, 401, 3, 2, 2, 2, 1739, 1740, 5, 72, 35, 2, 1740, 1741, 3, 2, 2, 2, 1741, 1742, 8, 200, 34, 2, 1742, 403, 3, 2, 2, 2, 1743, 1744, 5, 74, 36, 2, 1744, 1745, 3, 2, 2, 2, 1745, 1746, 8, 201, 35, 2, 1746, 405, 3, 2, 2, 2, 1747, 1748, 5, 76, 37, 2, 1748, 1749, 3, 2, 2, 2, 1749, 1750, 8, 202, 36, 2, 1750, 407, 3, 2, 2, 2, 1751, 1752, 5, 78, 38, 2, 1752, 1753, 3, 2, 2, 2, 1753, 1754, 8, 203, 37, 2, 1754, 409, 3, 2, 2, 2, 1755, 1756, 5, 18, 8, 2, 1756, 1757, 3, 2, 2, 2, 1757, 1758, 8, 204, 38, 2, 1758, 411, 3, 2, 2, 2, 1759, 1760, 5, 80, 39, 2, 1760, 1761, 3, 2, 2, 2, 1761, 1762, 8, 205, 39, 2, 1762, 413, 3, 2, 2, 2, 1763, 1764, 5, 82, 40, 2, 1764, 1765, 3, 2, 2, 2, 1765, 1766, 8, 206, 40, 2, 1766, 415, 3, 2, 2, 2, 1767, 1768, 5, 84, 41, 2, 1768, 1769, 3, 2, 2, 2, 1769, 1770, 8, 207, 41, 2, 1770, 417, 3, 2, 2, 2, 1771, 1772, 5, 86, 42, 2, 1772, 1773, 3, 2, 2, 2, 1773, 1774, 8, 208, 42, 2, 1774, 419, 3, 2, 2, 2, 1775, 1778, 7, 65, 2, 2, 1776, 1779, 5, 16, 7, 2, 1777, 1779, 5, 14, 6, 2, 1778, 1776, 3, 2, 2, 2, 1778, 1777, 3, 2, 2, 2, 1779, 1780, 3, 2, 2, 2, 1780, 1781, 8, 209, 43, 2, 1781, 421, 3, 2, 2, 2, 1782, 1783, 5, 92, 45, 2, 1783, 1784, 3, 2, 2, 2, 1784, 1785, 8, 210, 44, 2, 1785, 423, 3, 2, 2, 2, 1786, 1787, 5, 94, 46, 2, 1787, 1788, 3, 2, 2, 2, 1788, 1789, 8, 211, 45, 2, 1789, 425, 3, 2, 2, 2, 1790, 1791, 5, 96, 47, 2, 1791, 1792, 3, 2, 2, 2, 1792, 1793, 8, 212, 46, 2, 1793, 427, 3, 2, 2, 2, 1794, 1795, 5, 98, 48, 2, 1795, 1796, 3, 2, 2, 2, 1796, 1797, 8, 213, 47, 2, 1797, 429, 3, 2, 2, 2, 1798, 1799, 5, 100, 49, 2, 1799, 1800, 3, 2, 2, 2, 1800, 1801, 8, 214, 48, 2, 1801, 431, 3, 2, 2, 2, 1802, 1803, 5, 102, 50, 2, 1803, 1804, 3, 2, 2, 2, 1804, 1805, 8, 215, 49, 2, 1805, 433, 3, 2, 2, 2, 1806, 1807, 5, 104, 51, 2, 1807, 1808, 3, 2, 2, 2, 1808, 1809, 8, 216, 50, 2, 1809, 435, 3, 2, 2, 2, 1810, 1811, 5, 186, 92, 2, 1811, 1812, 3, 2, 2, 2, 1812, 1813, 8, 217, 51, 2, 1813, 437, 3, 2, 2, 2, 1814, 1815, 5, 190, 94, 2, 1815, 1816, 3, 2, 2, 2, 1816, 1817, 8, 218, 52, 2, 1817, 439, 3, 2, 2, 2, 1818, 1819, 5, 192, 95, 2, 1819, 1820, 3, 2, 2, 2, 1820, 1821, 8, 219, 53, 2, 1821, 441, 3, 2, 2, 2, 1822, 1823, 5, 184, 91, 2, 1823, 1824, 3, 2, 2, 2, 1824, 1825, 8, 220, 54, 2, 1825, 443, 3, 2, 2, 2, 1826, 1827, 5, 106, 52, 2, 1827, 1828, 3, 2, 2, 2, 1828, 1829, 8, 221, 55, 2, 1829, 445, 3, 2, 2, 2, 1830, 1831, 5, 108, 53, 2, 1831, 1832, 3, 2, 2, 2, 1832, 1833, 8, 222, 56, 2, 1833, 447, 3, 2, 2, 2, 1834, 1835, 5, 110, 54, 2, 1835, 1836, 3, 2, 2, 2, 1836, 1837, 8, 223, 57, 2, 1837, 449, 3, 2, 2, 2, 1838, 1839, 5, 112, 55, 2, 1839, 1840, 3, 2, 2, 2, 1840, 1841, 8, 224, 58, 2, 1841, 451, 3, 2, 2, 2, 1842, 1843, 5, 274, 136, 2, 1843, 1844, 3, 2, 2, 2, 1844, 1845, 8, 225, 6, 2, 1845, 1846, 8, 225, 59, 2, 1846, 453, 3, 2, 2, 2, 1847, 1848, 5, 276, 137, 2, 1848, 1849, 3, 2, 2, 2, 1849, 1850, 8, 226, 7, 2, 1850, 1851, 8, 226, 60, 2, 1851, 455, 3, 2, 2, 2, 1852, 1853, 5, 136, 67, 2, 1853, 1854, 3, 2, 2, 2, 1854, 1855, 8, 227, 61, 2, 1855, 457, 3, 2, 2, 2, 1856, 1857, 5, 138, 68, 2, 1857, 1858, 3, 2, 2, 2, 1858, 1859, 8, 228, 62, 2, 1859, 459, 3, 2, 2, 2, 1860, 1861, 5, 132, 65, 2, 1861, 1862, 3, 2, 2, 2, 1862, 1863, 8, 229, 63, 2, 1863, 461, 3, 2, 2, 2, 1864, 1865, 5, 134, 66, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1867, 8, 230, 64, 2, 1867, 463, 3, 2, 2, 2, 1868, 1869, 5, 152, 75, 2, 1869, 1870, 3, 2, 2, 2, 1870, 1871, 8, 231, 65, 2, 1871, 465, 3, 2, 2, 2, 1872, 1873, 5, 188, 93, 2, 1873, 1874, 3, 2, 2, 2, 1874, 1875, 8, 232, 66, 2, 1875, 467, 3, 2, 2, 2, 1876, 1877, 5, 194, 96, 2, 1877, 1878, 3, 2, 2, 2, 1878, 1879, 8, 233, 67, 2, 1879, 469, 3, 2, 2, 2, 1880, 1881, 5, 204, 101, 2, 1881, 1882, 3, 2, 2, 2, 1882, 1883, 8, 234, 68, 2, 1883, 471, 3, 2, 2, 2, 1884, 1885, 5, 202, 100, 2, 1885, 1886, 3, 2, 2, 2, 1886, 1887, 8, 235, 69, 2, 1887, 473, 3, 2, 2, 2, 1888, 1889, 5, 206, 102, 2, 1889, 1890, 3, 2, 2, 2, 1890, 1891, 8, 236, 70, 2, 1891, 475, 3, 2, 2, 2, 1892, 1893, 5, 208, 103, 2, 1893, 1894, 3, 2, 2, 2, 1894, 1895, 8, 237, 71, 2, 1895, 477, 3, 2, 2, 2, 1896, 1897, 5, 210, 104, 2, 1897, 1898, 3, 2, 2, 2, 1898, 1899, 8, 238, 72, 2, 1899, 479, 3, 2, 2, 2, 1900, 1901, 5, 212, 105, 2, 1901, 1902, 3, 2, 2, 2, 1902, 1903, 8, 239, 73, 2, 1903, 481, 3, 2, 2, 2, 1904, 1905, 5, 214, 106, 2, 1905, 1906, 3, 2, 2, 2, 1906, 1907, 8, 240, 74, 2, 1907, 483, 3, 2, 2, 2, 1908, 1909, 5, 216, 107, 2, 1909, 1910, 3, 2, 2, 2, 1910, 1911, 8, 241, 75, 2, 1911, 485, 3, 2, 2, 2, 1912, 1913, 5, 218, 108, 2, 1913, 1914, 3, 2, 2, 2, 1914, 1915, 8, 242, 76, 2, 1915, 487, 3, 2, 2, 2, 1916, 1917, 5, 176, 87, 2, 1917, 1918, 3, 2, 2, 2, 1918, 1919, 8, 243, 77, 2, 1919, 489, 3, 2, 2, 2, 1920, 1921, 5, 178, 88, 2, 1921, 1922, 3, 2, 2, 2, 1922, 1923, 8, 244, 78, 2, 1923, 491, 3, 2, 2, 2, 1924, 1925, 5, 180, 89, 2, 1925, 1926, 3, 2, 2, 2, 1926, 1927, 8, 245, 79, 2, 1927, 493, 3, 2, 2, 2, 1928, 1929, 5, 182, 90, 2, 1929, 1930, 3, 2, 2, 2, 1930, 1931, 8, 246, 80, 2, 1931, 495, 3, 2, 2, 2, 1932, 1933, 5, 114, 56, 2, 1933, 1934, 3, 2, 2, 2, 1934, 1935, 8, 247, 81, 2, 1935, 497, 3, 2, 2, 2, 1936, 1937, 5, 116, 57, 2, 1937, 1938, 3, 2, 2, 2, 1938, 1939, 8, 248, 82, 2, 1939, 499, 3, 2, 2, 2, 1940, 1941, 5, 118, 58, 2, 1941, 1942, 3, 2, 2, 2, 1942, 1943, 8, 249, 83, 2, 1943, 501, 3, 2, 2, 2, 1944, 1945, 5, 158, 78, 2, 1945, 1946, 3, 2, 2, 2, 1946, 1947, 8, 250, 84, 2, 1947, 503, 3, 2, 2, 2, 1948, 1949, 5, 160, 79, 2, 1949, 1950, 3, 2, 2, 2, 1950, 1951, 8, 251, 85, 2, 1951, 505, 3, 2, 2, 2, 1952, 1953, 5, 162, 80, 2, 1953, 1954, 3, 2, 2, 2, 1954, 1955, 8, 252, 86, 2, 1955, 507, 3, 2, 2, 2, 1956, 1957, 5, 164, 81, 2, 1957, 1958, 3, 2, 2, 2, 1958, 1959, 8, 253, 87, 2, 1959, 509, 3, 2, 2, 2, 1960, 1961, 5, 166, 82, 2, 1961, 1962, 3, 2, 2, 2, 1962, 1963, 8, 254, 88, 2, 1963, 511, 3, 2, 2, 2, 1964, 1965, 5, 168, 83, 2, 1965, 1966, 3, 2, 2, 2, 1966, 1967, 8, 255, 89, 2, 1967, 513, 3, 2, 2, 2, 1968, 1969, 5, 170, 84, 2, 1969, 1970, 3, 2, 2, 2, 1970, 1971, 8, 256, 90, 2, 1971, 515, 3, 2, 2, 2, 1972, 1973, 5, 172, 85, 2, 1973, 1974, 3, 2, 2, 2, 1974, 1975, 8, 257, 91, 2, 1975, 517, 3, 2, 2, 2, 1976, 1977, 5, 174, 86, 2, 1977, 1978, 3, 2, 2, 2, 1978, 1979, 8, 258, 92, 2, 1979, 519, 3, 2, 2, 2, 1980, 1981, 5, 220, 109, 2, 1981, 1982, 3, 2, 2, 2, 1982, 1983, 8, 259, 93, 2, 1983, 521, 3, 2, 2, 2, 1984, 1985, 5, 222, 110, 2, 1985, 1986, 3, 2, 2, 2, 1986, 1987, 8, 260, 94, 2, 1987, 523, 3, 2, 2, 2, 1988, 1989, 5, 224, 111, 2, 1989, 1990, 3, 2, 2, 2, 1990, 1991, 8, 261, 95, 2, 1991, 525, 3, 2, 2, 2, 1992, 1993, 5, 226, 112, 2, 1993, 1994, 3, 2, 2, 2, 1994, 1995, 8, 262, 96, 2, 1995, 527, 3, 2, 2, 2, 1996, 1997, 5, 228, 113, 2, 1997, 1998, 3, 2, 2, 2, 1998, 1999, 8, 263, 97, 2, 1999, 529, 3, 2, 2, 2, 2000, 2001, 5, 230, 114, 2, 2001, 2002, 3, 2, 2, 2, 2002, 2003, 8, 264, 98, 2, 2003, 531, 3, 2, 2, 2, 2004, 2005, 5, 232, 115, 2, 2005, 2006, 3, 2, 2, 2, 2006, 2007, 8, 265, 99, 2, 2007, 533, 3, 2, 2, 2, 2008, 2009, 5, 234, 116, 2, 2009, 2010, 3, 2, 2, 2, 2010, 2011, 8, 266, 100, 2, 2011, 535, 3, 2, 2, 2, 2012, 2013, 5, 236, 117, 2, 2013, 2014, 3, 2, 2, 2, 2014, 2015, 8, 267, 101, 2, 2015, 537, 3, 2, 2, 2, 2016, 2017, 5, 238, 118, 2, 2017, 2018, 3, 2, 2, 2, 2018, 2019, 8, 268, 102, 2, 2019, 539, 3, 2, 2, 2, 2020, 2021, 5, 240, 119, 2, 2021, 2022, 3, 2, 2, 2, 2022, 2023, 8, 269, 103, 2, 2023, 541, 3, 2, 2, 2, 2024, 2025, 5, 242, 120, 2, 2025, 2026, 3, 2, 2, 2, 2026, 2027, 8, 270, 104, 2, 2027, 543, 3, 2, 2, 2, 2028, 2029, 5, 244, 121, 2, 2029, 2030, 3, 2, 2, 2, 2030, 2031, 8, 271, 105, 2, 2031, 545, 3, 2, 2, 2, 2032, 2033, 5, 246, 122, 2, 2033, 2034, 3, 2, 2, 2, 2034, 2035, 8, 272, 106, 2, 2035, 547, 3, 2, 2, 2, 2036, 2037, 5, 248, 123, 2, 2037, 2038, 3, 2, 2, 2, 2038, 2039, 8, 273, 107, 2, 2039, 549, 3, 2, 2, 2, 2040, 2041, 5, 250, 124, 2, 2041, 2042, 3, 2, 2, 2, 2042, 2043, 8, 274, 108, 2, 2043, 551, 3, 2, 2, 2, 2044, 2045, 5, 252, 125, 2, 2045, 2046, 3, 2, 2, 2, 2046, 2047, 8, 275, 109, 2, 2047, 553, 3, 2, 2, 2, 2048, 2049, 5, 254, 126, 2, 2049, 2050, 3, 2, 2, 2, 2050, 2051, 8, 276, 110, 2, 2051, 555, 3, 2, 2, 2, 2052, 2053, 5, 256, 127, 2, 2053, 2054, 3, 2, 2, 2, 2054, 2055, 8, 277, 111, 2, 2055, 557, 3, 2, 2, 2, 2056, 2057, 5, 258, 128, 2, 2057, 2058, 3, 2, 2, 2, 2058, 2059, 8, 278, 112, 2, 2059, 559, 3, 2, 2, 2, 2060, 2061, 5, 260, 129, 2, 2061, 2062, 3, 2, 2, 2, 2062, 2063, 8, 279, 113, 2, 2063, 561, 3, 2, 2, 2, 2064, 2065, 5, 262, 130, 2, 2065, 2066, 3, 2, 2, 2, 2066, 2067, 8, 280, 114, 2, 2067, 563, 3, 2, 2, 2, 2068, 2069, 5, 264, 131, 2, 2069, 2070, 3, 2, 2, 2, 2070, 2071, 8, 281, 115, 2, 2071, 565, 3, 2, 2, 2, 2072, 2073, 5, 266, 132, 2, 2073, 2074, 3, 2, 2, 2, 2074, 2075, 8, 282, 116, 2, 2075, 567, 3, 2, 2, 2, 2076, 2077, 5, 268, 133, 2, 2077, 2078, 3, 2, 2, 2, 2078, 2079, 8, 283, 117, 2, 2079, 569, 3, 2, 2, 2, 2080, 2081, 5, 270, 134, 2, 2081, 2082, 3, 2, 2, 2, 2082, 2083, 8, 284, 118, 2, 2083, 571, 3, 2, 2, 2, 2084, 2085, 5, 272, 135, 2, 2085, 2086, 3, 2, 2, 2, 2086, 2087, 8, 285, 119, 2, 2087, 573, 3, 2, 2, 2, 2088, 2089, 5, 312, 155, 2, 2089, 2090, 3, 2, 2, 2, 2090, 2091, 8, 286, 120, 2, 2091, 575, 3, 2, 2, 2, 2092, 2093, 5, 292, 145, 2, 2093, 2094, 3, 2, 2, 2, 2094, 2095, 8, 287, 121, 2, 2095, 577, 3, 2, 2, 2, 2096, 2097, 5, 302, 150, 2, 2097, 2098, 3, 2, 2, 2, 2098, 2099, 8, 288, 122, 2, 2099, 579, 3, 2, 2, 2, 2100, 2101, 5, 308, 153, 2, 2101, 2102, 3, 2, 2, 2, 2102, 2103, 8, 289, 123, 2, 2103, 581, 3, 2, 2, 2, 2104, 2105, 5, 324, 161, 2, 2105, 2106, 3, 2, 2, 2, 2106, 2107, 8, 290, 124, 2, 2107, 583, 3, 2, 2, 2, 2108, 2109, 5, 278, 138, 2, 2109, 2110, 3, 2, 2, 2, 2110, 2111, 8, 291, 125, 2, 2111, 585, 3, 2, 2, 2, 2112, 2113, 5, 314, 156, 2, 2113, 2114, 3, 2, 2, 2, 2114, 2115, 8, 292, 126, 2, 2115, 587, 3, 2, 2, 2, 2116, 2117, 5, 290, 144, 2, 2117, 2118, 3, 2, 2, 2, 2118, 2119, 8, 293, 127, 2, 2119, 589, 3, 2, 2, 2, 2120, 2121, 5, 316, 157, 2, 2121, 2122, 3, 2, 2, 2, 2122, 2123, 8, 294, 128, 2, 2123, 591, 3, 2, 2, 2, 2124, 2125, 5, 320, 159, 2, 2125, 2126, 3, 2, 2, 2, 2126, 2127, 8, 295, 129, 2, 2127, 593, 3, 2, 2, 2, 2128, 2131, 5, 10, 4, 2, 2129, 2131, 5, 8, 3, 2, 2130, 2128, 3, 2, 2, 2, 2130, 2129, 3, 2, 2, 2, 2131, 2132, 3, 2, 2, 2, 2132, 2133, 8, 296, 2, 2, 2133, 595, 3, 2, 2, 2, 2134, 2135, 5, 12, 5, 2, 2135, 2136, 3, 2, 2, 2, 2136, 2137, 8, 297, 2, 2, 2137, 597, 3, 2, 2, 2, 2138, 2139, 5, 14, 6, 2, 2139, 2140, 3, 2, 2, 2, 2140, 2141, 8, 298, 2, 2, 2141, 599, 3, 2, 2, 2, 2142, 2143, 7, 36, 2, 2, 2143, 2144, 3, 2, 2, 2, 2144, 2145, 8, 299, 4, 2, 2145, 601, 3, 2, 2, 2, 2146, 2147, 5, 322, 160, 2, 2147, 603, 3, 2, 2, 2, 2148, 2150, 10, 21, 2, 2, 2149, 2148, 3, 2, 2, 2, 2150, 2151, 3, 2, 2, 2, 2151, 2149, 3, 2, 2, 2, 2151, 2152, 3, 2, 2, 2, 2152, 2155, 3, 2, 2, 2, 2153, 2155, 7, 38, 2, 2, 2154, 2149, 3, 2, 2, 2, 2154, 2153, 3, 2, 2, 2, 2155, 605, 3, 2, 2, 2, 2156, 2159, 5, 330, 164, 2, 2157, 2159, 5, 328, 163, 2, 2158, 2156, 3, 2, 2, 2, 2158, 2157, 3, 2, 2, 2, 2159, 607, 3, 2, 2, 2, 2160, 2161, 7, 38, 2, 2, 2161, 2162, 7, 125, 2, 2, 2162, 2163, 3, 2, 2, 2, 2163, 2164, 8, 303, 5, 2, 2164, 609, 3, 2, 2, 2, 2165, 2167, 5, 612, 305, 2, 2166, 2165, 3, 2, 2, 2, 2166, 2167, 3, 2, 2, 2, 2167, 2168, 3, 2, 2, 2, 2168, 2169, 7, 36, 2, 2, 2169, 2170, 7, 36, 2, 2, 2170, 2171, 7, 36, 2, 2, 2171, 2172, 3, 2, 2, 2, 2172, 2173, 8, 304, 4, 2, 2173, 611, 3, 2, 2, 2, 2174, 2176, 7, 36, 2, 2, 2175, 2174, 3, 2, 2, 2, 2176, 2177, 3, 2, 2, 2, 2177, 2175, 3, 2, 2, 2, 2177, 2178, 3, 2, 2, 2, 2178, 613, 3, 2, 2, 2, 2179, 2180, 5, 322, 160, 2, 2180, 615, 3, 2, 2, 2, 2181, 2183, 10, 22, 2, 2, 2182, 2181, 3, 2, 2, 2, 2183, 2184, 3, 2, 2, 2, 2184, 2182, 3, 2, 2, 2, 2184, 2185, 3, 2, 2, 2, 2185, 2188, 3, 2, 2, 2, 2186, 2188, 7, 38, 2, 2, 2187, 2182, 3, 2, 2, 2, 2187, 2186, 3, 2, 2, 2, 2188, 617, 3, 2, 2, 2, 2189, 2190, 7, 38, 2, 2, 2190, 2191, 7, 125, 2, 2, 2191, 2192, 3, 2, 2, 2, 2192, 2193, 8, 308, 5, 2, 2193, 619, 3, 2, 2, 2, 2194, 2195, 5, 14, 6, 2, 2195, 2196, 3, 2, 2, 2, 2196, 2197, 8, 309, 130, 2, 2197, 621, 3, 2, 2, 2, 54, 2, 3, 4, 5, 628, 636, 638, 652, 664, 666, 671, 775, 1061, 1069, 1382, 1390, 1394, 1400, 1406, 1410, 1415, 1420, 1425, 1430, 1438, 1444, 1454, 1462, 1470, 1476, 1484, 1492, 1505, 1514, 1519, 1521, 1528, 1531, 1573, 1584, 1590, 1608, 1703, 1778, 2130, 2151, 2154, 2158, 2166, 2177, 2184, 2187, 131, 2, 3, 2, 7, 3, 2, 6, 2, 2, 7, 2, 2, 7, 4, 2, 7, 5, 2, 9, 12, 2, 9, 14, 2, 9, 11, 2, 9, 13, 2, 9, 15, 2, 9, 16, 2, 9, 9, 2, 9, 10, 2, 9, 17, 2, 9, 18, 2, 9, 19, 2, 9, 20, 2, 9, 21, 2, 9, 22, 2, 9, 23, 2, 9, 24, 2, 9, 25, 2, 9, 26, 2, 9, 27, 2, 9, 28, 2, 9, 29, 2, 9, 30, 2, 9, 31, 2, 9, 32, 2, 9, 33, 2, 9, 34, 2, 9, 35, 2, 9, 36, 2, 9, 37, 2, 9, 38, 2, 9, 8, 2, 9, 39, 2, 9, 40, 2, 9, 41, 2, 9, 42, 2, 9, 44, 2, 9, 45, 2, 9, 46, 2, 9, 47, 2, 9, 48, 2, 9, 49, 2, 9, 50, 2, 9, 51, 2, 9, 92, 2, 9, 94, 2, 9, 95, 2, 9, 91, 2, 9, 52, 2, 9, 53, 2, 9, 54, 2, 9, 55, 2, 9, 136, 2, 9, 137, 2, 9, 67, 2, 9, 68, 2, 9, 65, 2, 9, 66, 2, 9, 75, 2, 9, 93, 2, 9, 96, 2, 9, 101, 2, 9, 100, 2, 9, 102, 2, 9, 103, 2, 9, 104, 2, 9, 105, 2, 9, 106, 2, 9, 107, 2, 9, 108, 2, 9, 87, 2, 9, 88, 2, 9, 89, 2, 9, 90, 2, 9, 56, 2, 9, 57, 2, 9, 58, 2, 9, 78, 2, 9, 79, 2, 9, 80, 2, 9, 81, 2, 9, 82, 2, 9, 83, 2, 9, 84, 2, 9, 85, 2, 9, 86, 2, 9, 109, 2, 9, 110, 2, 9, 111, 2, 9, 112, 2, 9, 113, 2, 9, 114, 2, 9, 115, 2, 9, 116, 2, 9, 117, 2, 9, 118, 2, 9, 119, 2, 9, 120, 2, 9, 121, 2, 9, 122, 2, 9, 123, 2, 9, 124, 2, 9, 125, 2, 9, 126, 2, 9, 127, 2, 9, 128, 2, 9, 129, 2, 9, 130, 2, 9, 131, 2, 9, 132, 2, 9, 133, 2, 9, 134, 2, 9, 135, 2, 9, 145, 2, 9, 142, 2, 9, 143, 2, 9, 144, 2, 9, 150, 2, 9, 138, 2, 9, 146, 2, 9, 141, 2, 9, 147, 2, 9, 148, 2, 9, 7, 2] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.java deleted file mode 100644 index 0faeddd..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.java +++ /dev/null @@ -1,1390 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.kotlin;// Generated from KotlinLexer.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.LexerATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.Utils; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class KotlinLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ShebangLine=1, DelimitedComment=2, LineComment=3, WS=4, NL=5, RESERVED=6, - DOT=7, COMMA=8, LPAREN=9, RPAREN=10, LSQUARE=11, RSQUARE=12, LCURL=13, - RCURL=14, MULT=15, MOD=16, DIV=17, ADD=18, SUB=19, INCR=20, DECR=21, CONJ=22, - DISJ=23, EXCL_WS=24, EXCL_NO_WS=25, COLON=26, SEMICOLON=27, ASSIGNMENT=28, - ADD_ASSIGNMENT=29, SUB_ASSIGNMENT=30, MULT_ASSIGNMENT=31, DIV_ASSIGNMENT=32, - MOD_ASSIGNMENT=33, ARROW=34, DOUBLE_ARROW=35, RANGE=36, COLONCOLON=37, - DOUBLE_SEMICOLON=38, HASH=39, AT=40, AT_WS=41, QUEST_WS=42, QUEST_NO_WS=43, - LANGLE=44, RANGLE=45, LE=46, GE=47, EXCL_EQ=48, EXCL_EQEQ=49, AS_SAFE=50, - EQEQ=51, EQEQEQ=52, SINGLE_QUOTE=53, RETURN_AT=54, CONTINUE_AT=55, BREAK_AT=56, - THIS_AT=57, SUPER_AT=58, PACKAGE=59, IMPORT=60, CLASS=61, INTERFACE=62, - FUN=63, OBJECT=64, VAL=65, VAR=66, TYPE_ALIAS=67, CONSTRUCTOR=68, BY=69, - COMPANION=70, INIT=71, THIS=72, SUPER=73, TYPEOF=74, WHERE=75, IF=76, - ELSE=77, WHEN=78, TRY=79, CATCH=80, FINALLY=81, FOR=82, DO=83, WHILE=84, - THROW=85, RETURN=86, CONTINUE=87, BREAK=88, AS=89, IS=90, IN=91, NOT_IS=92, - NOT_IN=93, OUT=94, GETTER=95, SETTER=96, DYNAMIC=97, AT_FILE=98, AT_FIELD=99, - AT_PROPERTY=100, AT_GET=101, AT_SET=102, AT_RECEIVER=103, AT_PARAM=104, - AT_SETPARAM=105, AT_DELEGATE=106, PUBLIC=107, PRIVATE=108, PROTECTED=109, - INTERNAL=110, ENUM=111, SEALED=112, ANNOTATION=113, DATA=114, INNER=115, - TAILREC=116, OPERATOR=117, INLINE=118, INFIX=119, EXTERNAL=120, SUSPEND=121, - OVERRIDE=122, ABSTRACT=123, FINAL=124, OPEN=125, CONST=126, LATEINIT=127, - VARARG=128, NOINLINE=129, CROSSINLINE=130, REIFIED=131, EXPECT=132, ACTUAL=133, - QUOTE_OPEN=134, TRIPLE_QUOTE_OPEN=135, RealLiteral=136, FloatLiteral=137, - DoubleLiteral=138, LongLiteral=139, IntegerLiteral=140, HexLiteral=141, - BinLiteral=142, BooleanLiteral=143, NullLiteral=144, Identifier=145, IdentifierAt=146, - FieldIdentifier=147, CharacterLiteral=148, ErrorCharacter=149, UNICODE_CLASS_LL=150, - UNICODE_CLASS_LM=151, UNICODE_CLASS_LO=152, UNICODE_CLASS_LT=153, UNICODE_CLASS_LU=154, - UNICODE_CLASS_ND=155, UNICODE_CLASS_NL=156, Inside_Comment=157, Inside_WS=158, - Inside_NL=159, QUOTE_CLOSE=160, LineStrRef=161, LineStrText=162, LineStrEscapedChar=163, - LineStrExprStart=164, TRIPLE_QUOTE_CLOSE=165, MultiLineStringQuote=166, - MultiLineStrRef=167, MultiLineStrText=168, MultiLineStrExprStart=169; - public static final int - Inside=1, LineString=2, MultiLineString=3; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; - - public static String[] modeNames = { - "DEFAULT_MODE", "Inside", "LineString", "MultiLineString" - }; - - private static String[] makeRuleNames() { - return new String[] { - "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "Hidden", - "RESERVED", "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", - "LCURL", "RCURL", "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", - "CONJ", "DISJ", "EXCL_WS", "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", - "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", - "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", - "HASH", "AT", "AT_WS", "QUEST_WS", "QUEST_NO_WS", "LANGLE", "RANGLE", - "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", - "RETURN_AT", "CONTINUE_AT", "BREAK_AT", "THIS_AT", "SUPER_AT", "PACKAGE", - "IMPORT", "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", - "CONSTRUCTOR", "BY", "COMPANION", "INIT", "THIS", "SUPER", "TYPEOF", - "WHERE", "IF", "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", "DO", - "WHILE", "THROW", "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", "NOT_IS", - "NOT_IN", "OUT", "GETTER", "SETTER", "DYNAMIC", "AT_FILE", "AT_FIELD", - "AT_PROPERTY", "AT_GET", "AT_SET", "AT_RECEIVER", "AT_PARAM", "AT_SETPARAM", - "AT_DELEGATE", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", - "SEALED", "ANNOTATION", "DATA", "INNER", "TAILREC", "OPERATOR", "INLINE", - "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", "OPEN", - "CONST", "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", - "EXPECT", "ACTUAL", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", "RealLiteral", - "FloatLiteral", "DecDigitOrSeparator", "DecDigits", "DoubleExponent", - "DoubleLiteral", "LongLiteral", "IntegerLiteral", "UnicodeDigit", "DecDigit", - "DecDigitNoZero", "HexDigitOrSeparator", "HexLiteral", "HexDigit", "BinDigitOrSeparator", - "BinLiteral", "BinDigit", "BooleanLiteral", "NullLiteral", "Identifier", - "IdentifierOrSoftKey", "IdentifierAt", "FieldIdentifier", "CharacterLiteral", - "EscapeSeq", "UniCharacterLiteral", "EscapedIdentifier", "Letter", "ErrorCharacter", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "Inside_RPAREN", - "Inside_RSQUARE", "Inside_LPAREN", "Inside_LSQUARE", "Inside_LCURL", - "Inside_RCURL", "Inside_DOT", "Inside_COMMA", "Inside_MULT", "Inside_MOD", - "Inside_DIV", "Inside_ADD", "Inside_SUB", "Inside_INCR", "Inside_DECR", - "Inside_CONJ", "Inside_DISJ", "Inside_EXCL_WS", "Inside_EXCL_NO_WS", - "Inside_COLON", "Inside_SEMICOLON", "Inside_ASSIGNMENT", "Inside_ADD_ASSIGNMENT", - "Inside_SUB_ASSIGNMENT", "Inside_MULT_ASSIGNMENT", "Inside_DIV_ASSIGNMENT", - "Inside_MOD_ASSIGNMENT", "Inside_ARROW", "Inside_DOUBLE_ARROW", "Inside_RANGE", - "Inside_RESERVED", "Inside_COLONCOLON", "Inside_DOUBLE_SEMICOLON", "Inside_HASH", - "Inside_AT", "Inside_QUEST_WS", "Inside_QUEST_NO_WS", "Inside_LANGLE", - "Inside_RANGLE", "Inside_LE", "Inside_GE", "Inside_EXCL_EQ", "Inside_EXCL_EQEQ", - "Inside_IS", "Inside_NOT_IS", "Inside_NOT_IN", "Inside_AS", "Inside_AS_SAFE", - "Inside_EQEQ", "Inside_EQEQEQ", "Inside_SINGLE_QUOTE", "Inside_QUOTE_OPEN", - "Inside_TRIPLE_QUOTE_OPEN", "Inside_VAL", "Inside_VAR", "Inside_FUN", - "Inside_OBJECT", "Inside_SUPER", "Inside_IN", "Inside_OUT", "Inside_AT_FIELD", - "Inside_AT_FILE", "Inside_AT_PROPERTY", "Inside_AT_GET", "Inside_AT_SET", - "Inside_AT_RECEIVER", "Inside_AT_PARAM", "Inside_AT_SETPARAM", "Inside_AT_DELEGATE", - "Inside_THROW", "Inside_RETURN", "Inside_CONTINUE", "Inside_BREAK", "Inside_RETURN_AT", - "Inside_CONTINUE_AT", "Inside_BREAK_AT", "Inside_IF", "Inside_ELSE", - "Inside_WHEN", "Inside_TRY", "Inside_CATCH", "Inside_FINALLY", "Inside_FOR", - "Inside_DO", "Inside_WHILE", "Inside_PUBLIC", "Inside_PRIVATE", "Inside_PROTECTED", - "Inside_INTERNAL", "Inside_ENUM", "Inside_SEALED", "Inside_ANNOTATION", - "Inside_DATA", "Inside_INNER", "Inside_TAILREC", "Inside_OPERATOR", "Inside_INLINE", - "Inside_INFIX", "Inside_EXTERNAL", "Inside_SUSPEND", "Inside_OVERRIDE", - "Inside_ABSTRACT", "Inside_FINAL", "Inside_OPEN", "Inside_CONST", "Inside_LATEINIT", - "Inside_VARARG", "Inside_NOINLINE", "Inside_CROSSINLINE", "Inside_REIFIED", - "Inside_EXPECT", "Inside_ACTUAL", "Inside_BooleanLiteral", "Inside_IntegerLiteral", - "Inside_HexLiteral", "Inside_BinLiteral", "Inside_CharacterLiteral", - "Inside_RealLiteral", "Inside_NullLiteral", "Inside_LongLiteral", "Inside_Identifier", - "Inside_IdentifierAt", "Inside_Comment", "Inside_WS", "Inside_NL", "QUOTE_CLOSE", - "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", - "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", - "MultiLineStrExprStart", "MultiLineNL" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, null, "'...'", "'.'", "','", "'('", "')'", - "'['", "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", - "'--'", "'&&'", "'||'", null, "'!'", "':'", "';'", "'='", "'+='", "'-='", - "'*='", "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", - "'@'", null, null, "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", - "'as?'", "'=='", "'==='", "'''", null, null, null, null, null, "'package'", - "'import'", "'class'", "'interface'", "'fun'", "'object'", "'val'", "'var'", - "'typealias'", "'constructor'", "'by'", "'companion'", "'init'", "'this'", - "'super'", "'typeof'", "'where'", "'if'", "'else'", "'when'", "'try'", - "'catch'", "'finally'", "'for'", "'do'", "'while'", "'throw'", "'return'", - "'continue'", "'break'", "'as'", "'is'", "'in'", null, null, "'out'", - "'get'", "'set'", "'dynamic'", "'@file'", "'@field'", "'@property'", - "'@get'", "'@set'", "'@receiver'", "'@param'", "'@setparam'", "'@delegate'", - "'public'", "'private'", "'protected'", "'internal'", "'enum'", "'sealed'", - "'annotation'", "'data'", "'inner'", "'tailrec'", "'operator'", "'inline'", - "'infix'", "'external'", "'suspend'", "'override'", "'abstract'", "'final'", - "'open'", "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", - "'reified'", "'expect'", "'actual'", null, "'\"\"\"'", null, null, null, - null, null, null, null, null, "'null'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", - "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", - "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL_WS", - "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", - "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", - "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT", "AT_WS", "QUEST_WS", - "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", - "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", - "BREAK_AT", "THIS_AT", "SUPER_AT", "PACKAGE", "IMPORT", "CLASS", "INTERFACE", - "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", - "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", - "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", "RETURN", "CONTINUE", - "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", "OUT", "GETTER", "SETTER", - "DYNAMIC", "AT_FILE", "AT_FIELD", "AT_PROPERTY", "AT_GET", "AT_SET", - "AT_RECEIVER", "AT_PARAM", "AT_SETPARAM", "AT_DELEGATE", "PUBLIC", "PRIVATE", - "PROTECTED", "INTERNAL", "ENUM", "SEALED", "ANNOTATION", "DATA", "INNER", - "TAILREC", "OPERATOR", "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", - "ABSTRACT", "FINAL", "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", - "CROSSINLINE", "REIFIED", "EXPECT", "ACTUAL", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", - "RealLiteral", "FloatLiteral", "DoubleLiteral", "LongLiteral", "IntegerLiteral", - "HexLiteral", "BinLiteral", "BooleanLiteral", "NullLiteral", "Identifier", - "IdentifierAt", "FieldIdentifier", "CharacterLiteral", "ErrorCharacter", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "Inside_Comment", - "Inside_WS", "Inside_NL", "QUOTE_CLOSE", "LineStrRef", "LineStrText", - "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", - "MultiLineStrRef", "MultiLineStrText", "MultiLineStrExprStart" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - public KotlinLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - @Override - public String getGrammarFileName() { return "KotlinLexer.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public String[] getChannelNames() { return channelNames; } - - @Override - public String[] getModeNames() { return modeNames; } - - @Override - public ATN getATN() { return _ATN; } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00ab\u0896\b\1\b"+ - "\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t"+ - "\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4"+ - "\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4"+ - "\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4"+ - "\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)"+ - "\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62"+ - "\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4"+ - ";\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\t"+ - "F\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4"+ - "R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]"+ - "\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th"+ - "\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t"+ - "\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177"+ - "\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083"+ - "\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088"+ - "\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c"+ - "\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091"+ - "\t\u0091\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095"+ - "\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a"+ - "\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e"+ - "\4\u009f\t\u009f\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3"+ - "\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7"+ - "\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac"+ - "\t\u00ac\4\u00ad\t\u00ad\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0"+ - "\4\u00b1\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5"+ - "\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9"+ - "\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be"+ - "\t\u00be\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2"+ - "\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7"+ - "\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb"+ - "\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0"+ - "\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4"+ - "\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9"+ - "\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd"+ - "\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2"+ - "\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6"+ - "\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb"+ - "\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef"+ - "\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4"+ - "\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8"+ - "\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd"+ - "\t\u00fd\4\u00fe\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101"+ - "\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105\4\u0106"+ - "\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109\t\u0109\4\u010a\t\u010a"+ - "\4\u010b\t\u010b\4\u010c\t\u010c\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f"+ - "\t\u010f\4\u0110\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113\t\u0113"+ - "\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116\4\u0117\t\u0117\4\u0118"+ - "\t\u0118\4\u0119\t\u0119\4\u011a\t\u011a\4\u011b\t\u011b\4\u011c\t\u011c"+ - "\4\u011d\t\u011d\4\u011e\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121"+ - "\t\u0121\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124\4\u0125\t\u0125"+ - "\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128\t\u0128\4\u0129\t\u0129\4\u012a"+ - "\t\u012a\4\u012b\t\u012b\4\u012c\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e"+ - "\4\u012f\t\u012f\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132\4\u0133"+ - "\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\3\2\3\2\3\2\3\2\7\2\u0273\n\2"+ - "\f\2\16\2\u0276\13\2\3\3\3\3\3\3\3\3\3\3\7\3\u027d\n\3\f\3\16\3\u0280"+ - "\13\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\7\4\u028b\n\4\f\4\16\4\u028e"+ - "\13\4\3\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\5\6\u0299\n\6\5\6\u029b\n\6"+ - "\3\7\3\7\3\7\5\7\u02a0\n\7\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3"+ - "\13\3\13\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17"+ - "\3\17\3\17\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24"+ - "\3\25\3\25\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31"+ - "\3\32\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3\37"+ - "\3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3%\3%\3%\3&\3&\3&\3\'"+ - "\3\'\3\'\3(\3(\3(\3)\3)\3*\3*\3+\3+\3+\5+\u0308\n+\3,\3,\3,\3-\3-\3.\3"+ - ".\3/\3/\3\60\3\60\3\60\3\61\3\61\3\61\3\62\3\62\3\62\3\63\3\63\3\63\3"+ - "\63\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\67\3\67\3"+ - "8\38\38\38\38\38\38\38\38\38\39\39\39\39\39\39\39\39\39\39\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>\3>\3>\3?\3?\3?\3?\3?\3?\3"+ - "@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3C\3C\3"+ - "C\3C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3"+ - "F\3F\3F\3F\3F\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3"+ - "J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3"+ - "M\3N\3N\3N\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3"+ - "R\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3"+ - "W\3W\3W\3W\3W\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3"+ - "Z\3Z\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3]\3]\3]\3^\3^\3^\3^\3^\3^\5^\u0426\n"+ - "^\3_\3_\3_\3_\3_\3_\5_\u042e\n_\3`\3`\3`\3`\3a\3a\3a\3a\3b\3b\3b\3b\3"+ - "c\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3e\3f\3f\3"+ - "f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3"+ - "i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3l\3"+ - "l\3l\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3"+ - "n\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3p\3p\3q\3q\3q\3"+ - "q\3q\3r\3r\3r\3r\3r\3r\3r\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3"+ - "t\3t\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3"+ - "w\3w\3x\3x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3z\3z\3z\3z\3z\3z\3z\3z\3"+ - "z\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\177\3\177\3\177\3\177\3\177\3\u0080\3\u0080"+ - "\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081"+ - "\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082"+ - "\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083"+ - "\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ - "\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085"+ - "\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086"+ - "\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087"+ - "\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089"+ - "\3\u0089\3\u008a\3\u008a\5\u008a\u0567\n\u008a\3\u008b\3\u008b\3\u008b"+ - "\3\u008b\3\u008b\3\u008b\5\u008b\u056f\n\u008b\3\u008c\3\u008c\5\u008c"+ - "\u0573\n\u008c\3\u008d\3\u008d\7\u008d\u0577\n\u008d\f\u008d\16\u008d"+ - "\u057a\13\u008d\3\u008d\3\u008d\3\u008d\5\u008d\u057f\n\u008d\3\u008e"+ - "\3\u008e\5\u008e\u0583\n\u008e\3\u008e\3\u008e\3\u008f\5\u008f\u0588\n"+ - "\u008f\3\u008f\3\u008f\3\u008f\5\u008f\u058d\n\u008f\3\u008f\3\u008f\3"+ - "\u008f\5\u008f\u0592\n\u008f\3\u0090\3\u0090\3\u0090\5\u0090\u0597\n\u0090"+ - "\3\u0090\3\u0090\3\u0091\3\u0091\7\u0091\u059d\n\u0091\f\u0091\16\u0091"+ - "\u05a0\13\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u05a5\n\u0091\3\u0092"+ - "\3\u0092\3\u0093\3\u0093\3\u0094\3\u0094\3\u0095\3\u0095\5\u0095\u05af"+ - "\n\u0095\3\u0096\3\u0096\3\u0096\3\u0096\7\u0096\u05b5\n\u0096\f\u0096"+ - "\16\u0096\u05b8\13\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\5\u0096"+ - "\u05bf\n\u0096\3\u0097\3\u0097\3\u0098\3\u0098\5\u0098\u05c5\n\u0098\3"+ - "\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u05cb\n\u0099\f\u0099\16\u0099"+ - "\u05ce\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u05d5"+ - "\n\u0099\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ - "\3\u009b\3\u009b\3\u009b\5\u009b\u05e2\n\u009b\3\u009c\3\u009c\3\u009c"+ - "\3\u009c\3\u009c\3\u009d\3\u009d\5\u009d\u05eb\n\u009d\3\u009d\3\u009d"+ - "\3\u009d\7\u009d\u05f0\n\u009d\f\u009d\16\u009d\u05f3\13\u009d\3\u009d"+ - "\3\u009d\6\u009d\u05f7\n\u009d\r\u009d\16\u009d\u05f8\3\u009d\5\u009d"+ - "\u05fc\n\u009d\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+ - "\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+ - "\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+ - "\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+ - "\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\5\u009e\u0626\n\u009e"+ - "\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1"+ - "\5\u00a1\u0631\n\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\5\u00a2\u0637\n"+ - "\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4"+ - "\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\5\u00a5"+ - "\u0649\n\u00a5\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9"+ - "\3\u00a9\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ad\3\u00ad"+ - "\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af\3\u00af\3\u00af"+ - "\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1"+ - "\3\u00b1\3\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3"+ - "\3\u00b3\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5"+ - "\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7"+ - "\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ - "\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc"+ - "\3\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be"+ - "\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u06a8\n\u00bf\3\u00bf"+ - "\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1"+ - "\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4"+ - "\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6"+ - "\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8"+ - "\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+ - "\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd"+ - "\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00cf\3\u00cf"+ - "\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1\3\u00d1"+ - "\5\u00d1\u06f3\n\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2"+ - "\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5"+ - "\3\u00d5\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d7\3\u00d7"+ - "\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9"+ - "\3\u00d9\3\u00da\3\u00da\3\u00da\3\u00da\3\u00db\3\u00db\3\u00db\3\u00db"+ - "\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de"+ - "\3\u00de\3\u00de\3\u00de\3\u00df\3\u00df\3\u00df\3\u00df\3\u00e0\3\u00e0"+ - "\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2\3\u00e2"+ - "\3\u00e2\3\u00e2\3\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3\u00e4"+ - "\3\u00e4\3\u00e4\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e6"+ - "\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8"+ - "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb"+ - "\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed"+ - "\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef"+ - "\3\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1"+ - "\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4"+ - "\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6"+ - "\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8"+ - "\3\u00f8\3\u00f9\3\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa"+ - "\3\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fd"+ - "\3\u00fd\3\u00fd\3\u00fd\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00ff\3\u00ff"+ - "\3\u00ff\3\u00ff\3\u0100\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101"+ - "\3\u0101\3\u0102\3\u0102\3\u0102\3\u0102\3\u0103\3\u0103\3\u0103\3\u0103"+ - "\3\u0104\3\u0104\3\u0104\3\u0104\3\u0105\3\u0105\3\u0105\3\u0105\3\u0106"+ - "\3\u0106\3\u0106\3\u0106\3\u0107\3\u0107\3\u0107\3\u0107\3\u0108\3\u0108"+ - "\3\u0108\3\u0108\3\u0109\3\u0109\3\u0109\3\u0109\3\u010a\3\u010a\3\u010a"+ - "\3\u010a\3\u010b\3\u010b\3\u010b\3\u010b\3\u010c\3\u010c\3\u010c\3\u010c"+ - "\3\u010d\3\u010d\3\u010d\3\u010d\3\u010e\3\u010e\3\u010e\3\u010e\3\u010f"+ - "\3\u010f\3\u010f\3\u010f\3\u0110\3\u0110\3\u0110\3\u0110\3\u0111\3\u0111"+ - "\3\u0111\3\u0111\3\u0112\3\u0112\3\u0112\3\u0112\3\u0113\3\u0113\3\u0113"+ - "\3\u0113\3\u0114\3\u0114\3\u0114\3\u0114\3\u0115\3\u0115\3\u0115\3\u0115"+ - "\3\u0116\3\u0116\3\u0116\3\u0116\3\u0117\3\u0117\3\u0117\3\u0117\3\u0118"+ - "\3\u0118\3\u0118\3\u0118\3\u0119\3\u0119\3\u0119\3\u0119\3\u011a\3\u011a"+ - "\3\u011a\3\u011a\3\u011b\3\u011b\3\u011b\3\u011b\3\u011c\3\u011c\3\u011c"+ - "\3\u011c\3\u011d\3\u011d\3\u011d\3\u011d\3\u011e\3\u011e\3\u011e\3\u011e"+ - "\3\u011f\3\u011f\3\u011f\3\u011f\3\u0120\3\u0120\3\u0120\3\u0120\3\u0121"+ - "\3\u0121\3\u0121\3\u0121\3\u0122\3\u0122\3\u0122\3\u0122\3\u0123\3\u0123"+ - "\3\u0123\3\u0123\3\u0124\3\u0124\3\u0124\3\u0124\3\u0125\3\u0125\3\u0125"+ - "\3\u0125\3\u0126\3\u0126\3\u0126\3\u0126\3\u0127\3\u0127\3\u0127\3\u0127"+ - "\3\u0128\3\u0128\5\u0128\u0853\n\u0128\3\u0128\3\u0128\3\u0129\3\u0129"+ - "\3\u0129\3\u0129\3\u012a\3\u012a\3\u012a\3\u012a\3\u012b\3\u012b\3\u012b"+ - "\3\u012b\3\u012c\3\u012c\3\u012d\6\u012d\u0866\n\u012d\r\u012d\16\u012d"+ - "\u0867\3\u012d\5\u012d\u086b\n\u012d\3\u012e\3\u012e\5\u012e\u086f\n\u012e"+ - "\3\u012f\3\u012f\3\u012f\3\u012f\3\u012f\3\u0130\5\u0130\u0877\n\u0130"+ - "\3\u0130\3\u0130\3\u0130\3\u0130\3\u0130\3\u0130\3\u0131\6\u0131\u0880"+ - "\n\u0131\r\u0131\16\u0131\u0881\3\u0132\3\u0132\3\u0133\6\u0133\u0887"+ - "\n\u0133\r\u0133\16\u0133\u0888\3\u0133\5\u0133\u088c\n\u0133\3\u0134"+ - "\3\u0134\3\u0134\3\u0134\3\u0134\3\u0135\3\u0135\3\u0135\3\u0135\3\u027e"+ - "\2\u0136\6\3\b\4\n\5\f\6\16\7\20\2\22\b\24\t\26\n\30\13\32\f\34\r\36\16"+ - " \17\"\20$\21&\22(\23*\24,\25.\26\60\27\62\30\64\31\66\328\33:\34<\35"+ - ">\36@\37B D!F\"H#J$L%N&P\'R(T)V*X+Z,\\-^.`/b\60d\61f\62h\63j\64l\65n\66"+ - "p\67r8t9v:x;z<|=~>\u0080?\u0082@\u0084A\u0086B\u0088C\u008aD\u008cE\u008e"+ - "F\u0090G\u0092H\u0094I\u0096J\u0098K\u009aL\u009cM\u009eN\u00a0O\u00a2"+ - "P\u00a4Q\u00a6R\u00a8S\u00aaT\u00acU\u00aeV\u00b0W\u00b2X\u00b4Y\u00b6"+ - "Z\u00b8[\u00ba\\\u00bc]\u00be^\u00c0_\u00c2`\u00c4a\u00c6b\u00c8c\u00ca"+ - "d\u00cce\u00cef\u00d0g\u00d2h\u00d4i\u00d6j\u00d8k\u00dal\u00dcm\u00de"+ - "n\u00e0o\u00e2p\u00e4q\u00e6r\u00e8s\u00eat\u00ecu\u00eev\u00f0w\u00f2"+ - "x\u00f4y\u00f6z\u00f8{\u00fa|\u00fc}\u00fe~\u0100\177\u0102\u0080\u0104"+ - "\u0081\u0106\u0082\u0108\u0083\u010a\u0084\u010c\u0085\u010e\u0086\u0110"+ - "\u0087\u0112\u0088\u0114\u0089\u0116\u008a\u0118\u008b\u011a\2\u011c\2"+ - "\u011e\2\u0120\u008c\u0122\u008d\u0124\u008e\u0126\2\u0128\2\u012a\2\u012c"+ - "\2\u012e\u008f\u0130\2\u0132\2\u0134\u0090\u0136\2\u0138\u0091\u013a\u0092"+ - "\u013c\u0093\u013e\2\u0140\u0094\u0142\u0095\u0144\u0096\u0146\2\u0148"+ - "\2\u014a\2\u014c\2\u014e\u0097\u0150\u0098\u0152\u0099\u0154\u009a\u0156"+ - "\u009b\u0158\u009c\u015a\u009d\u015c\u009e\u015e\2\u0160\2\u0162\2\u0164"+ - "\2\u0166\2\u0168\2\u016a\2\u016c\2\u016e\2\u0170\2\u0172\2\u0174\2\u0176"+ - "\2\u0178\2\u017a\2\u017c\2\u017e\2\u0180\2\u0182\2\u0184\2\u0186\2\u0188"+ - "\2\u018a\2\u018c\2\u018e\2\u0190\2\u0192\2\u0194\2\u0196\2\u0198\2\u019a"+ - "\2\u019c\2\u019e\2\u01a0\2\u01a2\2\u01a4\2\u01a6\2\u01a8\2\u01aa\2\u01ac"+ - "\2\u01ae\2\u01b0\2\u01b2\2\u01b4\2\u01b6\2\u01b8\2\u01ba\2\u01bc\2\u01be"+ - "\2\u01c0\2\u01c2\2\u01c4\2\u01c6\2\u01c8\2\u01ca\2\u01cc\2\u01ce\2\u01d0"+ - "\2\u01d2\2\u01d4\2\u01d6\2\u01d8\2\u01da\2\u01dc\2\u01de\2\u01e0\2\u01e2"+ - "\2\u01e4\2\u01e6\2\u01e8\2\u01ea\2\u01ec\2\u01ee\2\u01f0\2\u01f2\2\u01f4"+ - "\2\u01f6\2\u01f8\2\u01fa\2\u01fc\2\u01fe\2\u0200\2\u0202\2\u0204\2\u0206"+ - "\2\u0208\2\u020a\2\u020c\2\u020e\2\u0210\2\u0212\2\u0214\2\u0216\2\u0218"+ - "\2\u021a\2\u021c\2\u021e\2\u0220\2\u0222\2\u0224\2\u0226\2\u0228\2\u022a"+ - "\2\u022c\2\u022e\2\u0230\2\u0232\2\u0234\2\u0236\2\u0238\2\u023a\2\u023c"+ - "\2\u023e\2\u0240\2\u0242\2\u0244\2\u0246\2\u0248\2\u024a\2\u024c\2\u024e"+ - "\2\u0250\2\u0252\u009f\u0254\u00a0\u0256\u00a1\u0258\u00a2\u025a\u00a3"+ - "\u025c\u00a4\u025e\u00a5\u0260\u00a6\u0262\u00a7\u0264\u00a8\u0266\u00a9"+ - "\u0268\u00aa\u026a\u00ab\u026c\2\6\2\3\4\5\27\4\2\f\f\17\17\5\2\13\13"+ - "\16\16\"\"\4\2HHhh\4\2GGgg\4\2--//\4\2ZZzz\5\2\62;CHch\4\2DDdd\3\2\62"+ - "\63\t\2\f\f\17\17>>@@]]__bb\6\2\f\f\17\17))^^\n\2$$&&))^^ddppttvv\u0248"+ - "\2c|\u00b7\u00b7\u00e1\u00f8\u00fa\u0101\u0103\u0103\u0105\u0105\u0107"+ - "\u0107\u0109\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111\u0111\u0113"+ - "\u0113\u0115\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d\u011d\u011f"+ - "\u011f\u0121\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129\u0129\u012b"+ - "\u012b\u012d\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135\u0135\u0137"+ - "\u0137\u0139\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142\u0142\u0144"+ - "\u0144\u0146\u0146\u0148\u0148\u014a\u014b\u014d\u014d\u014f\u014f\u0151"+ - "\u0151\u0153\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b\u015b\u015d"+ - "\u015d\u015f\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167\u0167\u0169"+ - "\u0169\u016b\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173\u0173\u0175"+ - "\u0175\u0177\u0177\u0179\u0179\u017c\u017c\u017e\u017e\u0180\u0182\u0185"+ - "\u0185\u0187\u0187\u018a\u018a\u018e\u018f\u0194\u0194\u0197\u0197\u019b"+ - "\u019d\u01a0\u01a0\u01a3\u01a3\u01a5\u01a5\u01a7\u01a7\u01aa\u01aa\u01ac"+ - "\u01ad\u01af\u01af\u01b2\u01b2\u01b6\u01b6\u01b8\u01b8\u01bb\u01bc\u01bf"+ - "\u01c1\u01c8\u01c8\u01cb\u01cb\u01ce\u01ce\u01d0\u01d0\u01d2\u01d2\u01d4"+ - "\u01d4\u01d6\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dc\u01de\u01df\u01e1"+ - "\u01e1\u01e3\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb\u01eb\u01ed"+ - "\u01ed\u01ef\u01ef\u01f1\u01f2\u01f5\u01f5\u01f7\u01f7\u01fb\u01fb\u01fd"+ - "\u01fd\u01ff\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207\u0207\u0209"+ - "\u0209\u020b\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213\u0213\u0215"+ - "\u0215\u0217\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f\u021f\u0221"+ - "\u0221\u0223\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b\u022b\u022d"+ - "\u022d\u022f\u022f\u0231\u0231\u0233\u0233\u0235\u023b\u023e\u023e\u0241"+ - "\u0242\u0244\u0244\u0249\u0249\u024b\u024b\u024d\u024d\u024f\u024f\u0251"+ - "\u0295\u0297\u02b1\u0373\u0373\u0375\u0375\u0379\u0379\u037d\u037f\u0392"+ - "\u0392\u03ae\u03d0\u03d2\u03d3\u03d7\u03d9\u03db\u03db\u03dd\u03dd\u03df"+ - "\u03df\u03e1\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9\u03e9\u03eb"+ - "\u03eb\u03ed\u03ed\u03ef\u03ef\u03f1\u03f5\u03f7\u03f7\u03fa\u03fa\u03fd"+ - "\u03fe\u0432\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469\u0469\u046b"+ - "\u046b\u046d\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475\u0475\u0477"+ - "\u0477\u0479\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481\u0481\u0483"+ - "\u0483\u048d\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495\u0495\u0497"+ - "\u0497\u0499\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1\u04a1\u04a3"+ - "\u04a3\u04a5\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad\u04ad\u04af"+ - "\u04af\u04b1\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9\u04b9\u04bb"+ - "\u04bb\u04bd\u04bd\u04bf\u04bf\u04c1\u04c1\u04c4\u04c4\u04c6\u04c6\u04c8"+ - "\u04c8\u04ca\u04ca\u04cc\u04cc\u04ce\u04ce\u04d0\u04d1\u04d3\u04d3\u04d5"+ - "\u04d5\u04d7\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df\u04df\u04e1"+ - "\u04e1\u04e3\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb\u04eb\u04ed"+ - "\u04ed\u04ef\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7\u04f7\u04f9"+ - "\u04f9\u04fb\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503\u0503\u0505"+ - "\u0505\u0507\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f\u050f\u0511"+ - "\u0511\u0513\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b\u051b\u051d"+ - "\u051d\u051f\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527\u0527\u0529"+ - "\u0529\u0563\u0589\u1d02\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03\u1e03\u1e05"+ - "\u1e05\u1e07\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f\u1e0f\u1e11"+ - "\u1e11\u1e13\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b\u1e1b\u1e1d"+ - "\u1e1d\u1e1f\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27\u1e27\u1e29"+ - "\u1e29\u1e2b\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33\u1e33\u1e35"+ - "\u1e35\u1e37\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f\u1e3f\u1e41"+ - "\u1e41\u1e43\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b\u1e4b\u1e4d"+ - "\u1e4d\u1e4f\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57\u1e57\u1e59"+ - "\u1e59\u1e5b\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63\u1e63\u1e65"+ - "\u1e65\u1e67\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f\u1e6f\u1e71"+ - "\u1e71\u1e73\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b\u1e7b\u1e7d"+ - "\u1e7d\u1e7f\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87\u1e87\u1e89"+ - "\u1e89\u1e8b\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93\u1e93\u1e95"+ - "\u1e95\u1e97\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7\u1ea7\u1ea9"+ - "\u1ea9\u1eab\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3\u1eb3\u1eb5"+ - "\u1eb5\u1eb7\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf\u1ebf\u1ec1"+ - "\u1ec1\u1ec3\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb\u1ecb\u1ecd"+ - "\u1ecd\u1ecf\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7\u1ed7\u1ed9"+ - "\u1ed9\u1edb\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3\u1ee3\u1ee5"+ - "\u1ee5\u1ee7\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef\u1eef\u1ef1"+ - "\u1ef1\u1ef3\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb\u1efb\u1efd"+ - "\u1efd\u1eff\u1eff\u1f01\u1f09\u1f12\u1f17\u1f22\u1f29\u1f32\u1f39\u1f42"+ - "\u1f47\u1f52\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82\u1f89\u1f92\u1f99\u1fa2"+ - "\u1fa9\u1fb2\u1fb6\u1fb8\u1fb9\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8\u1fc9\u1fd2"+ - "\u1fd5\u1fd8\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c\u210c\u2110"+ - "\u2111\u2115\u2115\u2131\u2131\u2136\u2136\u213b\u213b\u213e\u213f\u2148"+ - "\u214b\u2150\u2150\u2186\u2186\u2c32\u2c60\u2c63\u2c63\u2c67\u2c68\u2c6a"+ - "\u2c6a\u2c6c\u2c6c\u2c6e\u2c6e\u2c73\u2c73\u2c75\u2c76\u2c78\u2c7d\u2c83"+ - "\u2c83\u2c85\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d\u2c8d\u2c8f"+ - "\u2c8f\u2c91\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99\u2c99\u2c9b"+ - "\u2c9b\u2c9d\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5\u2ca5\u2ca7"+ - "\u2ca7\u2ca9\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1\u2cb1\u2cb3"+ - "\u2cb3\u2cb5\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd\u2cbd\u2cbf"+ - "\u2cbf\u2cc1\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9\u2cc9\u2ccb"+ - "\u2ccb\u2ccd\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5\u2cd5\u2cd7"+ - "\u2cd7\u2cd9\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1\u2ce1\u2ce3"+ - "\u2ce3\u2ce5\u2ce6\u2cee\u2cee\u2cf0\u2cf0\u2cf5\u2cf5\u2d02\u2d27\u2d29"+ - "\u2d29\u2d2f\u2d2f\ua643\ua643\ua645\ua645\ua647\ua647\ua649\ua649\ua64b"+ - "\ua64b\ua64d\ua64d\ua64f\ua64f\ua651\ua651\ua653\ua653\ua655\ua655\ua657"+ - "\ua657\ua659\ua659\ua65b\ua65b\ua65d\ua65d\ua65f\ua65f\ua661\ua661\ua663"+ - "\ua663\ua665\ua665\ua667\ua667\ua669\ua669\ua66b\ua66b\ua66d\ua66d\ua66f"+ - "\ua66f\ua683\ua683\ua685\ua685\ua687\ua687\ua689\ua689\ua68b\ua68b\ua68d"+ - "\ua68d\ua68f\ua68f\ua691\ua691\ua693\ua693\ua695\ua695\ua697\ua697\ua699"+ - "\ua699\ua725\ua725\ua727\ua727\ua729\ua729\ua72b\ua72b\ua72d\ua72d\ua72f"+ - "\ua72f\ua731\ua733\ua735\ua735\ua737\ua737\ua739\ua739\ua73b\ua73b\ua73d"+ - "\ua73d\ua73f\ua73f\ua741\ua741\ua743\ua743\ua745\ua745\ua747\ua747\ua749"+ - "\ua749\ua74b\ua74b\ua74d\ua74d\ua74f\ua74f\ua751\ua751\ua753\ua753\ua755"+ - "\ua755\ua757\ua757\ua759\ua759\ua75b\ua75b\ua75d\ua75d\ua75f\ua75f\ua761"+ - "\ua761\ua763\ua763\ua765\ua765\ua767\ua767\ua769\ua769\ua76b\ua76b\ua76d"+ - "\ua76d\ua76f\ua76f\ua771\ua771\ua773\ua77a\ua77c\ua77c\ua77e\ua77e\ua781"+ - "\ua781\ua783\ua783\ua785\ua785\ua787\ua787\ua789\ua789\ua78e\ua78e\ua790"+ - "\ua790\ua793\ua793\ua795\ua795\ua7a3\ua7a3\ua7a5\ua7a5\ua7a7\ua7a7\ua7a9"+ - "\ua7a9\ua7ab\ua7ab\ua7fc\ua7fc\ufb02\ufb08\ufb15\ufb19\uff43\uff5c\65"+ - "\2\u02b2\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0\u0376\u0376"+ - "\u037c\u037c\u055b\u055b\u0642\u0642\u06e7\u06e8\u07f6\u07f7\u07fc\u07fc"+ - "\u081c\u081c\u0826\u0826\u082a\u082a\u0973\u0973\u0e48\u0e48\u0ec8\u0ec8"+ - "\u10fe\u10fe\u17d9\u17d9\u1845\u1845\u1aa9\u1aa9\u1c7a\u1c7f\u1d2e\u1d6c"+ - "\u1d7a\u1d7a\u1d9d\u1dc1\u2073\u2073\u2081\u2081\u2092\u209e\u2c7e\u2c7f"+ - "\u2d71\u2d71\u2e31\u2e31\u3007\u3007\u3033\u3037\u303d\u303d\u309f\u30a0"+ - "\u30fe\u3100\ua017\ua017\ua4fa\ua4ff\ua60e\ua60e\ua681\ua681\ua719\ua721"+ - "\ua772\ua772\ua78a\ua78a\ua7fa\ua7fb\ua9d1\ua9d1\uaa72\uaa72\uaadf\uaadf"+ - "\uaaf5\uaaf6\uff72\uff72\uffa0\uffa1\u0121\2\u00ac\u00ac\u00bc\u00bc\u01bd"+ - "\u01bd\u01c2\u01c5\u0296\u0296\u05d2\u05ec\u05f2\u05f4\u0622\u0641\u0643"+ - "\u064c\u0670\u0671\u0673\u06d5\u06d7\u06d7\u06f0\u06f1\u06fc\u06fe\u0701"+ - "\u0701\u0712\u0712\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc\u07ec\u0802"+ - "\u0817\u0842\u085a\u08a2\u08a2\u08a4\u08ae\u0906\u093b\u093f\u093f\u0952"+ - "\u0952\u095a\u0963\u0974\u0979\u097b\u0981\u0987\u098e\u0991\u0992\u0995"+ - "\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0\u09d0\u09de"+ - "\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c"+ - "\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60\u0a60\u0a74"+ - "\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7"+ - "\u0abb\u0abf\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12\u0b15"+ - "\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e\u0b5f\u0b61"+ - "\u0b63\u0b73\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b"+ - "\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bd2"+ - "\u0bd2\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f"+ - "\u0c3f\u0c5a\u0c5b\u0c62\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac"+ - "\u0cb5\u0cb7\u0cbb\u0cbf\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4\u0d07"+ - "\u0d0e\u0d10\u0d12\u0d14\u0d3c\u0d3f\u0d3f\u0d50\u0d50\u0d62\u0d63\u0d7c"+ - "\u0d81\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2\u0dc8\u0e03"+ - "\u0e32\u0e34\u0e35\u0e42\u0e47\u0e83\u0e84\u0e86\u0e86\u0e89\u0e8a\u0e8c"+ - "\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7\u0ea7\u0ea9"+ - "\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2\u0ec6\u0ede"+ - "\u0ee1\u0f02\u0f02\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041"+ - "\u1041\u1052\u1057\u105c\u105f\u1063\u1063\u1067\u1068\u1070\u1072\u1077"+ - "\u1083\u1090\u1090\u10d2\u10fc\u10ff\u124a\u124c\u124f\u1252\u1258\u125a"+ - "\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4\u12b7\u12ba"+ - "\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314\u1317\u131a"+ - "\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683\u169c\u16a2"+ - "\u16ec\u1702\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762\u176e\u1770"+ - "\u1772\u1782\u17b5\u17de\u17de\u1822\u1844\u1846\u1879\u1882\u18aa\u18ac"+ - "\u18ac\u18b2\u18f7\u1902\u191e\u1952\u196f\u1972\u1976\u1982\u19ad\u19c3"+ - "\u19c9\u1a02\u1a18\u1a22\u1a56\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0"+ - "\u1bb1\u1bbc\u1be7\u1c02\u1c25\u1c4f\u1c51\u1c5c\u1c79\u1ceb\u1cee\u1cf0"+ - "\u1cf3\u1cf7\u1cf8\u2137\u213a\u2d32\u2d69\u2d82\u2d98\u2da2\u2da8\u2daa"+ - "\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda"+ - "\u2de0\u3008\u3008\u303e\u303e\u3043\u3098\u30a1\u30a1\u30a3\u30fc\u3101"+ - "\u3101\u3107\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402\u4db7\u4e02"+ - "\u9fce\ua002\ua016\ua018\ua48e\ua4d2\ua4f9\ua502\ua60d\ua612\ua621\ua62c"+ - "\ua62d\ua670\ua670\ua6a2\ua6e7\ua7fd\ua803\ua805\ua807\ua809\ua80c\ua80e"+ - "\ua824\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua8fd\ua90c\ua927\ua932"+ - "\ua948\ua962\ua97e\ua986\ua9b4\uaa02\uaa2a\uaa42\uaa44\uaa46\uaa4d\uaa62"+ - "\uaa71\uaa73\uaa78\uaa7c\uaa7c\uaa82\uaab1\uaab3\uaab3\uaab7\uaab8\uaabb"+ - "\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd\uaade\uaae2\uaaec\uaaf4\uaaf4\uab03"+ - "\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2\uabe4\uac02"+ - "\uac02\ud7a5\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f\ufa72\ufadb\ufb1f"+ - "\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45"+ - "\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72"+ - "\ufe76\ufe78\ufefe\uff68\uff71\uff73\uff9f\uffa2\uffc0\uffc4\uffc9\uffcc"+ - "\uffd1\uffd4\uffd9\uffdc\uffde\f\2\u01c7\u01c7\u01ca\u01ca\u01cd\u01cd"+ - "\u01f4\u01f4\u1f8a\u1f91\u1f9a\u1fa1\u1faa\u1fb1\u1fbe\u1fbe\u1fce\u1fce"+ - "\u1ffe\u1ffe\u0242\2C\\\u00c2\u00d8\u00da\u00e0\u0102\u0102\u0104\u0104"+ - "\u0106\u0106\u0108\u0108\u010a\u010a\u010c\u010c\u010e\u010e\u0110\u0110"+ - "\u0112\u0112\u0114\u0114\u0116\u0116\u0118\u0118\u011a\u011a\u011c\u011c"+ - "\u011e\u011e\u0120\u0120\u0122\u0122\u0124\u0124\u0126\u0126\u0128\u0128"+ - "\u012a\u012a\u012c\u012c\u012e\u012e\u0130\u0130\u0132\u0132\u0134\u0134"+ - "\u0136\u0136\u0138\u0138\u013b\u013b\u013d\u013d\u013f\u013f\u0141\u0141"+ - "\u0143\u0143\u0145\u0145\u0147\u0147\u0149\u0149\u014c\u014c\u014e\u014e"+ - "\u0150\u0150\u0152\u0152\u0154\u0154\u0156\u0156\u0158\u0158\u015a\u015a"+ - "\u015c\u015c\u015e\u015e\u0160\u0160\u0162\u0162\u0164\u0164\u0166\u0166"+ - "\u0168\u0168\u016a\u016a\u016c\u016c\u016e\u016e\u0170\u0170\u0172\u0172"+ - "\u0174\u0174\u0176\u0176\u0178\u0178\u017a\u017b\u017d\u017d\u017f\u017f"+ - "\u0183\u0184\u0186\u0186\u0188\u0189\u018b\u018d\u0190\u0193\u0195\u0196"+ - "\u0198\u019a\u019e\u019f\u01a1\u01a2\u01a4\u01a4\u01a6\u01a6\u01a8\u01a9"+ - "\u01ab\u01ab\u01ae\u01ae\u01b0\u01b1\u01b3\u01b5\u01b7\u01b7\u01b9\u01ba"+ - "\u01be\u01be\u01c6\u01c6\u01c9\u01c9\u01cc\u01cc\u01cf\u01cf\u01d1\u01d1"+ - "\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7\u01d9\u01d9\u01db\u01db\u01dd\u01dd"+ - "\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4\u01e6\u01e6\u01e8\u01e8\u01ea\u01ea"+ - "\u01ec\u01ec\u01ee\u01ee\u01f0\u01f0\u01f3\u01f3\u01f6\u01f6\u01f8\u01fa"+ - "\u01fc\u01fc\u01fe\u01fe\u0200\u0200\u0202\u0202\u0204\u0204\u0206\u0206"+ - "\u0208\u0208\u020a\u020a\u020c\u020c\u020e\u020e\u0210\u0210\u0212\u0212"+ - "\u0214\u0214\u0216\u0216\u0218\u0218\u021a\u021a\u021c\u021c\u021e\u021e"+ - "\u0220\u0220\u0222\u0222\u0224\u0224\u0226\u0226\u0228\u0228\u022a\u022a"+ - "\u022c\u022c\u022e\u022e\u0230\u0230\u0232\u0232\u0234\u0234\u023c\u023d"+ - "\u023f\u0240\u0243\u0243\u0245\u0248\u024a\u024a\u024c\u024c\u024e\u024e"+ - "\u0250\u0250\u0372\u0372\u0374\u0374\u0378\u0378\u0388\u0388\u038a\u038c"+ - "\u038e\u038e\u0390\u0391\u0393\u03a3\u03a5\u03ad\u03d1\u03d1\u03d4\u03d6"+ - "\u03da\u03da\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03e2\u03e4\u03e4"+ - "\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea\u03ec\u03ec\u03ee\u03ee\u03f0\u03f0"+ - "\u03f6\u03f6\u03f9\u03f9\u03fb\u03fc\u03ff\u0431\u0462\u0462\u0464\u0464"+ - "\u0466\u0466\u0468\u0468\u046a\u046a\u046c\u046c\u046e\u046e\u0470\u0470"+ - "\u0472\u0472\u0474\u0474\u0476\u0476\u0478\u0478\u047a\u047a\u047c\u047c"+ - "\u047e\u047e\u0480\u0480\u0482\u0482\u048c\u048c\u048e\u048e\u0490\u0490"+ - "\u0492\u0492\u0494\u0494\u0496\u0496\u0498\u0498\u049a\u049a\u049c\u049c"+ - "\u049e\u049e\u04a0\u04a0\u04a2\u04a2\u04a4\u04a4\u04a6\u04a6\u04a8\u04a8"+ - "\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae\u04b0\u04b0\u04b2\u04b2\u04b4\u04b4"+ - "\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba\u04bc\u04bc\u04be\u04be\u04c0\u04c0"+ - "\u04c2\u04c3\u04c5\u04c5\u04c7\u04c7\u04c9\u04c9\u04cb\u04cb\u04cd\u04cd"+ - "\u04cf\u04cf\u04d2\u04d2\u04d4\u04d4\u04d6\u04d6\u04d8\u04d8\u04da\u04da"+ - "\u04dc\u04dc\u04de\u04de\u04e0\u04e0\u04e2\u04e2\u04e4\u04e4\u04e6\u04e6"+ - "\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec\u04ee\u04ee\u04f0\u04f0\u04f2\u04f2"+ - "\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8\u04fa\u04fa\u04fc\u04fc\u04fe\u04fe"+ - "\u0500\u0500\u0502\u0502\u0504\u0504\u0506\u0506\u0508\u0508\u050a\u050a"+ - "\u050c\u050c\u050e\u050e\u0510\u0510\u0512\u0512\u0514\u0514\u0516\u0516"+ - "\u0518\u0518\u051a\u051a\u051c\u051c\u051e\u051e\u0520\u0520\u0522\u0522"+ - "\u0524\u0524\u0526\u0526\u0528\u0528\u0533\u0558\u10a2\u10c7\u10c9\u10c9"+ - "\u10cf\u10cf\u1e02\u1e02\u1e04\u1e04\u1e06\u1e06\u1e08\u1e08\u1e0a\u1e0a"+ - "\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10\u1e12\u1e12\u1e14\u1e14\u1e16\u1e16"+ - "\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c\u1e1e\u1e1e\u1e20\u1e20\u1e22\u1e22"+ - "\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28\u1e2a\u1e2a\u1e2c\u1e2c\u1e2e\u1e2e"+ - "\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34\u1e36\u1e36\u1e38\u1e38\u1e3a\u1e3a"+ - "\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40\u1e42\u1e42\u1e44\u1e44\u1e46\u1e46"+ - "\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c\u1e4e\u1e4e\u1e50\u1e50\u1e52\u1e52"+ - "\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58\u1e5a\u1e5a\u1e5c\u1e5c\u1e5e\u1e5e"+ - "\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64\u1e66\u1e66\u1e68\u1e68\u1e6a\u1e6a"+ - "\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70\u1e72\u1e72\u1e74\u1e74\u1e76\u1e76"+ - "\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c\u1e7e\u1e7e\u1e80\u1e80\u1e82\u1e82"+ - "\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88\u1e8a\u1e8a\u1e8c\u1e8c\u1e8e\u1e8e"+ - "\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94\u1e96\u1e96\u1ea0\u1ea0\u1ea2\u1ea2"+ - "\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8\u1eaa\u1eaa\u1eac\u1eac\u1eae\u1eae"+ - "\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4\u1eb6\u1eb6\u1eb8\u1eb8\u1eba\u1eba"+ - "\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0\u1ec2\u1ec2\u1ec4\u1ec4\u1ec6\u1ec6"+ - "\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc\u1ece\u1ece\u1ed0\u1ed0\u1ed2\u1ed2"+ - "\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8\u1eda\u1eda\u1edc\u1edc\u1ede\u1ede"+ - "\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4\u1ee6\u1ee6\u1ee8\u1ee8\u1eea\u1eea"+ - "\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0\u1ef2\u1ef2\u1ef4\u1ef4\u1ef6\u1ef6"+ - "\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc\u1efe\u1efe\u1f00\u1f00\u1f0a\u1f11"+ - "\u1f1a\u1f1f\u1f2a\u1f31\u1f3a\u1f41\u1f4a\u1f4f\u1f5b\u1f5b\u1f5d\u1f5d"+ - "\u1f5f\u1f5f\u1f61\u1f61\u1f6a\u1f71\u1fba\u1fbd\u1fca\u1fcd\u1fda\u1fdd"+ - "\u1fea\u1fee\u1ffa\u1ffd\u2104\u2104\u2109\u2109\u210d\u210f\u2112\u2114"+ - "\u2117\u2117\u211b\u211f\u2126\u2126\u2128\u2128\u212a\u212a\u212c\u212f"+ - "\u2132\u2135\u2140\u2141\u2147\u2147\u2185\u2185\u2c02\u2c30\u2c62\u2c62"+ - "\u2c64\u2c66\u2c69\u2c69\u2c6b\u2c6b\u2c6d\u2c6d\u2c6f\u2c72\u2c74\u2c74"+ - "\u2c77\u2c77\u2c80\u2c82\u2c84\u2c84\u2c86\u2c86\u2c88\u2c88\u2c8a\u2c8a"+ - "\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90\u2c92\u2c92\u2c94\u2c94\u2c96\u2c96"+ - "\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c\u2c9e\u2c9e\u2ca0\u2ca0\u2ca2\u2ca2"+ - "\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8\u2caa\u2caa\u2cac\u2cac\u2cae\u2cae"+ - "\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4\u2cb6\u2cb6\u2cb8\u2cb8\u2cba\u2cba"+ - "\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0\u2cc2\u2cc2\u2cc4\u2cc4\u2cc6\u2cc6"+ - "\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc\u2cce\u2cce\u2cd0\u2cd0\u2cd2\u2cd2"+ - "\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8\u2cda\u2cda\u2cdc\u2cdc\u2cde\u2cde"+ - "\u2ce0\u2ce0\u2ce2\u2ce2\u2ce4\u2ce4\u2ced\u2ced\u2cef\u2cef\u2cf4\u2cf4"+ - "\ua642\ua642\ua644\ua644\ua646\ua646\ua648\ua648\ua64a\ua64a\ua64c\ua64c"+ - "\ua64e\ua64e\ua650\ua650\ua652\ua652\ua654\ua654\ua656\ua656\ua658\ua658"+ - "\ua65a\ua65a\ua65c\ua65c\ua65e\ua65e\ua660\ua660\ua662\ua662\ua664\ua664"+ - "\ua666\ua666\ua668\ua668\ua66a\ua66a\ua66c\ua66c\ua66e\ua66e\ua682\ua682"+ - "\ua684\ua684\ua686\ua686\ua688\ua688\ua68a\ua68a\ua68c\ua68c\ua68e\ua68e"+ - "\ua690\ua690\ua692\ua692\ua694\ua694\ua696\ua696\ua698\ua698\ua724\ua724"+ - "\ua726\ua726\ua728\ua728\ua72a\ua72a\ua72c\ua72c\ua72e\ua72e\ua730\ua730"+ - "\ua734\ua734\ua736\ua736\ua738\ua738\ua73a\ua73a\ua73c\ua73c\ua73e\ua73e"+ - "\ua740\ua740\ua742\ua742\ua744\ua744\ua746\ua746\ua748\ua748\ua74a\ua74a"+ - "\ua74c\ua74c\ua74e\ua74e\ua750\ua750\ua752\ua752\ua754\ua754\ua756\ua756"+ - "\ua758\ua758\ua75a\ua75a\ua75c\ua75c\ua75e\ua75e\ua760\ua760\ua762\ua762"+ - "\ua764\ua764\ua766\ua766\ua768\ua768\ua76a\ua76a\ua76c\ua76c\ua76e\ua76e"+ - "\ua770\ua770\ua77b\ua77b\ua77d\ua77d\ua77f\ua780\ua782\ua782\ua784\ua784"+ - "\ua786\ua786\ua788\ua788\ua78d\ua78d\ua78f\ua78f\ua792\ua792\ua794\ua794"+ - "\ua7a2\ua7a2\ua7a4\ua7a4\ua7a6\ua7a6\ua7a8\ua7a8\ua7aa\ua7aa\ua7ac\ua7ac"+ - "\uff23\uff3c%\2\62;\u0662\u066b\u06f2\u06fb\u07c2\u07cb\u0968\u0971\u09e8"+ - "\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68\u0b71\u0be8\u0bf1\u0c68\u0c71\u0ce8"+ - "\u0cf1\u0d68\u0d71\u0e52\u0e5b\u0ed2\u0edb\u0f22\u0f2b\u1042\u104b\u1092"+ - "\u109b\u17e2\u17eb\u1812\u181b\u1948\u1951\u19d2\u19db\u1a82\u1a8b\u1a92"+ - "\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42\u1c4b\u1c52\u1c5b\ua622\ua62b\ua8d2"+ - "\ua8db\ua902\ua90b\ua9d2\ua9db\uaa52\uaa5b\uabf2\uabfb\uff12\uff1b\t\2"+ - "\u16f0\u16f2\u2162\u2184\u2187\u218a\u3009\u3009\u3023\u302b\u303a\u303c"+ - "\ua6e8\ua6f1\5\2$$&&^^\4\2$$&&\2\u08df\2\6\3\2\2\2\2\b\3\2\2\2\2\n\3\2"+ - "\2\2\2\f\3\2\2\2\2\16\3\2\2\2\2\22\3\2\2\2\2\24\3\2\2\2\2\26\3\2\2\2\2"+ - "\30\3\2\2\2\2\32\3\2\2\2\2\34\3\2\2\2\2\36\3\2\2\2\2 \3\2\2\2\2\"\3\2"+ - "\2\2\2$\3\2\2\2\2&\3\2\2\2\2(\3\2\2\2\2*\3\2\2\2\2,\3\2\2\2\2.\3\2\2\2"+ - "\2\60\3\2\2\2\2\62\3\2\2\2\2\64\3\2\2\2\2\66\3\2\2\2\28\3\2\2\2\2:\3\2"+ - "\2\2\2<\3\2\2\2\2>\3\2\2\2\2@\3\2\2\2\2B\3\2\2\2\2D\3\2\2\2\2F\3\2\2\2"+ - "\2H\3\2\2\2\2J\3\2\2\2\2L\3\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2R\3\2\2\2\2T"+ - "\3\2\2\2\2V\3\2\2\2\2X\3\2\2\2\2Z\3\2\2\2\2\\\3\2\2\2\2^\3\2\2\2\2`\3"+ - "\2\2\2\2b\3\2\2\2\2d\3\2\2\2\2f\3\2\2\2\2h\3\2\2\2\2j\3\2\2\2\2l\3\2\2"+ - "\2\2n\3\2\2\2\2p\3\2\2\2\2r\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2x\3\2\2\2\2"+ - "z\3\2\2\2\2|\3\2\2\2\2~\3\2\2\2\2\u0080\3\2\2\2\2\u0082\3\2\2\2\2\u0084"+ - "\3\2\2\2\2\u0086\3\2\2\2\2\u0088\3\2\2\2\2\u008a\3\2\2\2\2\u008c\3\2\2"+ - "\2\2\u008e\3\2\2\2\2\u0090\3\2\2\2\2\u0092\3\2\2\2\2\u0094\3\2\2\2\2\u0096"+ - "\3\2\2\2\2\u0098\3\2\2\2\2\u009a\3\2\2\2\2\u009c\3\2\2\2\2\u009e\3\2\2"+ - "\2\2\u00a0\3\2\2\2\2\u00a2\3\2\2\2\2\u00a4\3\2\2\2\2\u00a6\3\2\2\2\2\u00a8"+ - "\3\2\2\2\2\u00aa\3\2\2\2\2\u00ac\3\2\2\2\2\u00ae\3\2\2\2\2\u00b0\3\2\2"+ - "\2\2\u00b2\3\2\2\2\2\u00b4\3\2\2\2\2\u00b6\3\2\2\2\2\u00b8\3\2\2\2\2\u00ba"+ - "\3\2\2\2\2\u00bc\3\2\2\2\2\u00be\3\2\2\2\2\u00c0\3\2\2\2\2\u00c2\3\2\2"+ - "\2\2\u00c4\3\2\2\2\2\u00c6\3\2\2\2\2\u00c8\3\2\2\2\2\u00ca\3\2\2\2\2\u00cc"+ - "\3\2\2\2\2\u00ce\3\2\2\2\2\u00d0\3\2\2\2\2\u00d2\3\2\2\2\2\u00d4\3\2\2"+ - "\2\2\u00d6\3\2\2\2\2\u00d8\3\2\2\2\2\u00da\3\2\2\2\2\u00dc\3\2\2\2\2\u00de"+ - "\3\2\2\2\2\u00e0\3\2\2\2\2\u00e2\3\2\2\2\2\u00e4\3\2\2\2\2\u00e6\3\2\2"+ - "\2\2\u00e8\3\2\2\2\2\u00ea\3\2\2\2\2\u00ec\3\2\2\2\2\u00ee\3\2\2\2\2\u00f0"+ - "\3\2\2\2\2\u00f2\3\2\2\2\2\u00f4\3\2\2\2\2\u00f6\3\2\2\2\2\u00f8\3\2\2"+ - "\2\2\u00fa\3\2\2\2\2\u00fc\3\2\2\2\2\u00fe\3\2\2\2\2\u0100\3\2\2\2\2\u0102"+ - "\3\2\2\2\2\u0104\3\2\2\2\2\u0106\3\2\2\2\2\u0108\3\2\2\2\2\u010a\3\2\2"+ - "\2\2\u010c\3\2\2\2\2\u010e\3\2\2\2\2\u0110\3\2\2\2\2\u0112\3\2\2\2\2\u0114"+ - "\3\2\2\2\2\u0116\3\2\2\2\2\u0118\3\2\2\2\2\u0120\3\2\2\2\2\u0122\3\2\2"+ - "\2\2\u0124\3\2\2\2\2\u012e\3\2\2\2\2\u0134\3\2\2\2\2\u0138\3\2\2\2\2\u013a"+ - "\3\2\2\2\2\u013c\3\2\2\2\2\u0140\3\2\2\2\2\u0142\3\2\2\2\2\u0144\3\2\2"+ - "\2\2\u014e\3\2\2\2\2\u0150\3\2\2\2\2\u0152\3\2\2\2\2\u0154\3\2\2\2\2\u0156"+ - "\3\2\2\2\2\u0158\3\2\2\2\2\u015a\3\2\2\2\2\u015c\3\2\2\2\3\u015e\3\2\2"+ - "\2\3\u0160\3\2\2\2\3\u0162\3\2\2\2\3\u0164\3\2\2\2\3\u0166\3\2\2\2\3\u0168"+ - "\3\2\2\2\3\u016a\3\2\2\2\3\u016c\3\2\2\2\3\u016e\3\2\2\2\3\u0170\3\2\2"+ - "\2\3\u0172\3\2\2\2\3\u0174\3\2\2\2\3\u0176\3\2\2\2\3\u0178\3\2\2\2\3\u017a"+ - "\3\2\2\2\3\u017c\3\2\2\2\3\u017e\3\2\2\2\3\u0180\3\2\2\2\3\u0182\3\2\2"+ - "\2\3\u0184\3\2\2\2\3\u0186\3\2\2\2\3\u0188\3\2\2\2\3\u018a\3\2\2\2\3\u018c"+ - "\3\2\2\2\3\u018e\3\2\2\2\3\u0190\3\2\2\2\3\u0192\3\2\2\2\3\u0194\3\2\2"+ - "\2\3\u0196\3\2\2\2\3\u0198\3\2\2\2\3\u019a\3\2\2\2\3\u019c\3\2\2\2\3\u019e"+ - "\3\2\2\2\3\u01a0\3\2\2\2\3\u01a2\3\2\2\2\3\u01a4\3\2\2\2\3\u01a6\3\2\2"+ - "\2\3\u01a8\3\2\2\2\3\u01aa\3\2\2\2\3\u01ac\3\2\2\2\3\u01ae\3\2\2\2\3\u01b0"+ - "\3\2\2\2\3\u01b2\3\2\2\2\3\u01b4\3\2\2\2\3\u01b6\3\2\2\2\3\u01b8\3\2\2"+ - "\2\3\u01ba\3\2\2\2\3\u01bc\3\2\2\2\3\u01be\3\2\2\2\3\u01c0\3\2\2\2\3\u01c2"+ - "\3\2\2\2\3\u01c4\3\2\2\2\3\u01c6\3\2\2\2\3\u01c8\3\2\2\2\3\u01ca\3\2\2"+ - "\2\3\u01cc\3\2\2\2\3\u01ce\3\2\2\2\3\u01d0\3\2\2\2\3\u01d2\3\2\2\2\3\u01d4"+ - "\3\2\2\2\3\u01d6\3\2\2\2\3\u01d8\3\2\2\2\3\u01da\3\2\2\2\3\u01dc\3\2\2"+ - "\2\3\u01de\3\2\2\2\3\u01e0\3\2\2\2\3\u01e2\3\2\2\2\3\u01e4\3\2\2\2\3\u01e6"+ - "\3\2\2\2\3\u01e8\3\2\2\2\3\u01ea\3\2\2\2\3\u01ec\3\2\2\2\3\u01ee\3\2\2"+ - "\2\3\u01f0\3\2\2\2\3\u01f2\3\2\2\2\3\u01f4\3\2\2\2\3\u01f6\3\2\2\2\3\u01f8"+ - "\3\2\2\2\3\u01fa\3\2\2\2\3\u01fc\3\2\2\2\3\u01fe\3\2\2\2\3\u0200\3\2\2"+ - "\2\3\u0202\3\2\2\2\3\u0204\3\2\2\2\3\u0206\3\2\2\2\3\u0208\3\2\2\2\3\u020a"+ - "\3\2\2\2\3\u020c\3\2\2\2\3\u020e\3\2\2\2\3\u0210\3\2\2\2\3\u0212\3\2\2"+ - "\2\3\u0214\3\2\2\2\3\u0216\3\2\2\2\3\u0218\3\2\2\2\3\u021a\3\2\2\2\3\u021c"+ - "\3\2\2\2\3\u021e\3\2\2\2\3\u0220\3\2\2\2\3\u0222\3\2\2\2\3\u0224\3\2\2"+ - "\2\3\u0226\3\2\2\2\3\u0228\3\2\2\2\3\u022a\3\2\2\2\3\u022c\3\2\2\2\3\u022e"+ - "\3\2\2\2\3\u0230\3\2\2\2\3\u0232\3\2\2\2\3\u0234\3\2\2\2\3\u0236\3\2\2"+ - "\2\3\u0238\3\2\2\2\3\u023a\3\2\2\2\3\u023c\3\2\2\2\3\u023e\3\2\2\2\3\u0240"+ - "\3\2\2\2\3\u0242\3\2\2\2\3\u0244\3\2\2\2\3\u0246\3\2\2\2\3\u0248\3\2\2"+ - "\2\3\u024a\3\2\2\2\3\u024c\3\2\2\2\3\u024e\3\2\2\2\3\u0250\3\2\2\2\3\u0252"+ - "\3\2\2\2\3\u0254\3\2\2\2\3\u0256\3\2\2\2\4\u0258\3\2\2\2\4\u025a\3\2\2"+ - "\2\4\u025c\3\2\2\2\4\u025e\3\2\2\2\4\u0260\3\2\2\2\5\u0262\3\2\2\2\5\u0264"+ - "\3\2\2\2\5\u0266\3\2\2\2\5\u0268\3\2\2\2\5\u026a\3\2\2\2\5\u026c\3\2\2"+ - "\2\6\u026e\3\2\2\2\b\u0277\3\2\2\2\n\u0286\3\2\2\2\f\u0291\3\2\2\2\16"+ - "\u029a\3\2\2\2\20\u029f\3\2\2\2\22\u02a1\3\2\2\2\24\u02a5\3\2\2\2\26\u02a7"+ - "\3\2\2\2\30\u02a9\3\2\2\2\32\u02ad\3\2\2\2\34\u02b1\3\2\2\2\36\u02b5\3"+ - "\2\2\2 \u02b9\3\2\2\2\"\u02bd\3\2\2\2$\u02c1\3\2\2\2&\u02c3\3\2\2\2(\u02c5"+ - "\3\2\2\2*\u02c7\3\2\2\2,\u02c9\3\2\2\2.\u02cb\3\2\2\2\60\u02ce\3\2\2\2"+ - "\62\u02d1\3\2\2\2\64\u02d4\3\2\2\2\66\u02d7\3\2\2\28\u02da\3\2\2\2:\u02dc"+ - "\3\2\2\2<\u02de\3\2\2\2>\u02e0\3\2\2\2@\u02e2\3\2\2\2B\u02e5\3\2\2\2D"+ - "\u02e8\3\2\2\2F\u02eb\3\2\2\2H\u02ee\3\2\2\2J\u02f1\3\2\2\2L\u02f4\3\2"+ - "\2\2N\u02f7\3\2\2\2P\u02fa\3\2\2\2R\u02fd\3\2\2\2T\u0300\3\2\2\2V\u0302"+ - "\3\2\2\2X\u0304\3\2\2\2Z\u0309\3\2\2\2\\\u030c\3\2\2\2^\u030e\3\2\2\2"+ - "`\u0310\3\2\2\2b\u0312\3\2\2\2d\u0315\3\2\2\2f\u0318\3\2\2\2h\u031b\3"+ - "\2\2\2j\u031f\3\2\2\2l\u0323\3\2\2\2n\u0326\3\2\2\2p\u032a\3\2\2\2r\u032c"+ - "\3\2\2\2t\u0336\3\2\2\2v\u0342\3\2\2\2x\u034b\3\2\2\2z\u0353\3\2\2\2|"+ - "\u035c\3\2\2\2~\u0364\3\2\2\2\u0080\u036b\3\2\2\2\u0082\u0371\3\2\2\2"+ - "\u0084\u037b\3\2\2\2\u0086\u037f\3\2\2\2\u0088\u0386\3\2\2\2\u008a\u038a"+ - "\3\2\2\2\u008c\u038e\3\2\2\2\u008e\u0398\3\2\2\2\u0090\u03a4\3\2\2\2\u0092"+ - "\u03a7\3\2\2\2\u0094\u03b1\3\2\2\2\u0096\u03b6\3\2\2\2\u0098\u03bb\3\2"+ - "\2\2\u009a\u03c1\3\2\2\2\u009c\u03c8\3\2\2\2\u009e\u03ce\3\2\2\2\u00a0"+ - "\u03d1\3\2\2\2\u00a2\u03d6\3\2\2\2\u00a4\u03db\3\2\2\2\u00a6\u03df\3\2"+ - "\2\2\u00a8\u03e5\3\2\2\2\u00aa\u03ed\3\2\2\2\u00ac\u03f1\3\2\2\2\u00ae"+ - "\u03f4\3\2\2\2\u00b0\u03fa\3\2\2\2\u00b2\u0400\3\2\2\2\u00b4\u0407\3\2"+ - "\2\2\u00b6\u0410\3\2\2\2\u00b8\u0416\3\2\2\2\u00ba\u0419\3\2\2\2\u00bc"+ - "\u041c\3\2\2\2\u00be\u041f\3\2\2\2\u00c0\u0427\3\2\2\2\u00c2\u042f\3\2"+ - "\2\2\u00c4\u0433\3\2\2\2\u00c6\u0437\3\2\2\2\u00c8\u043b\3\2\2\2\u00ca"+ - "\u0443\3\2\2\2\u00cc\u0449\3\2\2\2\u00ce\u0450\3\2\2\2\u00d0\u045a\3\2"+ - "\2\2\u00d2\u045f\3\2\2\2\u00d4\u0464\3\2\2\2\u00d6\u046e\3\2\2\2\u00d8"+ - "\u0475\3\2\2\2\u00da\u047f\3\2\2\2\u00dc\u0489\3\2\2\2\u00de\u0490\3\2"+ - "\2\2\u00e0\u0498\3\2\2\2\u00e2\u04a2\3\2\2\2\u00e4\u04ab\3\2\2\2\u00e6"+ - "\u04b0\3\2\2\2\u00e8\u04b7\3\2\2\2\u00ea\u04c2\3\2\2\2\u00ec\u04c7\3\2"+ - "\2\2\u00ee\u04cd\3\2\2\2\u00f0\u04d5\3\2\2\2\u00f2\u04de\3\2\2\2\u00f4"+ - "\u04e5\3\2\2\2\u00f6\u04eb\3\2\2\2\u00f8\u04f4\3\2\2\2\u00fa\u04fc\3\2"+ - "\2\2\u00fc\u0505\3\2\2\2\u00fe\u050e\3\2\2\2\u0100\u0514\3\2\2\2\u0102"+ - "\u0519\3\2\2\2\u0104\u051f\3\2\2\2\u0106\u0528\3\2\2\2\u0108\u052f\3\2"+ - "\2\2\u010a\u0538\3\2\2\2\u010c\u0544\3\2\2\2\u010e\u054c\3\2\2\2\u0110"+ - "\u0553\3\2\2\2\u0112\u055a\3\2\2\2\u0114\u055e\3\2\2\2\u0116\u0566\3\2"+ - "\2\2\u0118\u056e\3\2\2\2\u011a\u0572\3\2\2\2\u011c\u057e\3\2\2\2\u011e"+ - "\u0580\3\2\2\2\u0120\u0591\3\2\2\2\u0122\u0596\3\2\2\2\u0124\u05a4\3\2"+ - "\2\2\u0126\u05a6\3\2\2\2\u0128\u05a8\3\2\2\2\u012a\u05aa\3\2\2\2\u012c"+ - "\u05ae\3\2\2\2\u012e\u05be\3\2\2\2\u0130\u05c0\3\2\2\2\u0132\u05c4\3\2"+ - "\2\2\u0134\u05d4\3\2\2\2\u0136\u05d6\3\2\2\2\u0138\u05e1\3\2\2\2\u013a"+ - "\u05e3\3\2\2\2\u013c\u05fb\3\2\2\2\u013e\u0625\3\2\2\2\u0140\u0627\3\2"+ - "\2\2\u0142\u062a\3\2\2\2\u0144\u062d\3\2\2\2\u0146\u0636\3\2\2\2\u0148"+ - "\u0638\3\2\2\2\u014a\u063f\3\2\2\2\u014c\u0648\3\2\2\2\u014e\u064a\3\2"+ - "\2\2\u0150\u064c\3\2\2\2\u0152\u064e\3\2\2\2\u0154\u0650\3\2\2\2\u0156"+ - "\u0652\3\2\2\2\u0158\u0654\3\2\2\2\u015a\u0656\3\2\2\2\u015c\u0658\3\2"+ - "\2\2\u015e\u065a\3\2\2\2\u0160\u065f\3\2\2\2\u0162\u0664\3\2\2\2\u0164"+ - "\u0669\3\2\2\2\u0166\u066e\3\2\2\2\u0168\u0673\3\2\2\2\u016a\u0678\3\2"+ - "\2\2\u016c\u067c\3\2\2\2\u016e\u0680\3\2\2\2\u0170\u0684\3\2\2\2\u0172"+ - "\u0688\3\2\2\2\u0174\u068c\3\2\2\2\u0176\u0690\3\2\2\2\u0178\u0694\3\2"+ - "\2\2\u017a\u0698\3\2\2\2\u017c\u069c\3\2\2\2\u017e\u06a0\3\2\2\2\u0180"+ - "\u06a4\3\2\2\2\u0182\u06ab\3\2\2\2\u0184\u06af\3\2\2\2\u0186\u06b3\3\2"+ - "\2\2\u0188\u06b7\3\2\2\2\u018a\u06bb\3\2\2\2\u018c\u06bf\3\2\2\2\u018e"+ - "\u06c3\3\2\2\2\u0190\u06c7\3\2\2\2\u0192\u06cb\3\2\2\2\u0194\u06cf\3\2"+ - "\2\2\u0196\u06d3\3\2\2\2\u0198\u06d7\3\2\2\2\u019a\u06db\3\2\2\2\u019c"+ - "\u06df\3\2\2\2\u019e\u06e3\3\2\2\2\u01a0\u06e7\3\2\2\2\u01a2\u06eb\3\2"+ - "\2\2\u01a4\u06ef\3\2\2\2\u01a6\u06f6\3\2\2\2\u01a8\u06fa\3\2\2\2\u01aa"+ - "\u06fe\3\2\2\2\u01ac\u0702\3\2\2\2\u01ae\u0706\3\2\2\2\u01b0\u070a\3\2"+ - "\2\2\u01b2\u070e\3\2\2\2\u01b4\u0712\3\2\2\2\u01b6\u0716\3\2\2\2\u01b8"+ - "\u071a\3\2\2\2\u01ba\u071e\3\2\2\2\u01bc\u0722\3\2\2\2\u01be\u0726\3\2"+ - "\2\2\u01c0\u072a\3\2\2\2\u01c2\u072e\3\2\2\2\u01c4\u0732\3\2\2\2\u01c6"+ - "\u0737\3\2\2\2\u01c8\u073c\3\2\2\2\u01ca\u0740\3\2\2\2\u01cc\u0744\3\2"+ - "\2\2\u01ce\u0748\3\2\2\2\u01d0\u074c\3\2\2\2\u01d2\u0750\3\2\2\2\u01d4"+ - "\u0754\3\2\2\2\u01d6\u0758\3\2\2\2\u01d8\u075c\3\2\2\2\u01da\u0760\3\2"+ - "\2\2\u01dc\u0764\3\2\2\2\u01de\u0768\3\2\2\2\u01e0\u076c\3\2\2\2\u01e2"+ - "\u0770\3\2\2\2\u01e4\u0774\3\2\2\2\u01e6\u0778\3\2\2\2\u01e8\u077c\3\2"+ - "\2\2\u01ea\u0780\3\2\2\2\u01ec\u0784\3\2\2\2\u01ee\u0788\3\2\2\2\u01f0"+ - "\u078c\3\2\2\2\u01f2\u0790\3\2\2\2\u01f4\u0794\3\2\2\2\u01f6\u0798\3\2"+ - "\2\2\u01f8\u079c\3\2\2\2\u01fa\u07a0\3\2\2\2\u01fc\u07a4\3\2\2\2\u01fe"+ - "\u07a8\3\2\2\2\u0200\u07ac\3\2\2\2\u0202\u07b0\3\2\2\2\u0204\u07b4\3\2"+ - "\2\2\u0206\u07b8\3\2\2\2\u0208\u07bc\3\2\2\2\u020a\u07c0\3\2\2\2\u020c"+ - "\u07c4\3\2\2\2\u020e\u07c8\3\2\2\2\u0210\u07cc\3\2\2\2\u0212\u07d0\3\2"+ - "\2\2\u0214\u07d4\3\2\2\2\u0216\u07d8\3\2\2\2\u0218\u07dc\3\2\2\2\u021a"+ - "\u07e0\3\2\2\2\u021c\u07e4\3\2\2\2\u021e\u07e8\3\2\2\2\u0220\u07ec\3\2"+ - "\2\2\u0222\u07f0\3\2\2\2\u0224\u07f4\3\2\2\2\u0226\u07f8\3\2\2\2\u0228"+ - "\u07fc\3\2\2\2\u022a\u0800\3\2\2\2\u022c\u0804\3\2\2\2\u022e\u0808\3\2"+ - "\2\2\u0230\u080c\3\2\2\2\u0232\u0810\3\2\2\2\u0234\u0814\3\2\2\2\u0236"+ - "\u0818\3\2\2\2\u0238\u081c\3\2\2\2\u023a\u0820\3\2\2\2\u023c\u0824\3\2"+ - "\2\2\u023e\u0828\3\2\2\2\u0240\u082c\3\2\2\2\u0242\u0830\3\2\2\2\u0244"+ - "\u0834\3\2\2\2\u0246\u0838\3\2\2\2\u0248\u083c\3\2\2\2\u024a\u0840\3\2"+ - "\2\2\u024c\u0844\3\2\2\2\u024e\u0848\3\2\2\2\u0250\u084c\3\2\2\2\u0252"+ - "\u0852\3\2\2\2\u0254\u0856\3\2\2\2\u0256\u085a\3\2\2\2\u0258\u085e\3\2"+ - "\2\2\u025a\u0862\3\2\2\2\u025c\u086a\3\2\2\2\u025e\u086e\3\2\2\2\u0260"+ - "\u0870\3\2\2\2\u0262\u0876\3\2\2\2\u0264\u087f\3\2\2\2\u0266\u0883\3\2"+ - "\2\2\u0268\u088b\3\2\2\2\u026a\u088d\3\2\2\2\u026c\u0892\3\2\2\2\u026e"+ - "\u026f\7%\2\2\u026f\u0270\7#\2\2\u0270\u0274\3\2\2\2\u0271\u0273\n\2\2"+ - "\2\u0272\u0271\3\2\2\2\u0273\u0276\3\2\2\2\u0274\u0272\3\2\2\2\u0274\u0275"+ - "\3\2\2\2\u0275\7\3\2\2\2\u0276\u0274\3\2\2\2\u0277\u0278\7\61\2\2\u0278"+ - "\u0279\7,\2\2\u0279\u027e\3\2\2\2\u027a\u027d\5\b\3\2\u027b\u027d\13\2"+ - "\2\2\u027c\u027a\3\2\2\2\u027c\u027b\3\2\2\2\u027d\u0280\3\2\2\2\u027e"+ - "\u027f\3\2\2\2\u027e\u027c\3\2\2\2\u027f\u0281\3\2\2\2\u0280\u027e\3\2"+ - "\2\2\u0281\u0282\7,\2\2\u0282\u0283\7\61\2\2\u0283\u0284\3\2\2\2\u0284"+ - "\u0285\b\3\2\2\u0285\t\3\2\2\2\u0286\u0287\7\61\2\2\u0287\u0288\7\61\2"+ - "\2\u0288\u028c\3\2\2\2\u0289\u028b\n\2\2\2\u028a\u0289\3\2\2\2\u028b\u028e"+ - "\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d\u028f\3\2\2\2\u028e"+ - "\u028c\3\2\2\2\u028f\u0290\b\4\2\2\u0290\13\3\2\2\2\u0291\u0292\t\3\2"+ - "\2\u0292\u0293\3\2\2\2\u0293\u0294\b\5\2\2\u0294\r\3\2\2\2\u0295\u029b"+ - "\7\f\2\2\u0296\u0298\7\17\2\2\u0297\u0299\7\f\2\2\u0298\u0297\3\2\2\2"+ - "\u0298\u0299\3\2\2\2\u0299\u029b\3\2\2\2\u029a\u0295\3\2\2\2\u029a\u0296"+ - "\3\2\2\2\u029b\17\3\2\2\2\u029c\u02a0\5\b\3\2\u029d\u02a0\5\n\4\2\u029e"+ - "\u02a0\5\f\5\2\u029f\u029c\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u029e\3\2"+ - "\2\2\u02a0\21\3\2\2\2\u02a1\u02a2\7\60\2\2\u02a2\u02a3\7\60\2\2\u02a3"+ - "\u02a4\7\60\2\2\u02a4\23\3\2\2\2\u02a5\u02a6\7\60\2\2\u02a6\25\3\2\2\2"+ - "\u02a7\u02a8\7.\2\2\u02a8\27\3\2\2\2\u02a9\u02aa\7*\2\2\u02aa\u02ab\3"+ - "\2\2\2\u02ab\u02ac\b\13\3\2\u02ac\31\3\2\2\2\u02ad\u02ae\7+\2\2\u02ae"+ - "\u02af\3\2\2\2\u02af\u02b0\b\f\4\2\u02b0\33\3\2\2\2\u02b1\u02b2\7]\2\2"+ - "\u02b2\u02b3\3\2\2\2\u02b3\u02b4\b\r\3\2\u02b4\35\3\2\2\2\u02b5\u02b6"+ - "\7_\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b8\b\16\4\2\u02b8\37\3\2\2\2\u02b9"+ - "\u02ba\7}\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bc\b\17\5\2\u02bc!\3\2\2\2"+ - "\u02bd\u02be\7\177\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\b\20\4\2\u02c0"+ - "#\3\2\2\2\u02c1\u02c2\7,\2\2\u02c2%\3\2\2\2\u02c3\u02c4\7\'\2\2\u02c4"+ - "\'\3\2\2\2\u02c5\u02c6\7\61\2\2\u02c6)\3\2\2\2\u02c7\u02c8\7-\2\2\u02c8"+ - "+\3\2\2\2\u02c9\u02ca\7/\2\2\u02ca-\3\2\2\2\u02cb\u02cc\7-\2\2\u02cc\u02cd"+ - "\7-\2\2\u02cd/\3\2\2\2\u02ce\u02cf\7/\2\2\u02cf\u02d0\7/\2\2\u02d0\61"+ - "\3\2\2\2\u02d1\u02d2\7(\2\2\u02d2\u02d3\7(\2\2\u02d3\63\3\2\2\2\u02d4"+ - "\u02d5\7~\2\2\u02d5\u02d6\7~\2\2\u02d6\65\3\2\2\2\u02d7\u02d8\7#\2\2\u02d8"+ - "\u02d9\5\20\7\2\u02d9\67\3\2\2\2\u02da\u02db\7#\2\2\u02db9\3\2\2\2\u02dc"+ - "\u02dd\7<\2\2\u02dd;\3\2\2\2\u02de\u02df\7=\2\2\u02df=\3\2\2\2\u02e0\u02e1"+ - "\7?\2\2\u02e1?\3\2\2\2\u02e2\u02e3\7-\2\2\u02e3\u02e4\7?\2\2\u02e4A\3"+ - "\2\2\2\u02e5\u02e6\7/\2\2\u02e6\u02e7\7?\2\2\u02e7C\3\2\2\2\u02e8\u02e9"+ - "\7,\2\2\u02e9\u02ea\7?\2\2\u02eaE\3\2\2\2\u02eb\u02ec\7\61\2\2\u02ec\u02ed"+ - "\7?\2\2\u02edG\3\2\2\2\u02ee\u02ef\7\'\2\2\u02ef\u02f0\7?\2\2\u02f0I\3"+ - "\2\2\2\u02f1\u02f2\7/\2\2\u02f2\u02f3\7@\2\2\u02f3K\3\2\2\2\u02f4\u02f5"+ - "\7?\2\2\u02f5\u02f6\7@\2\2\u02f6M\3\2\2\2\u02f7\u02f8\7\60\2\2\u02f8\u02f9"+ - "\7\60\2\2\u02f9O\3\2\2\2\u02fa\u02fb\7<\2\2\u02fb\u02fc\7<\2\2\u02fcQ"+ - "\3\2\2\2\u02fd\u02fe\7=\2\2\u02fe\u02ff\7=\2\2\u02ffS\3\2\2\2\u0300\u0301"+ - "\7%\2\2\u0301U\3\2\2\2\u0302\u0303\7B\2\2\u0303W\3\2\2\2\u0304\u0307\5"+ - "V*\2\u0305\u0308\5\20\7\2\u0306\u0308\5\16\6\2\u0307\u0305\3\2\2\2\u0307"+ - "\u0306\3\2\2\2\u0308Y\3\2\2\2\u0309\u030a\7A\2\2\u030a\u030b\5\20\7\2"+ - "\u030b[\3\2\2\2\u030c\u030d\7A\2\2\u030d]\3\2\2\2\u030e\u030f\7>\2\2\u030f"+ - "_\3\2\2\2\u0310\u0311\7@\2\2\u0311a\3\2\2\2\u0312\u0313\7>\2\2\u0313\u0314"+ - "\7?\2\2\u0314c\3\2\2\2\u0315\u0316\7@\2\2\u0316\u0317\7?\2\2\u0317e\3"+ - "\2\2\2\u0318\u0319\7#\2\2\u0319\u031a\7?\2\2\u031ag\3\2\2\2\u031b\u031c"+ - "\7#\2\2\u031c\u031d\7?\2\2\u031d\u031e\7?\2\2\u031ei\3\2\2\2\u031f\u0320"+ - "\7c\2\2\u0320\u0321\7u\2\2\u0321\u0322\7A\2\2\u0322k\3\2\2\2\u0323\u0324"+ - "\7?\2\2\u0324\u0325\7?\2\2\u0325m\3\2\2\2\u0326\u0327\7?\2\2\u0327\u0328"+ - "\7?\2\2\u0328\u0329\7?\2\2\u0329o\3\2\2\2\u032a\u032b\7)\2\2\u032bq\3"+ - "\2\2\2\u032c\u032d\7t\2\2\u032d\u032e\7g\2\2\u032e\u032f\7v\2\2\u032f"+ - "\u0330\7w\2\2\u0330\u0331\7t\2\2\u0331\u0332\7p\2\2\u0332\u0333\7B\2\2"+ - "\u0333\u0334\3\2\2\2\u0334\u0335\5\u013c\u009d\2\u0335s\3\2\2\2\u0336"+ - "\u0337\7e\2\2\u0337\u0338\7q\2\2\u0338\u0339\7p\2\2\u0339\u033a\7v\2\2"+ - "\u033a\u033b\7k\2\2\u033b\u033c\7p\2\2\u033c\u033d\7w\2\2\u033d\u033e"+ - "\7g\2\2\u033e\u033f\7B\2\2\u033f\u0340\3\2\2\2\u0340\u0341\5\u013c\u009d"+ - "\2\u0341u\3\2\2\2\u0342\u0343\7d\2\2\u0343\u0344\7t\2\2\u0344\u0345\7"+ - "g\2\2\u0345\u0346\7c\2\2\u0346\u0347\7m\2\2\u0347\u0348\7B\2\2\u0348\u0349"+ - "\3\2\2\2\u0349\u034a\5\u013c\u009d\2\u034aw\3\2\2\2\u034b\u034c\7v\2\2"+ - "\u034c\u034d\7j\2\2\u034d\u034e\7k\2\2\u034e\u034f\7u\2\2\u034f\u0350"+ - "\7B\2\2\u0350\u0351\3\2\2\2\u0351\u0352\5\u013c\u009d\2\u0352y\3\2\2\2"+ - "\u0353\u0354\7u\2\2\u0354\u0355\7w\2\2\u0355\u0356\7r\2\2\u0356\u0357"+ - "\7g\2\2\u0357\u0358\7t\2\2\u0358\u0359\7B\2\2\u0359\u035a\3\2\2\2\u035a"+ - "\u035b\5\u013c\u009d\2\u035b{\3\2\2\2\u035c\u035d\7r\2\2\u035d\u035e\7"+ - "c\2\2\u035e\u035f\7e\2\2\u035f\u0360\7m\2\2\u0360\u0361\7c\2\2\u0361\u0362"+ - "\7i\2\2\u0362\u0363\7g\2\2\u0363}\3\2\2\2\u0364\u0365\7k\2\2\u0365\u0366"+ - "\7o\2\2\u0366\u0367\7r\2\2\u0367\u0368\7q\2\2\u0368\u0369\7t\2\2\u0369"+ - "\u036a\7v\2\2\u036a\177\3\2\2\2\u036b\u036c\7e\2\2\u036c\u036d\7n\2\2"+ - "\u036d\u036e\7c\2\2\u036e\u036f\7u\2\2\u036f\u0370\7u\2\2\u0370\u0081"+ - "\3\2\2\2\u0371\u0372\7k\2\2\u0372\u0373\7p\2\2\u0373\u0374\7v\2\2\u0374"+ - "\u0375\7g\2\2\u0375\u0376\7t\2\2\u0376\u0377\7h\2\2\u0377\u0378\7c\2\2"+ - "\u0378\u0379\7e\2\2\u0379\u037a\7g\2\2\u037a\u0083\3\2\2\2\u037b\u037c"+ - "\7h\2\2\u037c\u037d\7w\2\2\u037d\u037e\7p\2\2\u037e\u0085\3\2\2\2\u037f"+ - "\u0380\7q\2\2\u0380\u0381\7d\2\2\u0381\u0382\7l\2\2\u0382\u0383\7g\2\2"+ - "\u0383\u0384\7e\2\2\u0384\u0385\7v\2\2\u0385\u0087\3\2\2\2\u0386\u0387"+ - "\7x\2\2\u0387\u0388\7c\2\2\u0388\u0389\7n\2\2\u0389\u0089\3\2\2\2\u038a"+ - "\u038b\7x\2\2\u038b\u038c\7c\2\2\u038c\u038d\7t\2\2\u038d\u008b\3\2\2"+ - "\2\u038e\u038f\7v\2\2\u038f\u0390\7{\2\2\u0390\u0391\7r\2\2\u0391\u0392"+ - "\7g\2\2\u0392\u0393\7c\2\2\u0393\u0394\7n\2\2\u0394\u0395\7k\2\2\u0395"+ - "\u0396\7c\2\2\u0396\u0397\7u\2\2\u0397\u008d\3\2\2\2\u0398\u0399\7e\2"+ - "\2\u0399\u039a\7q\2\2\u039a\u039b\7p\2\2\u039b\u039c\7u\2\2\u039c\u039d"+ - "\7v\2\2\u039d\u039e\7t\2\2\u039e\u039f\7w\2\2\u039f\u03a0\7e\2\2\u03a0"+ - "\u03a1\7v\2\2\u03a1\u03a2\7q\2\2\u03a2\u03a3\7t\2\2\u03a3\u008f\3\2\2"+ - "\2\u03a4\u03a5\7d\2\2\u03a5\u03a6\7{\2\2\u03a6\u0091\3\2\2\2\u03a7\u03a8"+ - "\7e\2\2\u03a8\u03a9\7q\2\2\u03a9\u03aa\7o\2\2\u03aa\u03ab\7r\2\2\u03ab"+ - "\u03ac\7c\2\2\u03ac\u03ad\7p\2\2\u03ad\u03ae\7k\2\2\u03ae\u03af\7q\2\2"+ - "\u03af\u03b0\7p\2\2\u03b0\u0093\3\2\2\2\u03b1\u03b2\7k\2\2\u03b2\u03b3"+ - "\7p\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7v\2\2\u03b5\u0095\3\2\2\2\u03b6"+ - "\u03b7\7v\2\2\u03b7\u03b8\7j\2\2\u03b8\u03b9\7k\2\2\u03b9\u03ba\7u\2\2"+ - "\u03ba\u0097\3\2\2\2\u03bb\u03bc\7u\2\2\u03bc\u03bd\7w\2\2\u03bd\u03be"+ - "\7r\2\2\u03be\u03bf\7g\2\2\u03bf\u03c0\7t\2\2\u03c0\u0099\3\2\2\2\u03c1"+ - "\u03c2\7v\2\2\u03c2\u03c3\7{\2\2\u03c3\u03c4\7r\2\2\u03c4\u03c5\7g\2\2"+ - "\u03c5\u03c6\7q\2\2\u03c6\u03c7\7h\2\2\u03c7\u009b\3\2\2\2\u03c8\u03c9"+ - "\7y\2\2\u03c9\u03ca\7j\2\2\u03ca\u03cb\7g\2\2\u03cb\u03cc\7t\2\2\u03cc"+ - "\u03cd\7g\2\2\u03cd\u009d\3\2\2\2\u03ce\u03cf\7k\2\2\u03cf\u03d0\7h\2"+ - "\2\u03d0\u009f\3\2\2\2\u03d1\u03d2\7g\2\2\u03d2\u03d3\7n\2\2\u03d3\u03d4"+ - "\7u\2\2\u03d4\u03d5\7g\2\2\u03d5\u00a1\3\2\2\2\u03d6\u03d7\7y\2\2\u03d7"+ - "\u03d8\7j\2\2\u03d8\u03d9\7g\2\2\u03d9\u03da\7p\2\2\u03da\u00a3\3\2\2"+ - "\2\u03db\u03dc\7v\2\2\u03dc\u03dd\7t\2\2\u03dd\u03de\7{\2\2\u03de\u00a5"+ - "\3\2\2\2\u03df\u03e0\7e\2\2\u03e0\u03e1\7c\2\2\u03e1\u03e2\7v\2\2\u03e2"+ - "\u03e3\7e\2\2\u03e3\u03e4\7j\2\2\u03e4\u00a7\3\2\2\2\u03e5\u03e6\7h\2"+ - "\2\u03e6\u03e7\7k\2\2\u03e7\u03e8\7p\2\2\u03e8\u03e9\7c\2\2\u03e9\u03ea"+ - "\7n\2\2\u03ea\u03eb\7n\2\2\u03eb\u03ec\7{\2\2\u03ec\u00a9\3\2\2\2\u03ed"+ - "\u03ee\7h\2\2\u03ee\u03ef\7q\2\2\u03ef\u03f0\7t\2\2\u03f0\u00ab\3\2\2"+ - "\2\u03f1\u03f2\7f\2\2\u03f2\u03f3\7q\2\2\u03f3\u00ad\3\2\2\2\u03f4\u03f5"+ - "\7y\2\2\u03f5\u03f6\7j\2\2\u03f6\u03f7\7k\2\2\u03f7\u03f8\7n\2\2\u03f8"+ - "\u03f9\7g\2\2\u03f9\u00af\3\2\2\2\u03fa\u03fb\7v\2\2\u03fb\u03fc\7j\2"+ - "\2\u03fc\u03fd\7t\2\2\u03fd\u03fe\7q\2\2\u03fe\u03ff\7y\2\2\u03ff\u00b1"+ - "\3\2\2\2\u0400\u0401\7t\2\2\u0401\u0402\7g\2\2\u0402\u0403\7v\2\2\u0403"+ - "\u0404\7w\2\2\u0404\u0405\7t\2\2\u0405\u0406\7p\2\2\u0406\u00b3\3\2\2"+ - "\2\u0407\u0408\7e\2\2\u0408\u0409\7q\2\2\u0409\u040a\7p\2\2\u040a\u040b"+ - "\7v\2\2\u040b\u040c\7k\2\2\u040c\u040d\7p\2\2\u040d\u040e\7w\2\2\u040e"+ - "\u040f\7g\2\2\u040f\u00b5\3\2\2\2\u0410\u0411\7d\2\2\u0411\u0412\7t\2"+ - "\2\u0412\u0413\7g\2\2\u0413\u0414\7c\2\2\u0414\u0415\7m\2\2\u0415\u00b7"+ - "\3\2\2\2\u0416\u0417\7c\2\2\u0417\u0418\7u\2\2\u0418\u00b9\3\2\2\2\u0419"+ - "\u041a\7k\2\2\u041a\u041b\7u\2\2\u041b\u00bb\3\2\2\2\u041c\u041d\7k\2"+ - "\2\u041d\u041e\7p\2\2\u041e\u00bd\3\2\2\2\u041f\u0420\7#\2\2\u0420\u0421"+ - "\7k\2\2\u0421\u0422\7u\2\2\u0422\u0425\3\2\2\2\u0423\u0426\5\20\7\2\u0424"+ - "\u0426\5\16\6\2\u0425\u0423\3\2\2\2\u0425\u0424\3\2\2\2\u0426\u00bf\3"+ - "\2\2\2\u0427\u0428\7#\2\2\u0428\u0429\7k\2\2\u0429\u042a\7p\2\2\u042a"+ - "\u042d\3\2\2\2\u042b\u042e\5\20\7\2\u042c\u042e\5\16\6\2\u042d\u042b\3"+ - "\2\2\2\u042d\u042c\3\2\2\2\u042e\u00c1\3\2\2\2\u042f\u0430\7q\2\2\u0430"+ - "\u0431\7w\2\2\u0431\u0432\7v\2\2\u0432\u00c3\3\2\2\2\u0433\u0434\7i\2"+ - "\2\u0434\u0435\7g\2\2\u0435\u0436\7v\2\2\u0436\u00c5\3\2\2\2\u0437\u0438"+ - "\7u\2\2\u0438\u0439\7g\2\2\u0439\u043a\7v\2\2\u043a\u00c7\3\2\2\2\u043b"+ - "\u043c\7f\2\2\u043c\u043d\7{\2\2\u043d\u043e\7p\2\2\u043e\u043f\7c\2\2"+ - "\u043f\u0440\7o\2\2\u0440\u0441\7k\2\2\u0441\u0442\7e\2\2\u0442\u00c9"+ - "\3\2\2\2\u0443\u0444\7B\2\2\u0444\u0445\7h\2\2\u0445\u0446\7k\2\2\u0446"+ - "\u0447\7n\2\2\u0447\u0448\7g\2\2\u0448\u00cb\3\2\2\2\u0449\u044a\7B\2"+ - "\2\u044a\u044b\7h\2\2\u044b\u044c\7k\2\2\u044c\u044d\7g\2\2\u044d\u044e"+ - "\7n\2\2\u044e\u044f\7f\2\2\u044f\u00cd\3\2\2\2\u0450\u0451\7B\2\2\u0451"+ - "\u0452\7r\2\2\u0452\u0453\7t\2\2\u0453\u0454\7q\2\2\u0454\u0455\7r\2\2"+ - "\u0455\u0456\7g\2\2\u0456\u0457\7t\2\2\u0457\u0458\7v\2\2\u0458\u0459"+ - "\7{\2\2\u0459\u00cf\3\2\2\2\u045a\u045b\7B\2\2\u045b\u045c\7i\2\2\u045c"+ - "\u045d\7g\2\2\u045d\u045e\7v\2\2\u045e\u00d1\3\2\2\2\u045f\u0460\7B\2"+ - "\2\u0460\u0461\7u\2\2\u0461\u0462\7g\2\2\u0462\u0463\7v\2\2\u0463\u00d3"+ - "\3\2\2\2\u0464\u0465\7B\2\2\u0465\u0466\7t\2\2\u0466\u0467\7g\2\2\u0467"+ - "\u0468\7e\2\2\u0468\u0469\7g\2\2\u0469\u046a\7k\2\2\u046a\u046b\7x\2\2"+ - "\u046b\u046c\7g\2\2\u046c\u046d\7t\2\2\u046d\u00d5\3\2\2\2\u046e\u046f"+ - "\7B\2\2\u046f\u0470\7r\2\2\u0470\u0471\7c\2\2\u0471\u0472\7t\2\2\u0472"+ - "\u0473\7c\2\2\u0473\u0474\7o\2\2\u0474\u00d7\3\2\2\2\u0475\u0476\7B\2"+ - "\2\u0476\u0477\7u\2\2\u0477\u0478\7g\2\2\u0478\u0479\7v\2\2\u0479\u047a"+ - "\7r\2\2\u047a\u047b\7c\2\2\u047b\u047c\7t\2\2\u047c\u047d\7c\2\2\u047d"+ - "\u047e\7o\2\2\u047e\u00d9\3\2\2\2\u047f\u0480\7B\2\2\u0480\u0481\7f\2"+ - "\2\u0481\u0482\7g\2\2\u0482\u0483\7n\2\2\u0483\u0484\7g\2\2\u0484\u0485"+ - "\7i\2\2\u0485\u0486\7c\2\2\u0486\u0487\7v\2\2\u0487\u0488\7g\2\2\u0488"+ - "\u00db\3\2\2\2\u0489\u048a\7r\2\2\u048a\u048b\7w\2\2\u048b\u048c\7d\2"+ - "\2\u048c\u048d\7n\2\2\u048d\u048e\7k\2\2\u048e\u048f\7e\2\2\u048f\u00dd"+ - "\3\2\2\2\u0490\u0491\7r\2\2\u0491\u0492\7t\2\2\u0492\u0493\7k\2\2\u0493"+ - "\u0494\7x\2\2\u0494\u0495\7c\2\2\u0495\u0496\7v\2\2\u0496\u0497\7g\2\2"+ - "\u0497\u00df\3\2\2\2\u0498\u0499\7r\2\2\u0499\u049a\7t\2\2\u049a\u049b"+ - "\7q\2\2\u049b\u049c\7v\2\2\u049c\u049d\7g\2\2\u049d\u049e\7e\2\2\u049e"+ - "\u049f\7v\2\2\u049f\u04a0\7g\2\2\u04a0\u04a1\7f\2\2\u04a1\u00e1\3\2\2"+ - "\2\u04a2\u04a3\7k\2\2\u04a3\u04a4\7p\2\2\u04a4\u04a5\7v\2\2\u04a5\u04a6"+ - "\7g\2\2\u04a6\u04a7\7t\2\2\u04a7\u04a8\7p\2\2\u04a8\u04a9\7c\2\2\u04a9"+ - "\u04aa\7n\2\2\u04aa\u00e3\3\2\2\2\u04ab\u04ac\7g\2\2\u04ac\u04ad\7p\2"+ - "\2\u04ad\u04ae\7w\2\2\u04ae\u04af\7o\2\2\u04af\u00e5\3\2\2\2\u04b0\u04b1"+ - "\7u\2\2\u04b1\u04b2\7g\2\2\u04b2\u04b3\7c\2\2\u04b3\u04b4\7n\2\2\u04b4"+ - "\u04b5\7g\2\2\u04b5\u04b6\7f\2\2\u04b6\u00e7\3\2\2\2\u04b7\u04b8\7c\2"+ - "\2\u04b8\u04b9\7p\2\2\u04b9\u04ba\7p\2\2\u04ba\u04bb\7q\2\2\u04bb\u04bc"+ - "\7v\2\2\u04bc\u04bd\7c\2\2\u04bd\u04be\7v\2\2\u04be\u04bf\7k\2\2\u04bf"+ - "\u04c0\7q\2\2\u04c0\u04c1\7p\2\2\u04c1\u00e9\3\2\2\2\u04c2\u04c3\7f\2"+ - "\2\u04c3\u04c4\7c\2\2\u04c4\u04c5\7v\2\2\u04c5\u04c6\7c\2\2\u04c6\u00eb"+ - "\3\2\2\2\u04c7\u04c8\7k\2\2\u04c8\u04c9\7p\2\2\u04c9\u04ca\7p\2\2\u04ca"+ - "\u04cb\7g\2\2\u04cb\u04cc\7t\2\2\u04cc\u00ed\3\2\2\2\u04cd\u04ce\7v\2"+ - "\2\u04ce\u04cf\7c\2\2\u04cf\u04d0\7k\2\2\u04d0\u04d1\7n\2\2\u04d1\u04d2"+ - "\7t\2\2\u04d2\u04d3\7g\2\2\u04d3\u04d4\7e\2\2\u04d4\u00ef\3\2\2\2\u04d5"+ - "\u04d6\7q\2\2\u04d6\u04d7\7r\2\2\u04d7\u04d8\7g\2\2\u04d8\u04d9\7t\2\2"+ - "\u04d9\u04da\7c\2\2\u04da\u04db\7v\2\2\u04db\u04dc\7q\2\2\u04dc\u04dd"+ - "\7t\2\2\u04dd\u00f1\3\2\2\2\u04de\u04df\7k\2\2\u04df\u04e0\7p\2\2\u04e0"+ - "\u04e1\7n\2\2\u04e1\u04e2\7k\2\2\u04e2\u04e3\7p\2\2\u04e3\u04e4\7g\2\2"+ - "\u04e4\u00f3\3\2\2\2\u04e5\u04e6\7k\2\2\u04e6\u04e7\7p\2\2\u04e7\u04e8"+ - "\7h\2\2\u04e8\u04e9\7k\2\2\u04e9\u04ea\7z\2\2\u04ea\u00f5\3\2\2\2\u04eb"+ - "\u04ec\7g\2\2\u04ec\u04ed\7z\2\2\u04ed\u04ee\7v\2\2\u04ee\u04ef\7g\2\2"+ - "\u04ef\u04f0\7t\2\2\u04f0\u04f1\7p\2\2\u04f1\u04f2\7c\2\2\u04f2\u04f3"+ - "\7n\2\2\u04f3\u00f7\3\2\2\2\u04f4\u04f5\7u\2\2\u04f5\u04f6\7w\2\2\u04f6"+ - "\u04f7\7u\2\2\u04f7\u04f8\7r\2\2\u04f8\u04f9\7g\2\2\u04f9\u04fa\7p\2\2"+ - "\u04fa\u04fb\7f\2\2\u04fb\u00f9\3\2\2\2\u04fc\u04fd\7q\2\2\u04fd\u04fe"+ - "\7x\2\2\u04fe\u04ff\7g\2\2\u04ff\u0500\7t\2\2\u0500\u0501\7t\2\2\u0501"+ - "\u0502\7k\2\2\u0502\u0503\7f\2\2\u0503\u0504\7g\2\2\u0504\u00fb\3\2\2"+ - "\2\u0505\u0506\7c\2\2\u0506\u0507\7d\2\2\u0507\u0508\7u\2\2\u0508\u0509"+ - "\7v\2\2\u0509\u050a\7t\2\2\u050a\u050b\7c\2\2\u050b\u050c\7e\2\2\u050c"+ - "\u050d\7v\2\2\u050d\u00fd\3\2\2\2\u050e\u050f\7h\2\2\u050f\u0510\7k\2"+ - "\2\u0510\u0511\7p\2\2\u0511\u0512\7c\2\2\u0512\u0513\7n\2\2\u0513\u00ff"+ - "\3\2\2\2\u0514\u0515\7q\2\2\u0515\u0516\7r\2\2\u0516\u0517\7g\2\2\u0517"+ - "\u0518\7p\2\2\u0518\u0101\3\2\2\2\u0519\u051a\7e\2\2\u051a\u051b\7q\2"+ - "\2\u051b\u051c\7p\2\2\u051c\u051d\7u\2\2\u051d\u051e\7v\2\2\u051e\u0103"+ - "\3\2\2\2\u051f\u0520\7n\2\2\u0520\u0521\7c\2\2\u0521\u0522\7v\2\2\u0522"+ - "\u0523\7g\2\2\u0523\u0524\7k\2\2\u0524\u0525\7p\2\2\u0525\u0526\7k\2\2"+ - "\u0526\u0527\7v\2\2\u0527\u0105\3\2\2\2\u0528\u0529\7x\2\2\u0529\u052a"+ - "\7c\2\2\u052a\u052b\7t\2\2\u052b\u052c\7c\2\2\u052c\u052d\7t\2\2\u052d"+ - "\u052e\7i\2\2\u052e\u0107\3\2\2\2\u052f\u0530\7p\2\2\u0530\u0531\7q\2"+ - "\2\u0531\u0532\7k\2\2\u0532\u0533\7p\2\2\u0533\u0534\7n\2\2\u0534\u0535"+ - "\7k\2\2\u0535\u0536\7p\2\2\u0536\u0537\7g\2\2\u0537\u0109\3\2\2\2\u0538"+ - "\u0539\7e\2\2\u0539\u053a\7t\2\2\u053a\u053b\7q\2\2\u053b\u053c\7u\2\2"+ - "\u053c\u053d\7u\2\2\u053d\u053e\7k\2\2\u053e\u053f\7p\2\2\u053f\u0540"+ - "\7n\2\2\u0540\u0541\7k\2\2\u0541\u0542\7p\2\2\u0542\u0543\7g\2\2\u0543"+ - "\u010b\3\2\2\2\u0544\u0545\7t\2\2\u0545\u0546\7g\2\2\u0546\u0547\7k\2"+ - "\2\u0547\u0548\7h\2\2\u0548\u0549\7k\2\2\u0549\u054a\7g\2\2\u054a\u054b"+ - "\7f\2\2\u054b\u010d\3\2\2\2\u054c\u054d\7g\2\2\u054d\u054e\7z\2\2\u054e"+ - "\u054f\7r\2\2\u054f\u0550\7g\2\2\u0550\u0551\7e\2\2\u0551\u0552\7v\2\2"+ - "\u0552\u010f\3\2\2\2\u0553\u0554\7c\2\2\u0554\u0555\7e\2\2\u0555\u0556"+ - "\7v\2\2\u0556\u0557\7w\2\2\u0557\u0558\7c\2\2\u0558\u0559\7n\2\2\u0559"+ - "\u0111\3\2\2\2\u055a\u055b\7$\2\2\u055b\u055c\3\2\2\2\u055c\u055d\b\u0088"+ - "\6\2\u055d\u0113\3\2\2\2\u055e\u055f\7$\2\2\u055f\u0560\7$\2\2\u0560\u0561"+ - "\7$\2\2\u0561\u0562\3\2\2\2\u0562\u0563\b\u0089\7\2\u0563\u0115\3\2\2"+ - "\2\u0564\u0567\5\u0118\u008b\2\u0565\u0567\5\u0120\u008f\2\u0566\u0564"+ - "\3\2\2\2\u0566\u0565\3\2\2\2\u0567\u0117\3\2\2\2\u0568\u0569\5\u0120\u008f"+ - "\2\u0569\u056a\t\4\2\2\u056a\u056f\3\2\2\2\u056b\u056c\5\u011c\u008d\2"+ - "\u056c\u056d\t\4\2\2\u056d\u056f\3\2\2\2\u056e\u0568\3\2\2\2\u056e\u056b"+ - "\3\2\2\2\u056f\u0119\3\2\2\2\u0570\u0573\5\u0128\u0093\2\u0571\u0573\7"+ - "a\2\2\u0572\u0570\3\2\2\2\u0572\u0571\3\2\2\2\u0573\u011b\3\2\2\2\u0574"+ - "\u0578\5\u0128\u0093\2\u0575\u0577\5\u011a\u008c\2\u0576\u0575\3\2\2\2"+ - "\u0577\u057a\3\2\2\2\u0578\u0576\3\2\2\2\u0578\u0579\3\2\2\2\u0579\u057b"+ - "\3\2\2\2\u057a\u0578\3\2\2\2\u057b\u057c\5\u0128\u0093\2\u057c\u057f\3"+ - "\2\2\2\u057d\u057f\5\u0128\u0093\2\u057e\u0574\3\2\2\2\u057e\u057d\3\2"+ - "\2\2\u057f\u011d\3\2\2\2\u0580\u0582\t\5\2\2\u0581\u0583\t\6\2\2\u0582"+ - "\u0581\3\2\2\2\u0582\u0583\3\2\2\2\u0583\u0584\3\2\2\2\u0584\u0585\5\u011c"+ - "\u008d\2\u0585\u011f\3\2\2\2\u0586\u0588\5\u011c\u008d\2\u0587\u0586\3"+ - "\2\2\2\u0587\u0588\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058a\7\60\2\2\u058a"+ - "\u058c\5\u011c\u008d\2\u058b\u058d\5\u011e\u008e\2\u058c\u058b\3\2\2\2"+ - "\u058c\u058d\3\2\2\2\u058d\u0592\3\2\2\2\u058e\u058f\5\u011c\u008d\2\u058f"+ - "\u0590\5\u011e\u008e\2\u0590\u0592\3\2\2\2\u0591\u0587\3\2\2\2\u0591\u058e"+ - "\3\2\2\2\u0592\u0121\3\2\2\2\u0593\u0597\5\u0124\u0091\2\u0594\u0597\5"+ - "\u012e\u0096\2\u0595\u0597\5\u0134\u0099\2\u0596\u0593\3\2\2\2\u0596\u0594"+ - "\3\2\2\2\u0596\u0595\3\2\2\2\u0597\u0598\3\2\2\2\u0598\u0599\7N\2\2\u0599"+ - "\u0123\3\2\2\2\u059a\u059e\5\u012a\u0094\2\u059b\u059d\5\u011a\u008c\2"+ - "\u059c\u059b\3\2\2\2\u059d\u05a0\3\2\2\2\u059e\u059c\3\2\2\2\u059e\u059f"+ - "\3\2\2\2\u059f\u05a1\3\2\2\2\u05a0\u059e\3\2\2\2\u05a1\u05a2\5\u0128\u0093"+ - "\2\u05a2\u05a5\3\2\2\2\u05a3\u05a5\5\u0128\u0093\2\u05a4\u059a\3\2\2\2"+ - "\u05a4\u05a3\3\2\2\2\u05a5\u0125\3\2\2\2\u05a6\u05a7\5\u015a\u00ac\2\u05a7"+ - "\u0127\3\2\2\2\u05a8\u05a9\4\62;\2\u05a9\u0129\3\2\2\2\u05aa\u05ab\4\63"+ - ";\2\u05ab\u012b\3\2\2\2\u05ac\u05af\5\u0130\u0097\2\u05ad\u05af\7a\2\2"+ - "\u05ae\u05ac\3\2\2\2\u05ae\u05ad\3\2\2\2\u05af\u012d\3\2\2\2\u05b0\u05b1"+ - "\7\62\2\2\u05b1\u05b2\t\7\2\2\u05b2\u05b6\5\u0130\u0097\2\u05b3\u05b5"+ - "\5\u012c\u0095\2\u05b4\u05b3\3\2\2\2\u05b5\u05b8\3\2\2\2\u05b6\u05b4\3"+ - "\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05b9\3\2\2\2\u05b8\u05b6\3\2\2\2\u05b9"+ - "\u05ba\5\u0130\u0097\2\u05ba\u05bf\3\2\2\2\u05bb\u05bc\7\62\2\2\u05bc"+ - "\u05bd\t\7\2\2\u05bd\u05bf\5\u0130\u0097\2\u05be\u05b0\3\2\2\2\u05be\u05bb"+ - "\3\2\2\2\u05bf\u012f\3\2\2\2\u05c0\u05c1\t\b\2\2\u05c1\u0131\3\2\2\2\u05c2"+ - "\u05c5\5\u0136\u009a\2\u05c3\u05c5\7a\2\2\u05c4\u05c2\3\2\2\2\u05c4\u05c3"+ - "\3\2\2\2\u05c5\u0133\3\2\2\2\u05c6\u05c7\7\62\2\2\u05c7\u05c8\t\t\2\2"+ - "\u05c8\u05cc\5\u0136\u009a\2\u05c9\u05cb\5\u0132\u0098\2\u05ca\u05c9\3"+ - "\2\2\2\u05cb\u05ce\3\2\2\2\u05cc\u05ca\3\2\2\2\u05cc\u05cd\3\2\2\2\u05cd"+ - "\u05cf\3\2\2\2\u05ce\u05cc\3\2\2\2\u05cf\u05d0\5\u0136\u009a\2\u05d0\u05d5"+ - "\3\2\2\2\u05d1\u05d2\7\62\2\2\u05d2\u05d3\t\t\2\2\u05d3\u05d5\5\u0136"+ - "\u009a\2\u05d4\u05c6\3\2\2\2\u05d4\u05d1\3\2\2\2\u05d5\u0135\3\2\2\2\u05d6"+ - "\u05d7\t\n\2\2\u05d7\u0137\3\2\2\2\u05d8\u05d9\7v\2\2\u05d9\u05da\7t\2"+ - "\2\u05da\u05db\7w\2\2\u05db\u05e2\7g\2\2\u05dc\u05dd\7h\2\2\u05dd\u05de"+ - "\7c\2\2\u05de\u05df\7n\2\2\u05df\u05e0\7u\2\2\u05e0\u05e2\7g\2\2\u05e1"+ - "\u05d8\3\2\2\2\u05e1\u05dc\3\2\2\2\u05e2\u0139\3\2\2\2\u05e3\u05e4\7p"+ - "\2\2\u05e4\u05e5\7w\2\2\u05e5\u05e6\7n\2\2\u05e6\u05e7\7n\2\2\u05e7\u013b"+ - "\3\2\2\2\u05e8\u05eb\5\u014c\u00a5\2\u05e9\u05eb\7a\2\2\u05ea\u05e8\3"+ - "\2\2\2\u05ea\u05e9\3\2\2\2\u05eb\u05f1\3\2\2\2\u05ec\u05f0\5\u014c\u00a5"+ - "\2\u05ed\u05f0\7a\2\2\u05ee\u05f0\5\u0126\u0092\2\u05ef\u05ec\3\2\2\2"+ - "\u05ef\u05ed\3\2\2\2\u05ef\u05ee\3\2\2\2\u05f0\u05f3\3\2\2\2\u05f1\u05ef"+ - "\3\2\2\2\u05f1\u05f2\3\2\2\2\u05f2\u05fc\3\2\2\2\u05f3\u05f1\3\2\2\2\u05f4"+ - "\u05f6\7b\2\2\u05f5\u05f7\n\13\2\2\u05f6\u05f5\3\2\2\2\u05f7\u05f8\3\2"+ - "\2\2\u05f8\u05f6\3\2\2\2\u05f8\u05f9\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa"+ - "\u05fc\7b\2\2\u05fb\u05ea\3\2\2\2\u05fb\u05f4\3\2\2\2\u05fc\u013d\3\2"+ - "\2\2\u05fd\u0626\5\u013c\u009d\2\u05fe\u0626\5\u00fc}\2\u05ff\u0626\5"+ - "\u00e8s\2\u0600\u0626\5\u0090G\2\u0601\u0626\5\u00a6R\2\u0602\u0626\5"+ - "\u0092H\2\u0603\u0626\5\u008eF\2\u0604\u0626\5\u010a\u0084\2\u0605\u0626"+ - "\5\u00eat\2\u0606\u0626\5\u00c8c\2\u0607\u0626\5\u00e4q\2\u0608\u0626"+ - "\5\u00f6z\2\u0609\u0626\5\u00fe~\2\u060a\u0626\5\u00a8S\2\u060b\u0626"+ - "\5\u00c4a\2\u060c\u0626\5~>\2\u060d\u0626\5\u00f4y\2\u060e\u0626\5\u0094"+ - "I\2\u060f\u0626\5\u00f2x\2\u0610\u0626\5\u00ecu\2\u0611\u0626\5\u00e2"+ - "p\2\u0612\u0626\5\u0104\u0081\2\u0613\u0626\5\u0108\u0083\2\u0614\u0626"+ - "\5\u0100\177\2\u0615\u0626\5\u00f0w\2\u0616\u0626\5\u00c2`\2\u0617\u0626"+ - "\5\u00fa|\2\u0618\u0626\5\u00den\2\u0619\u0626\5\u00e0o\2\u061a\u0626"+ - "\5\u00dcm\2\u061b\u0626\5\u010c\u0085\2\u061c\u0626\5\u00e6r\2\u061d\u0626"+ - "\5\u00eev\2\u061e\u0626\5\u00c6b\2\u061f\u0626\5\u0106\u0082\2\u0620\u0626"+ - "\5\u009cM\2\u0621\u0626\5\u010e\u0086\2\u0622\u0626\5\u0110\u0087\2\u0623"+ - "\u0626\5\u0102\u0080\2\u0624\u0626\5\u00f8{\2\u0625\u05fd\3\2\2\2\u0625"+ - "\u05fe\3\2\2\2\u0625\u05ff\3\2\2\2\u0625\u0600\3\2\2\2\u0625\u0601\3\2"+ - "\2\2\u0625\u0602\3\2\2\2\u0625\u0603\3\2\2\2\u0625\u0604\3\2\2\2\u0625"+ - "\u0605\3\2\2\2\u0625\u0606\3\2\2\2\u0625\u0607\3\2\2\2\u0625\u0608\3\2"+ - "\2\2\u0625\u0609\3\2\2\2\u0625\u060a\3\2\2\2\u0625\u060b\3\2\2\2\u0625"+ - "\u060c\3\2\2\2\u0625\u060d\3\2\2\2\u0625\u060e\3\2\2\2\u0625\u060f\3\2"+ - "\2\2\u0625\u0610\3\2\2\2\u0625\u0611\3\2\2\2\u0625\u0612\3\2\2\2\u0625"+ - "\u0613\3\2\2\2\u0625\u0614\3\2\2\2\u0625\u0615\3\2\2\2\u0625\u0616\3\2"+ - "\2\2\u0625\u0617\3\2\2\2\u0625\u0618\3\2\2\2\u0625\u0619\3\2\2\2\u0625"+ - "\u061a\3\2\2\2\u0625\u061b\3\2\2\2\u0625\u061c\3\2\2\2\u0625\u061d\3\2"+ - "\2\2\u0625\u061e\3\2\2\2\u0625\u061f\3\2\2\2\u0625\u0620\3\2\2\2\u0625"+ - "\u0621\3\2\2\2\u0625\u0622\3\2\2\2\u0625\u0623\3\2\2\2\u0625\u0624\3\2"+ - "\2\2\u0626\u013f\3\2\2\2\u0627\u0628\5\u013e\u009e\2\u0628\u0629\7B\2"+ - "\2\u0629\u0141\3\2\2\2\u062a\u062b\7&\2\2\u062b\u062c\5\u013e\u009e\2"+ - "\u062c\u0143\3\2\2\2\u062d\u0630\7)\2\2\u062e\u0631\5\u0146\u00a2\2\u062f"+ - "\u0631\n\f\2\2\u0630\u062e\3\2\2\2\u0630\u062f\3\2\2\2\u0631\u0632\3\2"+ - "\2\2\u0632\u0633\7)\2\2\u0633\u0145\3\2\2\2\u0634\u0637\5\u0148\u00a3"+ - "\2\u0635\u0637\5\u014a\u00a4\2\u0636\u0634\3\2\2\2\u0636\u0635\3\2\2\2"+ - "\u0637\u0147\3\2\2\2\u0638\u0639\7^\2\2\u0639\u063a\7w\2\2\u063a\u063b"+ - "\5\u0130\u0097\2\u063b\u063c\5\u0130\u0097\2\u063c\u063d\5\u0130\u0097"+ - "\2\u063d\u063e\5\u0130\u0097\2\u063e\u0149\3\2\2\2\u063f\u0640\7^\2\2"+ - "\u0640\u0641\t\r\2\2\u0641\u014b\3\2\2\2\u0642\u0649\5\u0150\u00a7\2\u0643"+ - "\u0649\5\u0152\u00a8\2\u0644\u0649\5\u0154\u00a9\2\u0645\u0649\5\u0156"+ - "\u00aa\2\u0646\u0649\5\u0158\u00ab\2\u0647\u0649\5\u015c\u00ad\2\u0648"+ - "\u0642\3\2\2\2\u0648\u0643\3\2\2\2\u0648\u0644\3\2\2\2\u0648\u0645\3\2"+ - "\2\2\u0648\u0646\3\2\2\2\u0648\u0647\3\2\2\2\u0649\u014d\3\2\2\2\u064a"+ - "\u064b\13\2\2\2\u064b\u014f\3\2\2\2\u064c\u064d\t\16\2\2\u064d\u0151\3"+ - "\2\2\2\u064e\u064f\t\17\2\2\u064f\u0153\3\2\2\2\u0650\u0651\t\20\2\2\u0651"+ - "\u0155\3\2\2\2\u0652\u0653\t\21\2\2\u0653\u0157\3\2\2\2\u0654\u0655\t"+ - "\22\2\2\u0655\u0159\3\2\2\2\u0656\u0657\t\23\2\2\u0657\u015b\3\2\2\2\u0658"+ - "\u0659\t\24\2\2\u0659\u015d\3\2\2\2\u065a\u065b\5\32\f\2\u065b\u065c\3"+ - "\2\2\2\u065c\u065d\b\u00ae\4\2\u065d\u065e\b\u00ae\b\2\u065e\u015f\3\2"+ - "\2\2\u065f\u0660\5\36\16\2\u0660\u0661\3\2\2\2\u0661\u0662\b\u00af\4\2"+ - "\u0662\u0663\b\u00af\t\2\u0663\u0161\3\2\2\2\u0664\u0665\5\30\13\2\u0665"+ - "\u0666\3\2\2\2\u0666\u0667\b\u00b0\3\2\u0667\u0668\b\u00b0\n\2\u0668\u0163"+ - "\3\2\2\2\u0669\u066a\5\34\r\2\u066a\u066b\3\2\2\2\u066b\u066c\b\u00b1"+ - "\3\2\u066c\u066d\b\u00b1\13\2\u066d\u0165\3\2\2\2\u066e\u066f\5 \17\2"+ - "\u066f\u0670\3\2\2\2\u0670\u0671\b\u00b2\5\2\u0671\u0672\b\u00b2\f\2\u0672"+ - "\u0167\3\2\2\2\u0673\u0674\5\"\20\2\u0674\u0675\3\2\2\2\u0675\u0676\b"+ - "\u00b3\4\2\u0676\u0677\b\u00b3\r\2\u0677\u0169\3\2\2\2\u0678\u0679\5\24"+ - "\t\2\u0679\u067a\3\2\2\2\u067a\u067b\b\u00b4\16\2\u067b\u016b\3\2\2\2"+ - "\u067c\u067d\5\26\n\2\u067d\u067e\3\2\2\2\u067e\u067f\b\u00b5\17\2\u067f"+ - "\u016d\3\2\2\2\u0680\u0681\5$\21\2\u0681\u0682\3\2\2\2\u0682\u0683\b\u00b6"+ - "\20\2\u0683\u016f\3\2\2\2\u0684\u0685\5&\22\2\u0685\u0686\3\2\2\2\u0686"+ - "\u0687\b\u00b7\21\2\u0687\u0171\3\2\2\2\u0688\u0689\5(\23\2\u0689\u068a"+ - "\3\2\2\2\u068a\u068b\b\u00b8\22\2\u068b\u0173\3\2\2\2\u068c\u068d\5*\24"+ - "\2\u068d\u068e\3\2\2\2\u068e\u068f\b\u00b9\23\2\u068f\u0175\3\2\2\2\u0690"+ - "\u0691\5,\25\2\u0691\u0692\3\2\2\2\u0692\u0693\b\u00ba\24\2\u0693\u0177"+ - "\3\2\2\2\u0694\u0695\5.\26\2\u0695\u0696\3\2\2\2\u0696\u0697\b\u00bb\25"+ - "\2\u0697\u0179\3\2\2\2\u0698\u0699\5\60\27\2\u0699\u069a\3\2\2\2\u069a"+ - "\u069b\b\u00bc\26\2\u069b\u017b\3\2\2\2\u069c\u069d\5\62\30\2\u069d\u069e"+ - "\3\2\2\2\u069e\u069f\b\u00bd\27\2\u069f\u017d\3\2\2\2\u06a0\u06a1\5\64"+ - "\31\2\u06a1\u06a2\3\2\2\2\u06a2\u06a3\b\u00be\30\2\u06a3\u017f\3\2\2\2"+ - "\u06a4\u06a7\7#\2\2\u06a5\u06a8\5\20\7\2\u06a6\u06a8\5\16\6\2\u06a7\u06a5"+ - "\3\2\2\2\u06a7\u06a6\3\2\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06aa\b\u00bf\31"+ - "\2\u06aa\u0181\3\2\2\2\u06ab\u06ac\58\33\2\u06ac\u06ad\3\2\2\2\u06ad\u06ae"+ - "\b\u00c0\32\2\u06ae\u0183\3\2\2\2\u06af\u06b0\5:\34\2\u06b0\u06b1\3\2"+ - "\2\2\u06b1\u06b2\b\u00c1\33\2\u06b2\u0185\3\2\2\2\u06b3\u06b4\5<\35\2"+ - "\u06b4\u06b5\3\2\2\2\u06b5\u06b6\b\u00c2\34\2\u06b6\u0187\3\2\2\2\u06b7"+ - "\u06b8\5>\36\2\u06b8\u06b9\3\2\2\2\u06b9\u06ba\b\u00c3\35\2\u06ba\u0189"+ - "\3\2\2\2\u06bb\u06bc\5@\37\2\u06bc\u06bd\3\2\2\2\u06bd\u06be\b\u00c4\36"+ - "\2\u06be\u018b\3\2\2\2\u06bf\u06c0\5B \2\u06c0\u06c1\3\2\2\2\u06c1\u06c2"+ - "\b\u00c5\37\2\u06c2\u018d\3\2\2\2\u06c3\u06c4\5D!\2\u06c4\u06c5\3\2\2"+ - "\2\u06c5\u06c6\b\u00c6 \2\u06c6\u018f\3\2\2\2\u06c7\u06c8\5F\"\2\u06c8"+ - "\u06c9\3\2\2\2\u06c9\u06ca\b\u00c7!\2\u06ca\u0191\3\2\2\2\u06cb\u06cc"+ - "\5H#\2\u06cc\u06cd\3\2\2\2\u06cd\u06ce\b\u00c8\"\2\u06ce\u0193\3\2\2\2"+ - "\u06cf\u06d0\5J$\2\u06d0\u06d1\3\2\2\2\u06d1\u06d2\b\u00c9#\2\u06d2\u0195"+ - "\3\2\2\2\u06d3\u06d4\5L%\2\u06d4\u06d5\3\2\2\2\u06d5\u06d6\b\u00ca$\2"+ - "\u06d6\u0197\3\2\2\2\u06d7\u06d8\5N&\2\u06d8\u06d9\3\2\2\2\u06d9\u06da"+ - "\b\u00cb%\2\u06da\u0199\3\2\2\2\u06db\u06dc\5\22\b\2\u06dc\u06dd\3\2\2"+ - "\2\u06dd\u06de\b\u00cc&\2\u06de\u019b\3\2\2\2\u06df\u06e0\5P\'\2\u06e0"+ - "\u06e1\3\2\2\2\u06e1\u06e2\b\u00cd\'\2\u06e2\u019d\3\2\2\2\u06e3\u06e4"+ - "\5R(\2\u06e4\u06e5\3\2\2\2\u06e5\u06e6\b\u00ce(\2\u06e6\u019f\3\2\2\2"+ - "\u06e7\u06e8\5T)\2\u06e8\u06e9\3\2\2\2\u06e9\u06ea\b\u00cf)\2\u06ea\u01a1"+ - "\3\2\2\2\u06eb\u06ec\5V*\2\u06ec\u06ed\3\2\2\2\u06ed\u06ee\b\u00d0*\2"+ - "\u06ee\u01a3\3\2\2\2\u06ef\u06f2\7A\2\2\u06f0\u06f3\5\20\7\2\u06f1\u06f3"+ - "\5\16\6\2\u06f2\u06f0\3\2\2\2\u06f2\u06f1\3\2\2\2\u06f3\u06f4\3\2\2\2"+ - "\u06f4\u06f5\b\u00d1+\2\u06f5\u01a5\3\2\2\2\u06f6\u06f7\5\\-\2\u06f7\u06f8"+ - "\3\2\2\2\u06f8\u06f9\b\u00d2,\2\u06f9\u01a7\3\2\2\2\u06fa\u06fb\5^.\2"+ - "\u06fb\u06fc\3\2\2\2\u06fc\u06fd\b\u00d3-\2\u06fd\u01a9\3\2\2\2\u06fe"+ - "\u06ff\5`/\2\u06ff\u0700\3\2\2\2\u0700\u0701\b\u00d4.\2\u0701\u01ab\3"+ - "\2\2\2\u0702\u0703\5b\60\2\u0703\u0704\3\2\2\2\u0704\u0705\b\u00d5/\2"+ - "\u0705\u01ad\3\2\2\2\u0706\u0707\5d\61\2\u0707\u0708\3\2\2\2\u0708\u0709"+ - "\b\u00d6\60\2\u0709\u01af\3\2\2\2\u070a\u070b\5f\62\2\u070b\u070c\3\2"+ - "\2\2\u070c\u070d\b\u00d7\61\2\u070d\u01b1\3\2\2\2\u070e\u070f\5h\63\2"+ - "\u070f\u0710\3\2\2\2\u0710\u0711\b\u00d8\62\2\u0711\u01b3\3\2\2\2\u0712"+ - "\u0713\5\u00ba\\\2\u0713\u0714\3\2\2\2\u0714\u0715\b\u00d9\63\2\u0715"+ - "\u01b5\3\2\2\2\u0716\u0717\5\u00be^\2\u0717\u0718\3\2\2\2\u0718\u0719"+ - "\b\u00da\64\2\u0719\u01b7\3\2\2\2\u071a\u071b\5\u00c0_\2\u071b\u071c\3"+ - "\2\2\2\u071c\u071d\b\u00db\65\2\u071d\u01b9\3\2\2\2\u071e\u071f\5\u00b8"+ - "[\2\u071f\u0720\3\2\2\2\u0720\u0721\b\u00dc\66\2\u0721\u01bb\3\2\2\2\u0722"+ - "\u0723\5j\64\2\u0723\u0724\3\2\2\2\u0724\u0725\b\u00dd\67\2\u0725\u01bd"+ - "\3\2\2\2\u0726\u0727\5l\65\2\u0727\u0728\3\2\2\2\u0728\u0729\b\u00de8"+ - "\2\u0729\u01bf\3\2\2\2\u072a\u072b\5n\66\2\u072b\u072c\3\2\2\2\u072c\u072d"+ - "\b\u00df9\2\u072d\u01c1\3\2\2\2\u072e\u072f\5p\67\2\u072f\u0730\3\2\2"+ - "\2\u0730\u0731\b\u00e0:\2\u0731\u01c3\3\2\2\2\u0732\u0733\5\u0112\u0088"+ - "\2\u0733\u0734\3\2\2\2\u0734\u0735\b\u00e1\6\2\u0735\u0736\b\u00e1;\2"+ - "\u0736\u01c5\3\2\2\2\u0737\u0738\5\u0114\u0089\2\u0738\u0739\3\2\2\2\u0739"+ - "\u073a\b\u00e2\7\2\u073a\u073b\b\u00e2<\2\u073b\u01c7\3\2\2\2\u073c\u073d"+ - "\5\u0088C\2\u073d\u073e\3\2\2\2\u073e\u073f\b\u00e3=\2\u073f\u01c9\3\2"+ - "\2\2\u0740\u0741\5\u008aD\2\u0741\u0742\3\2\2\2\u0742\u0743\b\u00e4>\2"+ - "\u0743\u01cb\3\2\2\2\u0744\u0745\5\u0084A\2\u0745\u0746\3\2\2\2\u0746"+ - "\u0747\b\u00e5?\2\u0747\u01cd\3\2\2\2\u0748\u0749\5\u0086B\2\u0749\u074a"+ - "\3\2\2\2\u074a\u074b\b\u00e6@\2\u074b\u01cf\3\2\2\2\u074c\u074d\5\u0098"+ - "K\2\u074d\u074e\3\2\2\2\u074e\u074f\b\u00e7A\2\u074f\u01d1\3\2\2\2\u0750"+ - "\u0751\5\u00bc]\2\u0751\u0752\3\2\2\2\u0752\u0753\b\u00e8B\2\u0753\u01d3"+ - "\3\2\2\2\u0754\u0755\5\u00c2`\2\u0755\u0756\3\2\2\2\u0756\u0757\b\u00e9"+ - "C\2\u0757\u01d5\3\2\2\2\u0758\u0759\5\u00cce\2\u0759\u075a\3\2\2\2\u075a"+ - "\u075b\b\u00eaD\2\u075b\u01d7\3\2\2\2\u075c\u075d\5\u00cad\2\u075d\u075e"+ - "\3\2\2\2\u075e\u075f\b\u00ebE\2\u075f\u01d9\3\2\2\2\u0760\u0761\5\u00ce"+ - "f\2\u0761\u0762\3\2\2\2\u0762\u0763\b\u00ecF\2\u0763\u01db\3\2\2\2\u0764"+ - "\u0765\5\u00d0g\2\u0765\u0766\3\2\2\2\u0766\u0767\b\u00edG\2\u0767\u01dd"+ - "\3\2\2\2\u0768\u0769\5\u00d2h\2\u0769\u076a\3\2\2\2\u076a\u076b\b\u00ee"+ - "H\2\u076b\u01df\3\2\2\2\u076c\u076d\5\u00d4i\2\u076d\u076e\3\2\2\2\u076e"+ - "\u076f\b\u00efI\2\u076f\u01e1\3\2\2\2\u0770\u0771\5\u00d6j\2\u0771\u0772"+ - "\3\2\2\2\u0772\u0773\b\u00f0J\2\u0773\u01e3\3\2\2\2\u0774\u0775\5\u00d8"+ - "k\2\u0775\u0776\3\2\2\2\u0776\u0777\b\u00f1K\2\u0777\u01e5\3\2\2\2\u0778"+ - "\u0779\5\u00dal\2\u0779\u077a\3\2\2\2\u077a\u077b\b\u00f2L\2\u077b\u01e7"+ - "\3\2\2\2\u077c\u077d\5\u00b0W\2\u077d\u077e\3\2\2\2\u077e\u077f\b\u00f3"+ - "M\2\u077f\u01e9\3\2\2\2\u0780\u0781\5\u00b2X\2\u0781\u0782\3\2\2\2\u0782"+ - "\u0783\b\u00f4N\2\u0783\u01eb\3\2\2\2\u0784\u0785\5\u00b4Y\2\u0785\u0786"+ - "\3\2\2\2\u0786\u0787\b\u00f5O\2\u0787\u01ed\3\2\2\2\u0788\u0789\5\u00b6"+ - "Z\2\u0789\u078a\3\2\2\2\u078a\u078b\b\u00f6P\2\u078b\u01ef\3\2\2\2\u078c"+ - "\u078d\5r8\2\u078d\u078e\3\2\2\2\u078e\u078f\b\u00f7Q\2\u078f\u01f1\3"+ - "\2\2\2\u0790\u0791\5t9\2\u0791\u0792\3\2\2\2\u0792\u0793\b\u00f8R\2\u0793"+ - "\u01f3\3\2\2\2\u0794\u0795\5v:\2\u0795\u0796\3\2\2\2\u0796\u0797\b\u00f9"+ - "S\2\u0797\u01f5\3\2\2\2\u0798\u0799\5\u009eN\2\u0799\u079a\3\2\2\2\u079a"+ - "\u079b\b\u00faT\2\u079b\u01f7\3\2\2\2\u079c\u079d\5\u00a0O\2\u079d\u079e"+ - "\3\2\2\2\u079e\u079f\b\u00fbU\2\u079f\u01f9\3\2\2\2\u07a0\u07a1\5\u00a2"+ - "P\2\u07a1\u07a2\3\2\2\2\u07a2\u07a3\b\u00fcV\2\u07a3\u01fb\3\2\2\2\u07a4"+ - "\u07a5\5\u00a4Q\2\u07a5\u07a6\3\2\2\2\u07a6\u07a7\b\u00fdW\2\u07a7\u01fd"+ - "\3\2\2\2\u07a8\u07a9\5\u00a6R\2\u07a9\u07aa\3\2\2\2\u07aa\u07ab\b\u00fe"+ - "X\2\u07ab\u01ff\3\2\2\2\u07ac\u07ad\5\u00a8S\2\u07ad\u07ae\3\2\2\2\u07ae"+ - "\u07af\b\u00ffY\2\u07af\u0201\3\2\2\2\u07b0\u07b1\5\u00aaT\2\u07b1\u07b2"+ - "\3\2\2\2\u07b2\u07b3\b\u0100Z\2\u07b3\u0203\3\2\2\2\u07b4\u07b5\5\u00ac"+ - "U\2\u07b5\u07b6\3\2\2\2\u07b6\u07b7\b\u0101[\2\u07b7\u0205\3\2\2\2\u07b8"+ - "\u07b9\5\u00aeV\2\u07b9\u07ba\3\2\2\2\u07ba\u07bb\b\u0102\\\2\u07bb\u0207"+ - "\3\2\2\2\u07bc\u07bd\5\u00dcm\2\u07bd\u07be\3\2\2\2\u07be\u07bf\b\u0103"+ - "]\2\u07bf\u0209\3\2\2\2\u07c0\u07c1\5\u00den\2\u07c1\u07c2\3\2\2\2\u07c2"+ - "\u07c3\b\u0104^\2\u07c3\u020b\3\2\2\2\u07c4\u07c5\5\u00e0o\2\u07c5\u07c6"+ - "\3\2\2\2\u07c6\u07c7\b\u0105_\2\u07c7\u020d\3\2\2\2\u07c8\u07c9\5\u00e2"+ - "p\2\u07c9\u07ca\3\2\2\2\u07ca\u07cb\b\u0106`\2\u07cb\u020f\3\2\2\2\u07cc"+ - "\u07cd\5\u00e4q\2\u07cd\u07ce\3\2\2\2\u07ce\u07cf\b\u0107a\2\u07cf\u0211"+ - "\3\2\2\2\u07d0\u07d1\5\u00e6r\2\u07d1\u07d2\3\2\2\2\u07d2\u07d3\b\u0108"+ - "b\2\u07d3\u0213\3\2\2\2\u07d4\u07d5\5\u00e8s\2\u07d5\u07d6\3\2\2\2\u07d6"+ - "\u07d7\b\u0109c\2\u07d7\u0215\3\2\2\2\u07d8\u07d9\5\u00eat\2\u07d9\u07da"+ - "\3\2\2\2\u07da\u07db\b\u010ad\2\u07db\u0217\3\2\2\2\u07dc\u07dd\5\u00ec"+ - "u\2\u07dd\u07de\3\2\2\2\u07de\u07df\b\u010be\2\u07df\u0219\3\2\2\2\u07e0"+ - "\u07e1\5\u00eev\2\u07e1\u07e2\3\2\2\2\u07e2\u07e3\b\u010cf\2\u07e3\u021b"+ - "\3\2\2\2\u07e4\u07e5\5\u00f0w\2\u07e5\u07e6\3\2\2\2\u07e6\u07e7\b\u010d"+ - "g\2\u07e7\u021d\3\2\2\2\u07e8\u07e9\5\u00f2x\2\u07e9\u07ea\3\2\2\2\u07ea"+ - "\u07eb\b\u010eh\2\u07eb\u021f\3\2\2\2\u07ec\u07ed\5\u00f4y\2\u07ed\u07ee"+ - "\3\2\2\2\u07ee\u07ef\b\u010fi\2\u07ef\u0221\3\2\2\2\u07f0\u07f1\5\u00f6"+ - "z\2\u07f1\u07f2\3\2\2\2\u07f2\u07f3\b\u0110j\2\u07f3\u0223\3\2\2\2\u07f4"+ - "\u07f5\5\u00f8{\2\u07f5\u07f6\3\2\2\2\u07f6\u07f7\b\u0111k\2\u07f7\u0225"+ - "\3\2\2\2\u07f8\u07f9\5\u00fa|\2\u07f9\u07fa\3\2\2\2\u07fa\u07fb\b\u0112"+ - "l\2\u07fb\u0227\3\2\2\2\u07fc\u07fd\5\u00fc}\2\u07fd\u07fe\3\2\2\2\u07fe"+ - "\u07ff\b\u0113m\2\u07ff\u0229\3\2\2\2\u0800\u0801\5\u00fe~\2\u0801\u0802"+ - "\3\2\2\2\u0802\u0803\b\u0114n\2\u0803\u022b\3\2\2\2\u0804\u0805\5\u0100"+ - "\177\2\u0805\u0806\3\2\2\2\u0806\u0807\b\u0115o\2\u0807\u022d\3\2\2\2"+ - "\u0808\u0809\5\u0102\u0080\2\u0809\u080a\3\2\2\2\u080a\u080b\b\u0116p"+ - "\2\u080b\u022f\3\2\2\2\u080c\u080d\5\u0104\u0081\2\u080d\u080e\3\2\2\2"+ - "\u080e\u080f\b\u0117q\2\u080f\u0231\3\2\2\2\u0810\u0811\5\u0106\u0082"+ - "\2\u0811\u0812\3\2\2\2\u0812\u0813\b\u0118r\2\u0813\u0233\3\2\2\2\u0814"+ - "\u0815\5\u0108\u0083\2\u0815\u0816\3\2\2\2\u0816\u0817\b\u0119s\2\u0817"+ - "\u0235\3\2\2\2\u0818\u0819\5\u010a\u0084\2\u0819\u081a\3\2\2\2\u081a\u081b"+ - "\b\u011at\2\u081b\u0237\3\2\2\2\u081c\u081d\5\u010c\u0085\2\u081d\u081e"+ - "\3\2\2\2\u081e\u081f\b\u011bu\2\u081f\u0239\3\2\2\2\u0820\u0821\5\u010e"+ - "\u0086\2\u0821\u0822\3\2\2\2\u0822\u0823\b\u011cv\2\u0823\u023b\3\2\2"+ - "\2\u0824\u0825\5\u0110\u0087\2\u0825\u0826\3\2\2\2\u0826\u0827\b\u011d"+ - "w\2\u0827\u023d\3\2\2\2\u0828\u0829\5\u0138\u009b\2\u0829\u082a\3\2\2"+ - "\2\u082a\u082b\b\u011ex\2\u082b\u023f\3\2\2\2\u082c\u082d\5\u0124\u0091"+ - "\2\u082d\u082e\3\2\2\2\u082e\u082f\b\u011fy\2\u082f\u0241\3\2\2\2\u0830"+ - "\u0831\5\u012e\u0096\2\u0831\u0832\3\2\2\2\u0832\u0833\b\u0120z\2\u0833"+ - "\u0243\3\2\2\2\u0834\u0835\5\u0134\u0099\2\u0835\u0836\3\2\2\2\u0836\u0837"+ - "\b\u0121{\2\u0837\u0245\3\2\2\2\u0838\u0839\5\u0144\u00a1\2\u0839\u083a"+ - "\3\2\2\2\u083a\u083b\b\u0122|\2\u083b\u0247\3\2\2\2\u083c\u083d\5\u0116"+ - "\u008a\2\u083d\u083e\3\2\2\2\u083e\u083f\b\u0123}\2\u083f\u0249\3\2\2"+ - "\2\u0840\u0841\5\u013a\u009c\2\u0841\u0842\3\2\2\2\u0842\u0843\b\u0124"+ - "~\2\u0843\u024b\3\2\2\2\u0844\u0845\5\u0122\u0090\2\u0845\u0846\3\2\2"+ - "\2\u0846\u0847\b\u0125\177\2\u0847\u024d\3\2\2\2\u0848\u0849\5\u013c\u009d"+ - "\2\u0849\u084a\3\2\2\2\u084a\u084b\b\u0126\u0080\2\u084b\u024f\3\2\2\2"+ - "\u084c\u084d\5\u0140\u009f\2\u084d\u084e\3\2\2\2\u084e\u084f\b\u0127\u0081"+ - "\2\u084f\u0251\3\2\2\2\u0850\u0853\5\n\4\2\u0851\u0853\5\b\3\2\u0852\u0850"+ - "\3\2\2\2\u0852\u0851\3\2\2\2\u0853\u0854\3\2\2\2\u0854\u0855\b\u0128\2"+ - "\2\u0855\u0253\3\2\2\2\u0856\u0857\5\f\5\2\u0857\u0858\3\2\2\2\u0858\u0859"+ - "\b\u0129\2\2\u0859\u0255\3\2\2\2\u085a\u085b\5\16\6\2\u085b\u085c\3\2"+ - "\2\2\u085c\u085d\b\u012a\2\2\u085d\u0257\3\2\2\2\u085e\u085f\7$\2\2\u085f"+ - "\u0860\3\2\2\2\u0860\u0861\b\u012b\4\2\u0861\u0259\3\2\2\2\u0862\u0863"+ - "\5\u0142\u00a0\2\u0863\u025b\3\2\2\2\u0864\u0866\n\25\2\2\u0865\u0864"+ - "\3\2\2\2\u0866\u0867\3\2\2\2\u0867\u0865\3\2\2\2\u0867\u0868\3\2\2\2\u0868"+ - "\u086b\3\2\2\2\u0869\u086b\7&\2\2\u086a\u0865\3\2\2\2\u086a\u0869\3\2"+ - "\2\2\u086b\u025d\3\2\2\2\u086c\u086f\5\u014a\u00a4\2\u086d\u086f\5\u0148"+ - "\u00a3\2\u086e\u086c\3\2\2\2\u086e\u086d\3\2\2\2\u086f\u025f\3\2\2\2\u0870"+ - "\u0871\7&\2\2\u0871\u0872\7}\2\2\u0872\u0873\3\2\2\2\u0873\u0874\b\u012f"+ - "\5\2\u0874\u0261\3\2\2\2\u0875\u0877\5\u0264\u0131\2\u0876\u0875\3\2\2"+ - "\2\u0876\u0877\3\2\2\2\u0877\u0878\3\2\2\2\u0878\u0879\7$\2\2\u0879\u087a"+ - "\7$\2\2\u087a\u087b\7$\2\2\u087b\u087c\3\2\2\2\u087c\u087d\b\u0130\4\2"+ - "\u087d\u0263\3\2\2\2\u087e\u0880\7$\2\2\u087f\u087e\3\2\2\2\u0880\u0881"+ - "\3\2\2\2\u0881\u087f\3\2\2\2\u0881\u0882\3\2\2\2\u0882\u0265\3\2\2\2\u0883"+ - "\u0884\5\u0142\u00a0\2\u0884\u0267\3\2\2\2\u0885\u0887\n\26\2\2\u0886"+ - "\u0885\3\2\2\2\u0887\u0888\3\2\2\2\u0888\u0886\3\2\2\2\u0888\u0889\3\2"+ - "\2\2\u0889"; - private static final String _serializedATNSegment1 = - "\u088c\3\2\2\2\u088a\u088c\7&\2\2\u088b\u0886\3\2\2\2\u088b\u088a\3\2"+ - "\2\2\u088c\u0269\3\2\2\2\u088d\u088e\7&\2\2\u088e\u088f\7}\2\2\u088f\u0890"+ - "\3\2\2\2\u0890\u0891\b\u0134\5\2\u0891\u026b\3\2\2\2\u0892\u0893\5\16"+ - "\6\2\u0893\u0894\3\2\2\2\u0894\u0895\b\u0135\u0082\2\u0895\u026d\3\2\2"+ - "\2\66\2\3\4\5\u0274\u027c\u027e\u028c\u0298\u029a\u029f\u0307\u0425\u042d"+ - "\u0566\u056e\u0572\u0578\u057e\u0582\u0587\u058c\u0591\u0596\u059e\u05a4"+ - "\u05ae\u05b6\u05be\u05c4\u05cc\u05d4\u05e1\u05ea\u05ef\u05f1\u05f8\u05fb"+ - "\u0625\u0630\u0636\u0648\u06a7\u06f2\u0852\u0867\u086a\u086e\u0876\u0881"+ - "\u0888\u088b\u0083\2\3\2\7\3\2\6\2\2\7\2\2\7\4\2\7\5\2\t\f\2\t\16\2\t"+ - "\13\2\t\r\2\t\17\2\t\20\2\t\t\2\t\n\2\t\21\2\t\22\2\t\23\2\t\24\2\t\25"+ - "\2\t\26\2\t\27\2\t\30\2\t\31\2\t\32\2\t\33\2\t\34\2\t\35\2\t\36\2\t\37"+ - "\2\t \2\t!\2\t\"\2\t#\2\t$\2\t%\2\t&\2\t\b\2\t\'\2\t(\2\t)\2\t*\2\t,\2"+ - "\t-\2\t.\2\t/\2\t\60\2\t\61\2\t\62\2\t\63\2\t\\\2\t^\2\t_\2\t[\2\t\64"+ - "\2\t\65\2\t\66\2\t\67\2\t\u0088\2\t\u0089\2\tC\2\tD\2\tA\2\tB\2\tK\2\t"+ - "]\2\t`\2\te\2\td\2\tf\2\tg\2\th\2\ti\2\tj\2\tk\2\tl\2\tW\2\tX\2\tY\2\t"+ - "Z\2\t8\2\t9\2\t:\2\tN\2\tO\2\tP\2\tQ\2\tR\2\tS\2\tT\2\tU\2\tV\2\tm\2\t"+ - "n\2\to\2\tp\2\tq\2\tr\2\ts\2\tt\2\tu\2\tv\2\tw\2\tx\2\ty\2\tz\2\t{\2\t"+ - "|\2\t}\2\t~\2\t\177\2\t\u0080\2\t\u0081\2\t\u0082\2\t\u0083\2\t\u0084"+ - "\2\t\u0085\2\t\u0086\2\t\u0087\2\t\u0091\2\t\u008e\2\t\u008f\2\t\u0090"+ - "\2\t\u0096\2\t\u008a\2\t\u0092\2\t\u008d\2\t\u0093\2\t\u0094\2\t\7\2"; - public static final String _serializedATN = Utils.join( - new String[] { - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.tokens b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.tokens deleted file mode 100644 index abcc63e..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinLexer.tokens +++ /dev/null @@ -1,289 +0,0 @@ -ShebangLine=1 -DelimitedComment=2 -LineComment=3 -WS=4 -NL=5 -RESERVED=6 -DOT=7 -COMMA=8 -LPAREN=9 -RPAREN=10 -LSQUARE=11 -RSQUARE=12 -LCURL=13 -RCURL=14 -MULT=15 -MOD=16 -DIV=17 -ADD=18 -SUB=19 -INCR=20 -DECR=21 -CONJ=22 -DISJ=23 -EXCL_WS=24 -EXCL_NO_WS=25 -COLON=26 -SEMICOLON=27 -ASSIGNMENT=28 -ADD_ASSIGNMENT=29 -SUB_ASSIGNMENT=30 -MULT_ASSIGNMENT=31 -DIV_ASSIGNMENT=32 -MOD_ASSIGNMENT=33 -ARROW=34 -DOUBLE_ARROW=35 -RANGE=36 -COLONCOLON=37 -DOUBLE_SEMICOLON=38 -HASH=39 -AT=40 -AT_WS=41 -QUEST_WS=42 -QUEST_NO_WS=43 -LANGLE=44 -RANGLE=45 -LE=46 -GE=47 -EXCL_EQ=48 -EXCL_EQEQ=49 -AS_SAFE=50 -EQEQ=51 -EQEQEQ=52 -SINGLE_QUOTE=53 -RETURN_AT=54 -CONTINUE_AT=55 -BREAK_AT=56 -THIS_AT=57 -SUPER_AT=58 -PACKAGE=59 -IMPORT=60 -CLASS=61 -INTERFACE=62 -FUN=63 -OBJECT=64 -VAL=65 -VAR=66 -TYPE_ALIAS=67 -CONSTRUCTOR=68 -BY=69 -COMPANION=70 -INIT=71 -THIS=72 -SUPER=73 -TYPEOF=74 -WHERE=75 -IF=76 -ELSE=77 -WHEN=78 -TRY=79 -CATCH=80 -FINALLY=81 -FOR=82 -DO=83 -WHILE=84 -THROW=85 -RETURN=86 -CONTINUE=87 -BREAK=88 -AS=89 -IS=90 -IN=91 -NOT_IS=92 -NOT_IN=93 -OUT=94 -GETTER=95 -SETTER=96 -DYNAMIC=97 -AT_FILE=98 -AT_FIELD=99 -AT_PROPERTY=100 -AT_GET=101 -AT_SET=102 -AT_RECEIVER=103 -AT_PARAM=104 -AT_SETPARAM=105 -AT_DELEGATE=106 -PUBLIC=107 -PRIVATE=108 -PROTECTED=109 -INTERNAL=110 -ENUM=111 -SEALED=112 -ANNOTATION=113 -DATA=114 -INNER=115 -TAILREC=116 -OPERATOR=117 -INLINE=118 -INFIX=119 -EXTERNAL=120 -SUSPEND=121 -OVERRIDE=122 -ABSTRACT=123 -FINAL=124 -OPEN=125 -CONST=126 -LATEINIT=127 -VARARG=128 -NOINLINE=129 -CROSSINLINE=130 -REIFIED=131 -EXPECT=132 -ACTUAL=133 -QUOTE_OPEN=134 -TRIPLE_QUOTE_OPEN=135 -RealLiteral=136 -FloatLiteral=137 -DoubleLiteral=138 -LongLiteral=139 -IntegerLiteral=140 -HexLiteral=141 -BinLiteral=142 -BooleanLiteral=143 -NullLiteral=144 -Identifier=145 -IdentifierAt=146 -FieldIdentifier=147 -CharacterLiteral=148 -ErrorCharacter=149 -UNICODE_CLASS_LL=150 -UNICODE_CLASS_LM=151 -UNICODE_CLASS_LO=152 -UNICODE_CLASS_LT=153 -UNICODE_CLASS_LU=154 -UNICODE_CLASS_ND=155 -UNICODE_CLASS_NL=156 -Inside_Comment=157 -Inside_WS=158 -Inside_NL=159 -QUOTE_CLOSE=160 -LineStrRef=161 -LineStrText=162 -LineStrEscapedChar=163 -LineStrExprStart=164 -TRIPLE_QUOTE_CLOSE=165 -MultiLineStringQuote=166 -MultiLineStrRef=167 -MultiLineStrText=168 -MultiLineStrExprStart=169 -'...'=6 -'.'=7 -','=8 -'('=9 -')'=10 -'['=11 -']'=12 -'{'=13 -'}'=14 -'*'=15 -'%'=16 -'/'=17 -'+'=18 -'-'=19 -'++'=20 -'--'=21 -'&&'=22 -'||'=23 -'!'=25 -':'=26 -';'=27 -'='=28 -'+='=29 -'-='=30 -'*='=31 -'/='=32 -'%='=33 -'->'=34 -'=>'=35 -'..'=36 -'::'=37 -';;'=38 -'#'=39 -'@'=40 -'?'=43 -'<'=44 -'>'=45 -'<='=46 -'>='=47 -'!='=48 -'!=='=49 -'as?'=50 -'=='=51 -'==='=52 -'\''=53 -'package'=59 -'import'=60 -'class'=61 -'interface'=62 -'fun'=63 -'object'=64 -'val'=65 -'var'=66 -'typealias'=67 -'constructor'=68 -'by'=69 -'companion'=70 -'init'=71 -'this'=72 -'super'=73 -'typeof'=74 -'where'=75 -'if'=76 -'else'=77 -'when'=78 -'try'=79 -'catch'=80 -'finally'=81 -'for'=82 -'do'=83 -'while'=84 -'throw'=85 -'return'=86 -'continue'=87 -'break'=88 -'as'=89 -'is'=90 -'in'=91 -'out'=94 -'get'=95 -'set'=96 -'dynamic'=97 -'@file'=98 -'@field'=99 -'@property'=100 -'@get'=101 -'@set'=102 -'@receiver'=103 -'@param'=104 -'@setparam'=105 -'@delegate'=106 -'public'=107 -'private'=108 -'protected'=109 -'internal'=110 -'enum'=111 -'sealed'=112 -'annotation'=113 -'data'=114 -'inner'=115 -'tailrec'=116 -'operator'=117 -'inline'=118 -'infix'=119 -'external'=120 -'suspend'=121 -'override'=122 -'abstract'=123 -'final'=124 -'open'=125 -'const'=126 -'lateinit'=127 -'vararg'=128 -'noinline'=129 -'crossinline'=130 -'reified'=131 -'expect'=132 -'actual'=133 -'"""'=135 -'null'=144 diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.interp deleted file mode 100644 index 18f74c5..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.interp +++ /dev/null @@ -1,515 +0,0 @@ -token literal names: -null -null -null -null -null -null -'...' -'.' -',' -'(' -')' -'[' -']' -'{' -'}' -'*' -'%' -'/' -'+' -'-' -'++' -'--' -'&&' -'||' -null -'!' -':' -';' -'=' -'+=' -'-=' -'*=' -'/=' -'%=' -'->' -'=>' -'..' -'::' -';;' -'#' -'@' -null -null -'?' -'<' -'>' -'<=' -'>=' -'!=' -'!==' -'as?' -'==' -'===' -'\'' -null -null -null -null -null -'package' -'import' -'class' -'interface' -'fun' -'object' -'val' -'var' -'typealias' -'constructor' -'by' -'companion' -'init' -'this' -'super' -'typeof' -'where' -'if' -'else' -'when' -'try' -'catch' -'finally' -'for' -'do' -'while' -'throw' -'return' -'continue' -'break' -'as' -'is' -'in' -null -null -'out' -'get' -'set' -'dynamic' -'@file' -'@field' -'@property' -'@get' -'@set' -'@receiver' -'@param' -'@setparam' -'@delegate' -'public' -'private' -'protected' -'internal' -'enum' -'sealed' -'annotation' -'data' -'inner' -'tailrec' -'operator' -'inline' -'infix' -'external' -'suspend' -'override' -'abstract' -'final' -'open' -'const' -'lateinit' -'vararg' -'noinline' -'crossinline' -'reified' -'expect' -'actual' -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 - -token symbolic names: -null -ShebangLine -DelimitedComment -LineComment -WS -NL -RESERVED -DOT -COMMA -LPAREN -RPAREN -LSQUARE -RSQUARE -LCURL -RCURL -MULT -MOD -DIV -ADD -SUB -INCR -DECR -CONJ -DISJ -EXCL_WS -EXCL_NO_WS -COLON -SEMICOLON -ASSIGNMENT -ADD_ASSIGNMENT -SUB_ASSIGNMENT -MULT_ASSIGNMENT -DIV_ASSIGNMENT -MOD_ASSIGNMENT -ARROW -DOUBLE_ARROW -RANGE -COLONCOLON -DOUBLE_SEMICOLON -HASH -AT -AT_WS -QUEST_WS -QUEST_NO_WS -LANGLE -RANGLE -LE -GE -EXCL_EQ -EXCL_EQEQ -AS_SAFE -EQEQ -EQEQEQ -SINGLE_QUOTE -RETURN_AT -CONTINUE_AT -BREAK_AT -THIS_AT -SUPER_AT -PACKAGE -IMPORT -CLASS -INTERFACE -FUN -OBJECT -VAL -VAR -TYPE_ALIAS -CONSTRUCTOR -BY -COMPANION -INIT -THIS -SUPER -TYPEOF -WHERE -IF -ELSE -WHEN -TRY -CATCH -FINALLY -FOR -DO -WHILE -THROW -RETURN -CONTINUE -BREAK -AS -IS -IN -NOT_IS -NOT_IN -OUT -GETTER -SETTER -DYNAMIC -AT_FILE -AT_FIELD -AT_PROPERTY -AT_GET -AT_SET -AT_RECEIVER -AT_PARAM -AT_SETPARAM -AT_DELEGATE -PUBLIC -PRIVATE -PROTECTED -INTERNAL -ENUM -SEALED -ANNOTATION -DATA -INNER -TAILREC -OPERATOR -INLINE -INFIX -EXTERNAL -SUSPEND -OVERRIDE -ABSTRACT -FINAL -OPEN -CONST -LATEINIT -VARARG -NOINLINE -CROSSINLINE -REIFIED -EXPECT -ACTUAL -QUOTE_OPEN -TRIPLE_QUOTE_OPEN -RealLiteral -FloatLiteral -DoubleLiteral -LongLiteral -IntegerLiteral -HexLiteral -BinLiteral -BooleanLiteral -NullLiteral -Identifier -IdentifierAt -FieldIdentifier -CharacterLiteral -ErrorCharacter -UNICODE_CLASS_LL -UNICODE_CLASS_LM -UNICODE_CLASS_LO -UNICODE_CLASS_LT -UNICODE_CLASS_LU -UNICODE_CLASS_ND -UNICODE_CLASS_NL -Inside_Comment -Inside_WS -Inside_NL -QUOTE_CLOSE -LineStrRef -LineStrText -LineStrEscapedChar -LineStrExprStart -TRIPLE_QUOTE_CLOSE -MultiLineStringQuote -MultiLineStrRef -MultiLineStrText -MultiLineStrExprStart - -rule names: -kotlinFile -script -fileAnnotation -packageHeader -importList -importHeader -importAlias -topLevelObject -classDeclaration -primaryConstructor -classParameters -classParameter -delegationSpecifiers -annotatedDelegationSpecifier -delegationSpecifier -constructorInvocation -explicitDelegation -classBody -classMemberDeclarations -classMemberDeclaration -anonymousInitializer -secondaryConstructor -constructorDelegationCall -enumClassBody -enumEntries -enumEntry -functionDeclaration -functionValueParameters -functionValueParameter -parameter -setterParameter -functionBody -objectDeclaration -companionObject -propertyDeclaration -multiVariableDeclaration -variableDeclaration -propertyDelegate -getter -setter -typeAlias -typeParameters -typeParameter -typeParameterModifiers -typeParameterModifier -type -typeModifiers -typeModifier -parenthesizedType -nullableType -typeReference -functionType -receiverType -userType -parenthesizedUserType -simpleUserType -functionTypeParameters -typeConstraints -typeConstraint -block -statements -statement -declaration -assignment -expression -disjunction -conjunction -equality -comparison -infixOperation -elvisExpression -infixFunctionCall -rangeExpression -additiveExpression -multiplicativeExpression -asExpression -prefixUnaryExpression -unaryPrefix -postfixUnaryExpression -postfixUnarySuffix -directlyAssignableExpression -assignableExpression -assignableSuffix -indexingSuffix -navigationSuffix -callSuffix -annotatedLambda -valueArguments -typeArguments -typeProjection -typeProjectionModifiers -typeProjectionModifier -valueArgument -primaryExpression -parenthesizedExpression -collectionLiteral -literalConstant -stringLiteral -lineStringLiteral -multiLineStringLiteral -lineStringContent -lineStringExpression -multiLineStringContent -multiLineStringExpression -lambdaLiteral -lambdaParameters -lambdaParameter -anonymousFunction -functionLiteral -objectLiteral -thisExpression -superExpression -controlStructureBody -ifExpression -whenExpression -whenEntry -whenCondition -rangeTest -typeTest -tryExpression -catchBlock -finallyBlock -loopStatement -forStatement -whileStatement -doWhileStatement -jumpExpression -callableReference -assignmentAndOperator -equalityOperator -comparisonOperator -inOperator -isOperator -additiveOperator -multiplicativeOperator -asOperator -prefixUnaryOperator -postfixUnaryOperator -memberAccessOperator -modifiers -modifier -classModifier -memberModifier -visibilityModifier -varianceModifier -functionModifier -propertyModifier -inheritanceModifier -parameterModifier -reificationModifier -platformModifier -label -annotation -singleAnnotation -multiAnnotation -annotationUseSiteTarget -unescapedAnnotation -simpleIdentifier -identifier -shebangLine -quest -elvis -safeNav -excl -semi -semis - - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 171, 3281, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 3, 2, 5, 2, 336, 10, 2, 3, 2, 7, 2, 339, 10, 2, 12, 2, 14, 2, 342, 11, 2, 3, 2, 7, 2, 345, 10, 2, 12, 2, 14, 2, 348, 11, 2, 3, 2, 3, 2, 3, 2, 7, 2, 353, 10, 2, 12, 2, 14, 2, 356, 11, 2, 3, 2, 3, 2, 3, 3, 5, 3, 361, 10, 3, 3, 3, 7, 3, 364, 10, 3, 12, 3, 14, 3, 367, 11, 3, 3, 3, 7, 3, 370, 10, 3, 12, 3, 14, 3, 373, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 380, 10, 3, 12, 3, 14, 3, 383, 11, 3, 3, 3, 3, 3, 3, 4, 3, 4, 7, 4, 389, 10, 4, 12, 4, 14, 4, 392, 11, 4, 3, 4, 3, 4, 7, 4, 396, 10, 4, 12, 4, 14, 4, 399, 11, 4, 3, 4, 3, 4, 6, 4, 403, 10, 4, 13, 4, 14, 4, 404, 3, 4, 3, 4, 3, 4, 5, 4, 410, 10, 4, 3, 4, 7, 4, 413, 10, 4, 12, 4, 14, 4, 416, 11, 4, 3, 5, 3, 5, 3, 5, 5, 5, 421, 10, 5, 5, 5, 423, 10, 5, 3, 6, 7, 6, 426, 10, 6, 12, 6, 14, 6, 429, 11, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 436, 10, 7, 3, 7, 5, 7, 439, 10, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 5, 9, 446, 10, 9, 3, 10, 5, 10, 449, 10, 10, 3, 10, 3, 10, 7, 10, 453, 10, 10, 12, 10, 14, 10, 456, 11, 10, 3, 10, 3, 10, 7, 10, 460, 10, 10, 12, 10, 14, 10, 463, 11, 10, 3, 10, 5, 10, 466, 10, 10, 3, 10, 7, 10, 469, 10, 10, 12, 10, 14, 10, 472, 11, 10, 3, 10, 5, 10, 475, 10, 10, 3, 10, 7, 10, 478, 10, 10, 12, 10, 14, 10, 481, 11, 10, 3, 10, 3, 10, 7, 10, 485, 10, 10, 12, 10, 14, 10, 488, 11, 10, 3, 10, 5, 10, 491, 10, 10, 3, 10, 7, 10, 494, 10, 10, 12, 10, 14, 10, 497, 11, 10, 3, 10, 5, 10, 500, 10, 10, 3, 10, 7, 10, 503, 10, 10, 12, 10, 14, 10, 506, 11, 10, 3, 10, 3, 10, 7, 10, 510, 10, 10, 12, 10, 14, 10, 513, 11, 10, 3, 10, 5, 10, 516, 10, 10, 3, 11, 5, 11, 519, 10, 11, 3, 11, 3, 11, 7, 11, 523, 10, 11, 12, 11, 14, 11, 526, 11, 11, 5, 11, 528, 10, 11, 3, 11, 3, 11, 3, 12, 3, 12, 7, 12, 534, 10, 12, 12, 12, 14, 12, 537, 11, 12, 3, 12, 3, 12, 7, 12, 541, 10, 12, 12, 12, 14, 12, 544, 11, 12, 3, 12, 3, 12, 7, 12, 548, 10, 12, 12, 12, 14, 12, 551, 11, 12, 3, 12, 7, 12, 554, 10, 12, 12, 12, 14, 12, 557, 11, 12, 5, 12, 559, 10, 12, 3, 12, 7, 12, 562, 10, 12, 12, 12, 14, 12, 565, 11, 12, 3, 12, 3, 12, 3, 13, 5, 13, 570, 10, 13, 3, 13, 5, 13, 573, 10, 13, 3, 13, 7, 13, 576, 10, 13, 12, 13, 14, 13, 579, 11, 13, 3, 13, 3, 13, 3, 13, 7, 13, 584, 10, 13, 12, 13, 14, 13, 587, 11, 13, 3, 13, 3, 13, 7, 13, 591, 10, 13, 12, 13, 14, 13, 594, 11, 13, 3, 13, 3, 13, 7, 13, 598, 10, 13, 12, 13, 14, 13, 601, 11, 13, 3, 13, 5, 13, 604, 10, 13, 3, 14, 3, 14, 7, 14, 608, 10, 14, 12, 14, 14, 14, 611, 11, 14, 3, 14, 3, 14, 7, 14, 615, 10, 14, 12, 14, 14, 14, 618, 11, 14, 3, 14, 7, 14, 621, 10, 14, 12, 14, 14, 14, 624, 11, 14, 3, 15, 7, 15, 627, 10, 15, 12, 15, 14, 15, 630, 11, 15, 3, 15, 7, 15, 633, 10, 15, 12, 15, 14, 15, 636, 11, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 644, 10, 16, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 5, 18, 651, 10, 18, 3, 18, 7, 18, 654, 10, 18, 12, 18, 14, 18, 657, 11, 18, 3, 18, 3, 18, 7, 18, 661, 10, 18, 12, 18, 14, 18, 664, 11, 18, 3, 18, 3, 18, 3, 19, 3, 19, 7, 19, 670, 10, 19, 12, 19, 14, 19, 673, 11, 19, 3, 19, 3, 19, 7, 19, 677, 10, 19, 12, 19, 14, 19, 680, 11, 19, 3, 19, 3, 19, 3, 20, 3, 20, 5, 20, 686, 10, 20, 7, 20, 688, 10, 20, 12, 20, 14, 20, 691, 11, 20, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 697, 10, 21, 3, 22, 3, 22, 7, 22, 701, 10, 22, 12, 22, 14, 22, 704, 11, 22, 3, 22, 3, 22, 3, 23, 5, 23, 709, 10, 23, 3, 23, 3, 23, 7, 23, 713, 10, 23, 12, 23, 14, 23, 716, 11, 23, 3, 23, 3, 23, 7, 23, 720, 10, 23, 12, 23, 14, 23, 723, 11, 23, 3, 23, 3, 23, 7, 23, 727, 10, 23, 12, 23, 14, 23, 730, 11, 23, 3, 23, 5, 23, 733, 10, 23, 3, 23, 7, 23, 736, 10, 23, 12, 23, 14, 23, 739, 11, 23, 3, 23, 5, 23, 742, 10, 23, 3, 24, 3, 24, 7, 24, 746, 10, 24, 12, 24, 14, 24, 749, 11, 24, 3, 24, 3, 24, 3, 24, 7, 24, 754, 10, 24, 12, 24, 14, 24, 757, 11, 24, 3, 24, 5, 24, 760, 10, 24, 3, 25, 3, 25, 7, 25, 764, 10, 25, 12, 25, 14, 25, 767, 11, 25, 3, 25, 5, 25, 770, 10, 25, 3, 25, 7, 25, 773, 10, 25, 12, 25, 14, 25, 776, 11, 25, 3, 25, 3, 25, 7, 25, 780, 10, 25, 12, 25, 14, 25, 783, 11, 25, 3, 25, 5, 25, 786, 10, 25, 3, 25, 7, 25, 789, 10, 25, 12, 25, 14, 25, 792, 11, 25, 3, 25, 3, 25, 3, 26, 3, 26, 7, 26, 798, 10, 26, 12, 26, 14, 26, 801, 11, 26, 3, 26, 3, 26, 7, 26, 805, 10, 26, 12, 26, 14, 26, 808, 11, 26, 3, 26, 7, 26, 811, 10, 26, 12, 26, 14, 26, 814, 11, 26, 3, 26, 7, 26, 817, 10, 26, 12, 26, 14, 26, 820, 11, 26, 3, 26, 5, 26, 823, 10, 26, 3, 27, 3, 27, 7, 27, 827, 10, 27, 12, 27, 14, 27, 830, 11, 27, 5, 27, 832, 10, 27, 3, 27, 3, 27, 7, 27, 836, 10, 27, 12, 27, 14, 27, 839, 11, 27, 3, 27, 5, 27, 842, 10, 27, 3, 27, 7, 27, 845, 10, 27, 12, 27, 14, 27, 848, 11, 27, 3, 27, 5, 27, 851, 10, 27, 3, 28, 5, 28, 854, 10, 28, 3, 28, 3, 28, 7, 28, 858, 10, 28, 12, 28, 14, 28, 861, 11, 28, 3, 28, 5, 28, 864, 10, 28, 3, 28, 7, 28, 867, 10, 28, 12, 28, 14, 28, 870, 11, 28, 3, 28, 3, 28, 7, 28, 874, 10, 28, 12, 28, 14, 28, 877, 11, 28, 3, 28, 3, 28, 5, 28, 881, 10, 28, 3, 28, 7, 28, 884, 10, 28, 12, 28, 14, 28, 887, 11, 28, 3, 28, 3, 28, 7, 28, 891, 10, 28, 12, 28, 14, 28, 894, 11, 28, 3, 28, 3, 28, 7, 28, 898, 10, 28, 12, 28, 14, 28, 901, 11, 28, 3, 28, 3, 28, 7, 28, 905, 10, 28, 12, 28, 14, 28, 908, 11, 28, 3, 28, 5, 28, 911, 10, 28, 3, 28, 7, 28, 914, 10, 28, 12, 28, 14, 28, 917, 11, 28, 3, 28, 5, 28, 920, 10, 28, 3, 28, 7, 28, 923, 10, 28, 12, 28, 14, 28, 926, 11, 28, 3, 28, 5, 28, 929, 10, 28, 3, 29, 3, 29, 7, 29, 933, 10, 29, 12, 29, 14, 29, 936, 11, 29, 3, 29, 3, 29, 7, 29, 940, 10, 29, 12, 29, 14, 29, 943, 11, 29, 3, 29, 3, 29, 7, 29, 947, 10, 29, 12, 29, 14, 29, 950, 11, 29, 3, 29, 7, 29, 953, 10, 29, 12, 29, 14, 29, 956, 11, 29, 5, 29, 958, 10, 29, 3, 29, 7, 29, 961, 10, 29, 12, 29, 14, 29, 964, 11, 29, 3, 29, 3, 29, 3, 30, 5, 30, 969, 10, 30, 3, 30, 3, 30, 7, 30, 973, 10, 30, 12, 30, 14, 30, 976, 11, 30, 3, 30, 3, 30, 7, 30, 980, 10, 30, 12, 30, 14, 30, 983, 11, 30, 3, 30, 5, 30, 986, 10, 30, 3, 31, 3, 31, 7, 31, 990, 10, 31, 12, 31, 14, 31, 993, 11, 31, 3, 31, 3, 31, 7, 31, 997, 10, 31, 12, 31, 14, 31, 1000, 11, 31, 3, 31, 3, 31, 3, 32, 3, 32, 7, 32, 1006, 10, 32, 12, 32, 14, 32, 1009, 11, 32, 3, 32, 3, 32, 7, 32, 1013, 10, 32, 12, 32, 14, 32, 1016, 11, 32, 3, 32, 5, 32, 1019, 10, 32, 3, 33, 3, 33, 3, 33, 7, 33, 1024, 10, 33, 12, 33, 14, 33, 1027, 11, 33, 3, 33, 5, 33, 1030, 10, 33, 3, 34, 5, 34, 1033, 10, 34, 3, 34, 3, 34, 7, 34, 1037, 10, 34, 12, 34, 14, 34, 1040, 11, 34, 3, 34, 3, 34, 7, 34, 1044, 10, 34, 12, 34, 14, 34, 1047, 11, 34, 3, 34, 3, 34, 7, 34, 1051, 10, 34, 12, 34, 14, 34, 1054, 11, 34, 3, 34, 5, 34, 1057, 10, 34, 3, 34, 7, 34, 1060, 10, 34, 12, 34, 14, 34, 1063, 11, 34, 3, 34, 5, 34, 1066, 10, 34, 3, 35, 5, 35, 1069, 10, 35, 3, 35, 3, 35, 7, 35, 1073, 10, 35, 12, 35, 14, 35, 1076, 11, 35, 3, 35, 3, 35, 7, 35, 1080, 10, 35, 12, 35, 14, 35, 1083, 11, 35, 3, 35, 5, 35, 1086, 10, 35, 3, 35, 7, 35, 1089, 10, 35, 12, 35, 14, 35, 1092, 11, 35, 3, 35, 3, 35, 7, 35, 1096, 10, 35, 12, 35, 14, 35, 1099, 11, 35, 3, 35, 5, 35, 1102, 10, 35, 3, 35, 7, 35, 1105, 10, 35, 12, 35, 14, 35, 1108, 11, 35, 3, 35, 5, 35, 1111, 10, 35, 3, 36, 5, 36, 1114, 10, 36, 3, 36, 3, 36, 7, 36, 1118, 10, 36, 12, 36, 14, 36, 1121, 11, 36, 3, 36, 5, 36, 1124, 10, 36, 3, 36, 7, 36, 1127, 10, 36, 12, 36, 14, 36, 1130, 11, 36, 3, 36, 3, 36, 7, 36, 1134, 10, 36, 12, 36, 14, 36, 1137, 11, 36, 3, 36, 3, 36, 5, 36, 1141, 10, 36, 3, 36, 7, 36, 1144, 10, 36, 12, 36, 14, 36, 1147, 11, 36, 3, 36, 3, 36, 5, 36, 1151, 10, 36, 3, 36, 7, 36, 1154, 10, 36, 12, 36, 14, 36, 1157, 11, 36, 3, 36, 5, 36, 1160, 10, 36, 3, 36, 7, 36, 1163, 10, 36, 12, 36, 14, 36, 1166, 11, 36, 3, 36, 3, 36, 7, 36, 1170, 10, 36, 12, 36, 14, 36, 1173, 11, 36, 3, 36, 3, 36, 5, 36, 1177, 10, 36, 5, 36, 1179, 10, 36, 3, 36, 6, 36, 1182, 10, 36, 13, 36, 14, 36, 1183, 3, 36, 5, 36, 1187, 10, 36, 3, 36, 7, 36, 1190, 10, 36, 12, 36, 14, 36, 1193, 11, 36, 3, 36, 5, 36, 1196, 10, 36, 3, 36, 7, 36, 1199, 10, 36, 12, 36, 14, 36, 1202, 11, 36, 3, 36, 5, 36, 1205, 10, 36, 3, 36, 5, 36, 1208, 10, 36, 3, 36, 5, 36, 1211, 10, 36, 3, 36, 7, 36, 1214, 10, 36, 12, 36, 14, 36, 1217, 11, 36, 3, 36, 5, 36, 1220, 10, 36, 3, 36, 5, 36, 1223, 10, 36, 5, 36, 1225, 10, 36, 3, 37, 3, 37, 7, 37, 1229, 10, 37, 12, 37, 14, 37, 1232, 11, 37, 3, 37, 3, 37, 7, 37, 1236, 10, 37, 12, 37, 14, 37, 1239, 11, 37, 3, 37, 3, 37, 7, 37, 1243, 10, 37, 12, 37, 14, 37, 1246, 11, 37, 3, 37, 7, 37, 1249, 10, 37, 12, 37, 14, 37, 1252, 11, 37, 3, 37, 7, 37, 1255, 10, 37, 12, 37, 14, 37, 1258, 11, 37, 3, 37, 3, 37, 3, 38, 7, 38, 1263, 10, 38, 12, 38, 14, 38, 1266, 11, 38, 3, 38, 7, 38, 1269, 10, 38, 12, 38, 14, 38, 1272, 11, 38, 3, 38, 3, 38, 7, 38, 1276, 10, 38, 12, 38, 14, 38, 1279, 11, 38, 3, 38, 3, 38, 7, 38, 1283, 10, 38, 12, 38, 14, 38, 1286, 11, 38, 3, 38, 5, 38, 1289, 10, 38, 3, 39, 3, 39, 7, 39, 1293, 10, 39, 12, 39, 14, 39, 1296, 11, 39, 3, 39, 3, 39, 3, 40, 5, 40, 1301, 10, 40, 3, 40, 3, 40, 5, 40, 1305, 10, 40, 3, 40, 3, 40, 7, 40, 1309, 10, 40, 12, 40, 14, 40, 1312, 11, 40, 3, 40, 3, 40, 7, 40, 1316, 10, 40, 12, 40, 14, 40, 1319, 11, 40, 3, 40, 3, 40, 7, 40, 1323, 10, 40, 12, 40, 14, 40, 1326, 11, 40, 3, 40, 3, 40, 7, 40, 1330, 10, 40, 12, 40, 14, 40, 1333, 11, 40, 3, 40, 5, 40, 1336, 10, 40, 3, 40, 7, 40, 1339, 10, 40, 12, 40, 14, 40, 1342, 11, 40, 3, 40, 5, 40, 1345, 10, 40, 3, 41, 5, 41, 1348, 10, 41, 3, 41, 3, 41, 5, 41, 1352, 10, 41, 3, 41, 3, 41, 7, 41, 1356, 10, 41, 12, 41, 14, 41, 1359, 11, 41, 3, 41, 3, 41, 3, 41, 7, 41, 1364, 10, 41, 12, 41, 14, 41, 1367, 11, 41, 3, 41, 3, 41, 3, 41, 7, 41, 1372, 10, 41, 12, 41, 14, 41, 1375, 11, 41, 3, 41, 3, 41, 7, 41, 1379, 10, 41, 12, 41, 14, 41, 1382, 11, 41, 3, 41, 5, 41, 1385, 10, 41, 3, 41, 7, 41, 1388, 10, 41, 12, 41, 14, 41, 1391, 11, 41, 3, 41, 3, 41, 5, 41, 1395, 10, 41, 3, 42, 5, 42, 1398, 10, 42, 3, 42, 3, 42, 7, 42, 1402, 10, 42, 12, 42, 14, 42, 1405, 11, 42, 3, 42, 3, 42, 7, 42, 1409, 10, 42, 12, 42, 14, 42, 1412, 11, 42, 3, 42, 5, 42, 1415, 10, 42, 3, 42, 7, 42, 1418, 10, 42, 12, 42, 14, 42, 1421, 11, 42, 3, 42, 3, 42, 7, 42, 1425, 10, 42, 12, 42, 14, 42, 1428, 11, 42, 3, 42, 3, 42, 3, 43, 3, 43, 7, 43, 1434, 10, 43, 12, 43, 14, 43, 1437, 11, 43, 3, 43, 3, 43, 7, 43, 1441, 10, 43, 12, 43, 14, 43, 1444, 11, 43, 3, 43, 3, 43, 7, 43, 1448, 10, 43, 12, 43, 14, 43, 1451, 11, 43, 3, 43, 7, 43, 1454, 10, 43, 12, 43, 14, 43, 1457, 11, 43, 3, 43, 7, 43, 1460, 10, 43, 12, 43, 14, 43, 1463, 11, 43, 3, 43, 3, 43, 3, 44, 5, 44, 1468, 10, 44, 3, 44, 7, 44, 1471, 10, 44, 12, 44, 14, 44, 1474, 11, 44, 3, 44, 3, 44, 7, 44, 1478, 10, 44, 12, 44, 14, 44, 1481, 11, 44, 3, 44, 3, 44, 7, 44, 1485, 10, 44, 12, 44, 14, 44, 1488, 11, 44, 3, 44, 5, 44, 1491, 10, 44, 3, 45, 6, 45, 1494, 10, 45, 13, 45, 14, 45, 1495, 3, 46, 3, 46, 7, 46, 1500, 10, 46, 12, 46, 14, 46, 1503, 11, 46, 3, 46, 3, 46, 7, 46, 1507, 10, 46, 12, 46, 14, 46, 1510, 11, 46, 3, 46, 5, 46, 1513, 10, 46, 3, 47, 5, 47, 1516, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 1522, 10, 47, 3, 48, 6, 48, 1525, 10, 48, 13, 48, 14, 48, 1526, 3, 49, 3, 49, 3, 49, 7, 49, 1532, 10, 49, 12, 49, 14, 49, 1535, 11, 49, 5, 49, 1537, 10, 49, 3, 50, 3, 50, 7, 50, 1541, 10, 50, 12, 50, 14, 50, 1544, 11, 50, 3, 50, 3, 50, 7, 50, 1548, 10, 50, 12, 50, 14, 50, 1551, 11, 50, 3, 50, 3, 50, 3, 51, 3, 51, 5, 51, 1557, 10, 51, 3, 51, 7, 51, 1560, 10, 51, 12, 51, 14, 51, 1563, 11, 51, 3, 51, 6, 51, 1566, 10, 51, 13, 51, 14, 51, 1567, 3, 52, 3, 52, 5, 52, 1572, 10, 52, 3, 53, 3, 53, 7, 53, 1576, 10, 53, 12, 53, 14, 53, 1579, 11, 53, 3, 53, 3, 53, 7, 53, 1583, 10, 53, 12, 53, 14, 53, 1586, 11, 53, 5, 53, 1588, 10, 53, 3, 53, 3, 53, 7, 53, 1592, 10, 53, 12, 53, 14, 53, 1595, 11, 53, 3, 53, 3, 53, 7, 53, 1599, 10, 53, 12, 53, 14, 53, 1602, 11, 53, 3, 53, 3, 53, 3, 54, 5, 54, 1607, 10, 54, 3, 54, 3, 54, 3, 54, 5, 54, 1612, 10, 54, 3, 55, 3, 55, 7, 55, 1616, 10, 55, 12, 55, 14, 55, 1619, 11, 55, 3, 55, 3, 55, 7, 55, 1623, 10, 55, 12, 55, 14, 55, 1626, 11, 55, 3, 55, 7, 55, 1629, 10, 55, 12, 55, 14, 55, 1632, 11, 55, 3, 56, 3, 56, 7, 56, 1636, 10, 56, 12, 56, 14, 56, 1639, 11, 56, 3, 56, 3, 56, 7, 56, 1643, 10, 56, 12, 56, 14, 56, 1646, 11, 56, 3, 56, 3, 56, 3, 56, 3, 56, 7, 56, 1652, 10, 56, 12, 56, 14, 56, 1655, 11, 56, 3, 56, 3, 56, 7, 56, 1659, 10, 56, 12, 56, 14, 56, 1662, 11, 56, 3, 56, 3, 56, 5, 56, 1666, 10, 56, 3, 57, 3, 57, 7, 57, 1670, 10, 57, 12, 57, 14, 57, 1673, 11, 57, 3, 57, 5, 57, 1676, 10, 57, 3, 58, 3, 58, 7, 58, 1680, 10, 58, 12, 58, 14, 58, 1683, 11, 58, 3, 58, 3, 58, 5, 58, 1687, 10, 58, 3, 58, 7, 58, 1690, 10, 58, 12, 58, 14, 58, 1693, 11, 58, 3, 58, 3, 58, 7, 58, 1697, 10, 58, 12, 58, 14, 58, 1700, 11, 58, 3, 58, 3, 58, 5, 58, 1704, 10, 58, 7, 58, 1706, 10, 58, 12, 58, 14, 58, 1709, 11, 58, 3, 58, 7, 58, 1712, 10, 58, 12, 58, 14, 58, 1715, 11, 58, 3, 58, 3, 58, 3, 59, 3, 59, 7, 59, 1721, 10, 59, 12, 59, 14, 59, 1724, 11, 59, 3, 59, 3, 59, 7, 59, 1728, 10, 59, 12, 59, 14, 59, 1731, 11, 59, 3, 59, 3, 59, 7, 59, 1735, 10, 59, 12, 59, 14, 59, 1738, 11, 59, 3, 59, 7, 59, 1741, 10, 59, 12, 59, 14, 59, 1744, 11, 59, 3, 60, 7, 60, 1747, 10, 60, 12, 60, 14, 60, 1750, 11, 60, 3, 60, 3, 60, 7, 60, 1754, 10, 60, 12, 60, 14, 60, 1757, 11, 60, 3, 60, 3, 60, 7, 60, 1761, 10, 60, 12, 60, 14, 60, 1764, 11, 60, 3, 60, 3, 60, 3, 61, 3, 61, 7, 61, 1770, 10, 61, 12, 61, 14, 61, 1773, 11, 61, 3, 61, 3, 61, 7, 61, 1777, 10, 61, 12, 61, 14, 61, 1780, 11, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 7, 62, 1788, 10, 62, 12, 62, 14, 62, 1791, 11, 62, 3, 62, 5, 62, 1794, 10, 62, 5, 62, 1796, 10, 62, 3, 63, 3, 63, 7, 63, 1800, 10, 63, 12, 63, 14, 63, 1803, 11, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1809, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 1816, 10, 64, 3, 65, 3, 65, 3, 65, 7, 65, 1821, 10, 65, 12, 65, 14, 65, 1824, 11, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 7, 65, 1831, 10, 65, 12, 65, 14, 65, 1834, 11, 65, 3, 65, 3, 65, 5, 65, 1838, 10, 65, 3, 66, 3, 66, 3, 67, 3, 67, 7, 67, 1844, 10, 67, 12, 67, 14, 67, 1847, 11, 67, 3, 67, 3, 67, 7, 67, 1851, 10, 67, 12, 67, 14, 67, 1854, 11, 67, 3, 67, 7, 67, 1857, 10, 67, 12, 67, 14, 67, 1860, 11, 67, 3, 68, 3, 68, 7, 68, 1864, 10, 68, 12, 68, 14, 68, 1867, 11, 68, 3, 68, 3, 68, 7, 68, 1871, 10, 68, 12, 68, 14, 68, 1874, 11, 68, 3, 68, 7, 68, 1877, 10, 68, 12, 68, 14, 68, 1880, 11, 68, 3, 69, 3, 69, 3, 69, 7, 69, 1885, 10, 69, 12, 69, 14, 69, 1888, 11, 69, 3, 69, 3, 69, 7, 69, 1892, 10, 69, 12, 69, 14, 69, 1895, 11, 69, 3, 70, 3, 70, 3, 70, 7, 70, 1900, 10, 70, 12, 70, 14, 70, 1903, 11, 70, 3, 70, 3, 70, 5, 70, 1907, 10, 70, 3, 71, 3, 71, 3, 71, 7, 71, 1912, 10, 71, 12, 71, 14, 71, 1915, 11, 71, 3, 71, 3, 71, 3, 71, 3, 71, 7, 71, 1921, 10, 71, 12, 71, 14, 71, 1924, 11, 71, 3, 71, 3, 71, 7, 71, 1928, 10, 71, 12, 71, 14, 71, 1931, 11, 71, 3, 72, 3, 72, 7, 72, 1935, 10, 72, 12, 72, 14, 72, 1938, 11, 72, 3, 72, 3, 72, 7, 72, 1942, 10, 72, 12, 72, 14, 72, 1945, 11, 72, 3, 72, 3, 72, 7, 72, 1949, 10, 72, 12, 72, 14, 72, 1952, 11, 72, 3, 73, 3, 73, 3, 73, 7, 73, 1957, 10, 73, 12, 73, 14, 73, 1960, 11, 73, 3, 73, 3, 73, 7, 73, 1964, 10, 73, 12, 73, 14, 73, 1967, 11, 73, 3, 74, 3, 74, 3, 74, 7, 74, 1972, 10, 74, 12, 74, 14, 74, 1975, 11, 74, 3, 74, 7, 74, 1978, 10, 74, 12, 74, 14, 74, 1981, 11, 74, 3, 75, 3, 75, 3, 75, 7, 75, 1986, 10, 75, 12, 75, 14, 75, 1989, 11, 75, 3, 75, 3, 75, 7, 75, 1993, 10, 75, 12, 75, 14, 75, 1996, 11, 75, 3, 76, 3, 76, 3, 76, 7, 76, 2001, 10, 76, 12, 76, 14, 76, 2004, 11, 76, 3, 76, 3, 76, 7, 76, 2008, 10, 76, 12, 76, 14, 76, 2011, 11, 76, 3, 77, 3, 77, 7, 77, 2015, 10, 77, 12, 77, 14, 77, 2018, 11, 77, 3, 77, 3, 77, 7, 77, 2022, 10, 77, 12, 77, 14, 77, 2025, 11, 77, 3, 77, 3, 77, 5, 77, 2029, 10, 77, 3, 78, 7, 78, 2032, 10, 78, 12, 78, 14, 78, 2035, 11, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 7, 79, 2043, 10, 79, 12, 79, 14, 79, 2046, 11, 79, 5, 79, 2048, 10, 79, 3, 80, 3, 80, 3, 80, 6, 80, 2053, 10, 80, 13, 80, 14, 80, 2054, 5, 80, 2057, 10, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 2064, 10, 81, 3, 82, 3, 82, 3, 82, 3, 82, 5, 82, 2070, 10, 82, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 5, 84, 2077, 10, 84, 3, 85, 3, 85, 7, 85, 2081, 10, 85, 12, 85, 14, 85, 2084, 11, 85, 3, 85, 3, 85, 7, 85, 2088, 10, 85, 12, 85, 14, 85, 2091, 11, 85, 3, 85, 3, 85, 7, 85, 2095, 10, 85, 12, 85, 14, 85, 2098, 11, 85, 3, 85, 7, 85, 2101, 10, 85, 12, 85, 14, 85, 2104, 11, 85, 3, 85, 7, 85, 2107, 10, 85, 12, 85, 14, 85, 2110, 11, 85, 3, 85, 3, 85, 3, 86, 7, 86, 2115, 10, 86, 12, 86, 14, 86, 2118, 11, 86, 3, 86, 3, 86, 7, 86, 2122, 10, 86, 12, 86, 14, 86, 2125, 11, 86, 3, 86, 3, 86, 3, 86, 5, 86, 2130, 10, 86, 3, 87, 5, 87, 2133, 10, 87, 3, 87, 5, 87, 2136, 10, 87, 3, 87, 3, 87, 5, 87, 2140, 10, 87, 3, 87, 5, 87, 2143, 10, 87, 3, 88, 7, 88, 2146, 10, 88, 12, 88, 14, 88, 2149, 11, 88, 3, 88, 5, 88, 2152, 10, 88, 3, 88, 7, 88, 2155, 10, 88, 12, 88, 14, 88, 2158, 11, 88, 3, 88, 3, 88, 3, 89, 3, 89, 7, 89, 2164, 10, 89, 12, 89, 14, 89, 2167, 11, 89, 3, 89, 3, 89, 3, 89, 7, 89, 2172, 10, 89, 12, 89, 14, 89, 2175, 11, 89, 3, 89, 3, 89, 7, 89, 2179, 10, 89, 12, 89, 14, 89, 2182, 11, 89, 3, 89, 3, 89, 7, 89, 2186, 10, 89, 12, 89, 14, 89, 2189, 11, 89, 3, 89, 7, 89, 2192, 10, 89, 12, 89, 14, 89, 2195, 11, 89, 3, 89, 7, 89, 2198, 10, 89, 12, 89, 14, 89, 2201, 11, 89, 3, 89, 3, 89, 5, 89, 2205, 10, 89, 3, 90, 3, 90, 7, 90, 2209, 10, 90, 12, 90, 14, 90, 2212, 11, 90, 3, 90, 3, 90, 7, 90, 2216, 10, 90, 12, 90, 14, 90, 2219, 11, 90, 3, 90, 3, 90, 7, 90, 2223, 10, 90, 12, 90, 14, 90, 2226, 11, 90, 3, 90, 7, 90, 2229, 10, 90, 12, 90, 14, 90, 2232, 11, 90, 3, 90, 7, 90, 2235, 10, 90, 12, 90, 14, 90, 2238, 11, 90, 3, 90, 3, 90, 3, 91, 5, 91, 2243, 10, 91, 3, 91, 3, 91, 5, 91, 2247, 10, 91, 3, 92, 6, 92, 2250, 10, 92, 13, 92, 14, 92, 2251, 3, 93, 3, 93, 7, 93, 2256, 10, 93, 12, 93, 14, 93, 2259, 11, 93, 3, 93, 5, 93, 2262, 10, 93, 3, 94, 5, 94, 2265, 10, 94, 3, 94, 7, 94, 2268, 10, 94, 12, 94, 14, 94, 2271, 11, 94, 3, 94, 3, 94, 7, 94, 2275, 10, 94, 12, 94, 14, 94, 2278, 11, 94, 3, 94, 3, 94, 7, 94, 2282, 10, 94, 12, 94, 14, 94, 2285, 11, 94, 5, 94, 2287, 10, 94, 3, 94, 5, 94, 2290, 10, 94, 3, 94, 7, 94, 2293, 10, 94, 12, 94, 14, 94, 2296, 11, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 5, 95, 2314, 10, 95, 3, 96, 3, 96, 7, 96, 2318, 10, 96, 12, 96, 14, 96, 2321, 11, 96, 3, 96, 3, 96, 7, 96, 2325, 10, 96, 12, 96, 14, 96, 2328, 11, 96, 3, 96, 3, 96, 3, 97, 3, 97, 7, 97, 2334, 10, 97, 12, 97, 14, 97, 2337, 11, 97, 3, 97, 3, 97, 7, 97, 2341, 10, 97, 12, 97, 14, 97, 2344, 11, 97, 3, 97, 3, 97, 7, 97, 2348, 10, 97, 12, 97, 14, 97, 2351, 11, 97, 3, 97, 7, 97, 2354, 10, 97, 12, 97, 14, 97, 2357, 11, 97, 3, 97, 7, 97, 2360, 10, 97, 12, 97, 14, 97, 2363, 11, 97, 3, 97, 3, 97, 3, 97, 3, 97, 7, 97, 2369, 10, 97, 12, 97, 14, 97, 2372, 11, 97, 3, 97, 5, 97, 2375, 10, 97, 3, 98, 3, 98, 3, 99, 3, 99, 5, 99, 2381, 10, 99, 3, 100, 3, 100, 3, 100, 7, 100, 2386, 10, 100, 12, 100, 14, 100, 2389, 11, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 7, 101, 2397, 10, 101, 12, 101, 14, 101, 2400, 11, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 105, 3, 105, 7, 105, 2414, 10, 105, 12, 105, 14, 105, 2417, 11, 105, 3, 105, 3, 105, 7, 105, 2421, 10, 105, 12, 105, 14, 105, 2424, 11, 105, 3, 105, 3, 105, 3, 106, 3, 106, 7, 106, 2430, 10, 106, 12, 106, 14, 106, 2433, 11, 106, 3, 106, 3, 106, 7, 106, 2437, 10, 106, 12, 106, 14, 106, 2440, 11, 106, 3, 106, 3, 106, 3, 106, 3, 106, 7, 106, 2446, 10, 106, 12, 106, 14, 106, 2449, 11, 106, 3, 106, 5, 106, 2452, 10, 106, 3, 106, 7, 106, 2455, 10, 106, 12, 106, 14, 106, 2458, 11, 106, 3, 106, 3, 106, 7, 106, 2462, 10, 106, 12, 106, 14, 106, 2465, 11, 106, 3, 106, 3, 106, 7, 106, 2469, 10, 106, 12, 106, 14, 106, 2472, 11, 106, 3, 106, 3, 106, 5, 106, 2476, 10, 106, 3, 107, 3, 107, 7, 107, 2480, 10, 107, 12, 107, 14, 107, 2483, 11, 107, 3, 107, 3, 107, 7, 107, 2487, 10, 107, 12, 107, 14, 107, 2490, 11, 107, 3, 107, 7, 107, 2493, 10, 107, 12, 107, 14, 107, 2496, 11, 107, 3, 108, 3, 108, 3, 108, 7, 108, 2501, 10, 108, 12, 108, 14, 108, 2504, 11, 108, 3, 108, 3, 108, 7, 108, 2508, 10, 108, 12, 108, 14, 108, 2511, 11, 108, 3, 108, 5, 108, 2514, 10, 108, 5, 108, 2516, 10, 108, 3, 109, 3, 109, 7, 109, 2520, 10, 109, 12, 109, 14, 109, 2523, 11, 109, 3, 109, 3, 109, 7, 109, 2527, 10, 109, 12, 109, 14, 109, 2530, 11, 109, 3, 109, 3, 109, 5, 109, 2534, 10, 109, 3, 109, 7, 109, 2537, 10, 109, 12, 109, 14, 109, 2540, 11, 109, 3, 109, 3, 109, 7, 109, 2544, 10, 109, 12, 109, 14, 109, 2547, 11, 109, 3, 109, 3, 109, 7, 109, 2551, 10, 109, 12, 109, 14, 109, 2554, 11, 109, 3, 109, 5, 109, 2557, 10, 109, 3, 109, 7, 109, 2560, 10, 109, 12, 109, 14, 109, 2563, 11, 109, 3, 109, 5, 109, 2566, 10, 109, 3, 109, 7, 109, 2569, 10, 109, 12, 109, 14, 109, 2572, 11, 109, 3, 109, 5, 109, 2575, 10, 109, 3, 110, 3, 110, 5, 110, 2579, 10, 110, 3, 111, 3, 111, 7, 111, 2583, 10, 111, 12, 111, 14, 111, 2586, 11, 111, 3, 111, 3, 111, 7, 111, 2590, 10, 111, 12, 111, 14, 111, 2593, 11, 111, 3, 111, 3, 111, 7, 111, 2597, 10, 111, 12, 111, 14, 111, 2600, 11, 111, 3, 111, 5, 111, 2603, 10, 111, 3, 111, 3, 111, 7, 111, 2607, 10, 111, 12, 111, 14, 111, 2610, 11, 111, 3, 111, 5, 111, 2613, 10, 111, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 7, 113, 2620, 10, 113, 12, 113, 14, 113, 2623, 11, 113, 3, 113, 3, 113, 7, 113, 2627, 10, 113, 12, 113, 14, 113, 2630, 11, 113, 3, 113, 3, 113, 5, 113, 2634, 10, 113, 3, 113, 3, 113, 5, 113, 2638, 10, 113, 3, 113, 5, 113, 2641, 10, 113, 3, 114, 3, 114, 5, 114, 2645, 10, 114, 3, 115, 3, 115, 7, 115, 2649, 10, 115, 12, 115, 14, 115, 2652, 11, 115, 3, 115, 3, 115, 7, 115, 2656, 10, 115, 12, 115, 14, 115, 2659, 11, 115, 3, 115, 3, 115, 7, 115, 2663, 10, 115, 12, 115, 14, 115, 2666, 11, 115, 3, 115, 3, 115, 7, 115, 2670, 10, 115, 12, 115, 14, 115, 2673, 11, 115, 3, 115, 3, 115, 5, 115, 2677, 10, 115, 3, 115, 7, 115, 2680, 10, 115, 12, 115, 14, 115, 2683, 11, 115, 3, 115, 3, 115, 7, 115, 2687, 10, 115, 12, 115, 14, 115, 2690, 11, 115, 3, 115, 5, 115, 2693, 10, 115, 3, 115, 3, 115, 7, 115, 2697, 10, 115, 12, 115, 14, 115, 2700, 11, 115, 3, 115, 3, 115, 7, 115, 2704, 10, 115, 12, 115, 14, 115, 2707, 11, 115, 3, 115, 3, 115, 7, 115, 2711, 10, 115, 12, 115, 14, 115, 2714, 11, 115, 3, 115, 3, 115, 7, 115, 2718, 10, 115, 12, 115, 14, 115, 2721, 11, 115, 3, 115, 3, 115, 7, 115, 2725, 10, 115, 12, 115, 14, 115, 2728, 11, 115, 5, 115, 2730, 10, 115, 3, 115, 3, 115, 7, 115, 2734, 10, 115, 12, 115, 14, 115, 2737, 11, 115, 3, 115, 3, 115, 5, 115, 2741, 10, 115, 3, 116, 3, 116, 7, 116, 2745, 10, 116, 12, 116, 14, 116, 2748, 11, 116, 3, 116, 3, 116, 3, 116, 3, 116, 5, 116, 2754, 10, 116, 3, 116, 7, 116, 2757, 10, 116, 12, 116, 14, 116, 2760, 11, 116, 3, 116, 3, 116, 7, 116, 2764, 10, 116, 12, 116, 14, 116, 2767, 11, 116, 3, 116, 3, 116, 7, 116, 2771, 10, 116, 12, 116, 14, 116, 2774, 11, 116, 7, 116, 2776, 10, 116, 12, 116, 14, 116, 2779, 11, 116, 3, 116, 7, 116, 2782, 10, 116, 12, 116, 14, 116, 2785, 11, 116, 3, 116, 3, 116, 3, 117, 3, 117, 7, 117, 2791, 10, 117, 12, 117, 14, 117, 2794, 11, 117, 3, 117, 3, 117, 7, 117, 2798, 10, 117, 12, 117, 14, 117, 2801, 11, 117, 3, 117, 7, 117, 2804, 10, 117, 12, 117, 14, 117, 2807, 11, 117, 3, 117, 7, 117, 2810, 10, 117, 12, 117, 14, 117, 2813, 11, 117, 3, 117, 3, 117, 7, 117, 2817, 10, 117, 12, 117, 14, 117, 2820, 11, 117, 3, 117, 3, 117, 5, 117, 2824, 10, 117, 3, 117, 3, 117, 7, 117, 2828, 10, 117, 12, 117, 14, 117, 2831, 11, 117, 3, 117, 3, 117, 7, 117, 2835, 10, 117, 12, 117, 14, 117, 2838, 11, 117, 3, 117, 3, 117, 5, 117, 2842, 10, 117, 5, 117, 2844, 10, 117, 3, 118, 3, 118, 3, 118, 5, 118, 2849, 10, 118, 3, 119, 3, 119, 7, 119, 2853, 10, 119, 12, 119, 14, 119, 2856, 11, 119, 3, 119, 3, 119, 3, 120, 3, 120, 7, 120, 2862, 10, 120, 12, 120, 14, 120, 2865, 11, 120, 3, 120, 3, 120, 3, 121, 3, 121, 7, 121, 2871, 10, 121, 12, 121, 14, 121, 2874, 11, 121, 3, 121, 3, 121, 7, 121, 2878, 10, 121, 12, 121, 14, 121, 2881, 11, 121, 3, 121, 6, 121, 2884, 10, 121, 13, 121, 14, 121, 2885, 3, 121, 7, 121, 2889, 10, 121, 12, 121, 14, 121, 2892, 11, 121, 3, 121, 5, 121, 2895, 10, 121, 3, 121, 7, 121, 2898, 10, 121, 12, 121, 14, 121, 2901, 11, 121, 3, 121, 5, 121, 2904, 10, 121, 3, 122, 3, 122, 7, 122, 2908, 10, 122, 12, 122, 14, 122, 2911, 11, 122, 3, 122, 3, 122, 7, 122, 2915, 10, 122, 12, 122, 14, 122, 2918, 11, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 7, 122, 2925, 10, 122, 12, 122, 14, 122, 2928, 11, 122, 3, 122, 3, 122, 3, 123, 3, 123, 7, 123, 2934, 10, 123, 12, 123, 14, 123, 2937, 11, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 5, 124, 2944, 10, 124, 3, 125, 3, 125, 7, 125, 2948, 10, 125, 12, 125, 14, 125, 2951, 11, 125, 3, 125, 3, 125, 7, 125, 2955, 10, 125, 12, 125, 14, 125, 2958, 11, 125, 3, 125, 3, 125, 5, 125, 2962, 10, 125, 3, 125, 3, 125, 3, 125, 3, 125, 7, 125, 2968, 10, 125, 12, 125, 14, 125, 2971, 11, 125, 3, 125, 5, 125, 2974, 10, 125, 3, 126, 3, 126, 7, 126, 2978, 10, 126, 12, 126, 14, 126, 2981, 11, 126, 3, 126, 3, 126, 3, 126, 3, 126, 7, 126, 2987, 10, 126, 12, 126, 14, 126, 2990, 11, 126, 3, 126, 3, 126, 3, 126, 3, 126, 7, 126, 2996, 10, 126, 12, 126, 14, 126, 2999, 11, 126, 3, 126, 3, 126, 3, 126, 3, 126, 7, 126, 3005, 10, 126, 12, 126, 14, 126, 3008, 11, 126, 3, 126, 3, 126, 5, 126, 3012, 10, 126, 3, 127, 3, 127, 7, 127, 3016, 10, 127, 12, 127, 14, 127, 3019, 11, 127, 3, 127, 5, 127, 3022, 10, 127, 3, 127, 7, 127, 3025, 10, 127, 12, 127, 14, 127, 3028, 11, 127, 3, 127, 3, 127, 7, 127, 3032, 10, 127, 12, 127, 14, 127, 3035, 11, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 7, 128, 3043, 10, 128, 12, 128, 14, 128, 3046, 11, 128, 3, 128, 3, 128, 3, 128, 5, 128, 3051, 10, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 3057, 10, 128, 3, 129, 5, 129, 3060, 10, 129, 3, 129, 7, 129, 3063, 10, 129, 12, 129, 14, 129, 3066, 11, 129, 3, 129, 3, 129, 7, 129, 3070, 10, 129, 12, 129, 14, 129, 3073, 11, 129, 3, 129, 3, 129, 5, 129, 3077, 10, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 132, 3, 132, 3, 133, 3, 133, 3, 134, 3, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3100, 10, 138, 3, 139, 3, 139, 3, 139, 3, 139, 5, 139, 3106, 10, 139, 3, 140, 3, 140, 3, 140, 5, 140, 3111, 10, 140, 3, 141, 3, 141, 6, 141, 3115, 10, 141, 13, 141, 14, 141, 3116, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 3127, 10, 142, 3, 142, 7, 142, 3130, 10, 142, 12, 142, 14, 142, 3133, 11, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 151, 3, 151, 3, 152, 3, 152, 3, 153, 3, 153, 7, 153, 3157, 10, 153, 12, 153, 14, 153, 3160, 11, 153, 3, 154, 3, 154, 5, 154, 3164, 10, 154, 3, 154, 7, 154, 3167, 10, 154, 12, 154, 14, 154, 3170, 11, 154, 3, 155, 3, 155, 7, 155, 3174, 10, 155, 12, 155, 14, 155, 3177, 11, 155, 3, 155, 3, 155, 7, 155, 3181, 10, 155, 12, 155, 14, 155, 3184, 11, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3190, 10, 155, 3, 156, 3, 156, 7, 156, 3194, 10, 156, 12, 156, 14, 156, 3197, 11, 156, 3, 156, 3, 156, 7, 156, 3201, 10, 156, 12, 156, 14, 156, 3204, 11, 156, 3, 156, 3, 156, 6, 156, 3208, 10, 156, 13, 156, 14, 156, 3209, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 6, 156, 3217, 10, 156, 13, 156, 14, 156, 3218, 3, 156, 3, 156, 5, 156, 3223, 10, 156, 3, 157, 3, 157, 3, 158, 3, 158, 5, 158, 3229, 10, 158, 3, 159, 3, 159, 3, 160, 3, 160, 7, 160, 3235, 10, 160, 12, 160, 14, 160, 3238, 11, 160, 3, 160, 3, 160, 7, 160, 3242, 10, 160, 12, 160, 14, 160, 3245, 11, 160, 3, 161, 3, 161, 6, 161, 3249, 10, 161, 13, 161, 14, 161, 3250, 3, 162, 3, 162, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 166, 3, 166, 7, 166, 3265, 10, 166, 12, 166, 14, 166, 3268, 11, 166, 3, 166, 5, 166, 3271, 10, 166, 3, 167, 6, 167, 3274, 10, 167, 13, 167, 14, 167, 3275, 3, 167, 5, 167, 3279, 10, 167, 3, 167, 2, 2, 168, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 2, 30, 3, 2, 63, 64, 3, 2, 67, 68, 5, 2, 138, 138, 141, 146, 150, 150, 3, 2, 163, 165, 3, 2, 168, 170, 4, 2, 59, 59, 74, 74, 4, 2, 56, 56, 88, 88, 3, 2, 31, 35, 4, 2, 50, 51, 53, 54, 3, 2, 46, 49, 4, 2, 93, 93, 95, 95, 4, 2, 92, 92, 94, 94, 3, 2, 20, 21, 3, 2, 17, 19, 4, 2, 52, 52, 91, 91, 3, 2, 113, 117, 4, 2, 124, 124, 129, 129, 3, 2, 109, 112, 4, 2, 93, 93, 96, 96, 3, 2, 118, 123, 3, 2, 125, 127, 3, 2, 130, 132, 3, 2, 134, 135, 3, 2, 101, 108, 9, 2, 62, 62, 70, 73, 77, 77, 82, 83, 96, 99, 109, 135, 147, 147, 3, 2, 44, 45, 3, 2, 26, 27, 4, 2, 7, 7, 29, 29, 2, 3661, 2, 335, 3, 2, 2, 2, 4, 360, 3, 2, 2, 2, 6, 386, 3, 2, 2, 2, 8, 422, 3, 2, 2, 2, 10, 427, 3, 2, 2, 2, 12, 430, 3, 2, 2, 2, 14, 440, 3, 2, 2, 2, 16, 443, 3, 2, 2, 2, 18, 448, 3, 2, 2, 2, 20, 527, 3, 2, 2, 2, 22, 531, 3, 2, 2, 2, 24, 569, 3, 2, 2, 2, 26, 605, 3, 2, 2, 2, 28, 628, 3, 2, 2, 2, 30, 643, 3, 2, 2, 2, 32, 645, 3, 2, 2, 2, 34, 650, 3, 2, 2, 2, 36, 667, 3, 2, 2, 2, 38, 689, 3, 2, 2, 2, 40, 696, 3, 2, 2, 2, 42, 698, 3, 2, 2, 2, 44, 708, 3, 2, 2, 2, 46, 759, 3, 2, 2, 2, 48, 761, 3, 2, 2, 2, 50, 795, 3, 2, 2, 2, 52, 831, 3, 2, 2, 2, 54, 853, 3, 2, 2, 2, 56, 930, 3, 2, 2, 2, 58, 968, 3, 2, 2, 2, 60, 987, 3, 2, 2, 2, 62, 1003, 3, 2, 2, 2, 64, 1029, 3, 2, 2, 2, 66, 1032, 3, 2, 2, 2, 68, 1068, 3, 2, 2, 2, 70, 1113, 3, 2, 2, 2, 72, 1226, 3, 2, 2, 2, 74, 1264, 3, 2, 2, 2, 76, 1290, 3, 2, 2, 2, 78, 1344, 3, 2, 2, 2, 80, 1394, 3, 2, 2, 2, 82, 1397, 3, 2, 2, 2, 84, 1431, 3, 2, 2, 2, 86, 1467, 3, 2, 2, 2, 88, 1493, 3, 2, 2, 2, 90, 1512, 3, 2, 2, 2, 92, 1515, 3, 2, 2, 2, 94, 1524, 3, 2, 2, 2, 96, 1536, 3, 2, 2, 2, 98, 1538, 3, 2, 2, 2, 100, 1556, 3, 2, 2, 2, 102, 1571, 3, 2, 2, 2, 104, 1587, 3, 2, 2, 2, 106, 1606, 3, 2, 2, 2, 108, 1613, 3, 2, 2, 2, 110, 1665, 3, 2, 2, 2, 112, 1667, 3, 2, 2, 2, 114, 1677, 3, 2, 2, 2, 116, 1718, 3, 2, 2, 2, 118, 1748, 3, 2, 2, 2, 120, 1767, 3, 2, 2, 2, 122, 1795, 3, 2, 2, 2, 124, 1801, 3, 2, 2, 2, 126, 1815, 3, 2, 2, 2, 128, 1837, 3, 2, 2, 2, 130, 1839, 3, 2, 2, 2, 132, 1841, 3, 2, 2, 2, 134, 1861, 3, 2, 2, 2, 136, 1881, 3, 2, 2, 2, 138, 1896, 3, 2, 2, 2, 140, 1908, 3, 2, 2, 2, 142, 1932, 3, 2, 2, 2, 144, 1953, 3, 2, 2, 2, 146, 1968, 3, 2, 2, 2, 148, 1982, 3, 2, 2, 2, 150, 1997, 3, 2, 2, 2, 152, 2012, 3, 2, 2, 2, 154, 2033, 3, 2, 2, 2, 156, 2047, 3, 2, 2, 2, 158, 2056, 3, 2, 2, 2, 160, 2063, 3, 2, 2, 2, 162, 2069, 3, 2, 2, 2, 164, 2071, 3, 2, 2, 2, 166, 2076, 3, 2, 2, 2, 168, 2078, 3, 2, 2, 2, 170, 2116, 3, 2, 2, 2, 172, 2142, 3, 2, 2, 2, 174, 2147, 3, 2, 2, 2, 176, 2204, 3, 2, 2, 2, 178, 2206, 3, 2, 2, 2, 180, 2246, 3, 2, 2, 2, 182, 2249, 3, 2, 2, 2, 184, 2261, 3, 2, 2, 2, 186, 2264, 3, 2, 2, 2, 188, 2313, 3, 2, 2, 2, 190, 2315, 3, 2, 2, 2, 192, 2374, 3, 2, 2, 2, 194, 2376, 3, 2, 2, 2, 196, 2380, 3, 2, 2, 2, 198, 2382, 3, 2, 2, 2, 200, 2392, 3, 2, 2, 2, 202, 2403, 3, 2, 2, 2, 204, 2405, 3, 2, 2, 2, 206, 2409, 3, 2, 2, 2, 208, 2411, 3, 2, 2, 2, 210, 2475, 3, 2, 2, 2, 212, 2477, 3, 2, 2, 2, 214, 2515, 3, 2, 2, 2, 216, 2517, 3, 2, 2, 2, 218, 2578, 3, 2, 2, 2, 220, 2612, 3, 2, 2, 2, 222, 2614, 3, 2, 2, 2, 224, 2640, 3, 2, 2, 2, 226, 2644, 3, 2, 2, 2, 228, 2740, 3, 2, 2, 2, 230, 2742, 3, 2, 2, 2, 232, 2843, 3, 2, 2, 2, 234, 2848, 3, 2, 2, 2, 236, 2850, 3, 2, 2, 2, 238, 2859, 3, 2, 2, 2, 240, 2868, 3, 2, 2, 2, 242, 2905, 3, 2, 2, 2, 244, 2931, 3, 2, 2, 2, 246, 2943, 3, 2, 2, 2, 248, 2945, 3, 2, 2, 2, 250, 3011, 3, 2, 2, 2, 252, 3013, 3, 2, 2, 2, 254, 3056, 3, 2, 2, 2, 256, 3059, 3, 2, 2, 2, 258, 3078, 3, 2, 2, 2, 260, 3080, 3, 2, 2, 2, 262, 3082, 3, 2, 2, 2, 264, 3084, 3, 2, 2, 2, 266, 3086, 3, 2, 2, 2, 268, 3088, 3, 2, 2, 2, 270, 3090, 3, 2, 2, 2, 272, 3092, 3, 2, 2, 2, 274, 3099, 3, 2, 2, 2, 276, 3105, 3, 2, 2, 2, 278, 3110, 3, 2, 2, 2, 280, 3114, 3, 2, 2, 2, 282, 3126, 3, 2, 2, 2, 284, 3134, 3, 2, 2, 2, 286, 3136, 3, 2, 2, 2, 288, 3138, 3, 2, 2, 2, 290, 3140, 3, 2, 2, 2, 292, 3142, 3, 2, 2, 2, 294, 3144, 3, 2, 2, 2, 296, 3146, 3, 2, 2, 2, 298, 3148, 3, 2, 2, 2, 300, 3150, 3, 2, 2, 2, 302, 3152, 3, 2, 2, 2, 304, 3154, 3, 2, 2, 2, 306, 3163, 3, 2, 2, 2, 308, 3189, 3, 2, 2, 2, 310, 3222, 3, 2, 2, 2, 312, 3224, 3, 2, 2, 2, 314, 3228, 3, 2, 2, 2, 316, 3230, 3, 2, 2, 2, 318, 3232, 3, 2, 2, 2, 320, 3246, 3, 2, 2, 2, 322, 3252, 3, 2, 2, 2, 324, 3254, 3, 2, 2, 2, 326, 3257, 3, 2, 2, 2, 328, 3260, 3, 2, 2, 2, 330, 3270, 3, 2, 2, 2, 332, 3278, 3, 2, 2, 2, 334, 336, 5, 320, 161, 2, 335, 334, 3, 2, 2, 2, 335, 336, 3, 2, 2, 2, 336, 340, 3, 2, 2, 2, 337, 339, 7, 7, 2, 2, 338, 337, 3, 2, 2, 2, 339, 342, 3, 2, 2, 2, 340, 338, 3, 2, 2, 2, 340, 341, 3, 2, 2, 2, 341, 346, 3, 2, 2, 2, 342, 340, 3, 2, 2, 2, 343, 345, 5, 6, 4, 2, 344, 343, 3, 2, 2, 2, 345, 348, 3, 2, 2, 2, 346, 344, 3, 2, 2, 2, 346, 347, 3, 2, 2, 2, 347, 349, 3, 2, 2, 2, 348, 346, 3, 2, 2, 2, 349, 350, 5, 8, 5, 2, 350, 354, 5, 10, 6, 2, 351, 353, 5, 16, 9, 2, 352, 351, 3, 2, 2, 2, 353, 356, 3, 2, 2, 2, 354, 352, 3, 2, 2, 2, 354, 355, 3, 2, 2, 2, 355, 357, 3, 2, 2, 2, 356, 354, 3, 2, 2, 2, 357, 358, 7, 2, 2, 3, 358, 3, 3, 2, 2, 2, 359, 361, 5, 320, 161, 2, 360, 359, 3, 2, 2, 2, 360, 361, 3, 2, 2, 2, 361, 365, 3, 2, 2, 2, 362, 364, 7, 7, 2, 2, 363, 362, 3, 2, 2, 2, 364, 367, 3, 2, 2, 2, 365, 363, 3, 2, 2, 2, 365, 366, 3, 2, 2, 2, 366, 371, 3, 2, 2, 2, 367, 365, 3, 2, 2, 2, 368, 370, 5, 6, 4, 2, 369, 368, 3, 2, 2, 2, 370, 373, 3, 2, 2, 2, 371, 369, 3, 2, 2, 2, 371, 372, 3, 2, 2, 2, 372, 374, 3, 2, 2, 2, 373, 371, 3, 2, 2, 2, 374, 375, 5, 8, 5, 2, 375, 381, 5, 10, 6, 2, 376, 377, 5, 124, 63, 2, 377, 378, 5, 330, 166, 2, 378, 380, 3, 2, 2, 2, 379, 376, 3, 2, 2, 2, 380, 383, 3, 2, 2, 2, 381, 379, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 384, 3, 2, 2, 2, 383, 381, 3, 2, 2, 2, 384, 385, 7, 2, 2, 3, 385, 5, 3, 2, 2, 2, 386, 390, 7, 100, 2, 2, 387, 389, 7, 7, 2, 2, 388, 387, 3, 2, 2, 2, 389, 392, 3, 2, 2, 2, 390, 388, 3, 2, 2, 2, 390, 391, 3, 2, 2, 2, 391, 393, 3, 2, 2, 2, 392, 390, 3, 2, 2, 2, 393, 397, 7, 28, 2, 2, 394, 396, 7, 7, 2, 2, 395, 394, 3, 2, 2, 2, 396, 399, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 397, 398, 3, 2, 2, 2, 398, 409, 3, 2, 2, 2, 399, 397, 3, 2, 2, 2, 400, 402, 7, 13, 2, 2, 401, 403, 5, 314, 158, 2, 402, 401, 3, 2, 2, 2, 403, 404, 3, 2, 2, 2, 404, 402, 3, 2, 2, 2, 404, 405, 3, 2, 2, 2, 405, 406, 3, 2, 2, 2, 406, 407, 7, 14, 2, 2, 407, 410, 3, 2, 2, 2, 408, 410, 5, 314, 158, 2, 409, 400, 3, 2, 2, 2, 409, 408, 3, 2, 2, 2, 410, 414, 3, 2, 2, 2, 411, 413, 7, 7, 2, 2, 412, 411, 3, 2, 2, 2, 413, 416, 3, 2, 2, 2, 414, 412, 3, 2, 2, 2, 414, 415, 3, 2, 2, 2, 415, 7, 3, 2, 2, 2, 416, 414, 3, 2, 2, 2, 417, 418, 7, 61, 2, 2, 418, 420, 5, 318, 160, 2, 419, 421, 5, 330, 166, 2, 420, 419, 3, 2, 2, 2, 420, 421, 3, 2, 2, 2, 421, 423, 3, 2, 2, 2, 422, 417, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 423, 9, 3, 2, 2, 2, 424, 426, 5, 12, 7, 2, 425, 424, 3, 2, 2, 2, 426, 429, 3, 2, 2, 2, 427, 425, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 11, 3, 2, 2, 2, 429, 427, 3, 2, 2, 2, 430, 431, 7, 62, 2, 2, 431, 435, 5, 318, 160, 2, 432, 433, 7, 9, 2, 2, 433, 436, 7, 17, 2, 2, 434, 436, 5, 14, 8, 2, 435, 432, 3, 2, 2, 2, 435, 434, 3, 2, 2, 2, 435, 436, 3, 2, 2, 2, 436, 438, 3, 2, 2, 2, 437, 439, 5, 330, 166, 2, 438, 437, 3, 2, 2, 2, 438, 439, 3, 2, 2, 2, 439, 13, 3, 2, 2, 2, 440, 441, 7, 91, 2, 2, 441, 442, 5, 316, 159, 2, 442, 15, 3, 2, 2, 2, 443, 445, 5, 126, 64, 2, 444, 446, 5, 332, 167, 2, 445, 444, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 17, 3, 2, 2, 2, 447, 449, 5, 280, 141, 2, 448, 447, 3, 2, 2, 2, 448, 449, 3, 2, 2, 2, 449, 450, 3, 2, 2, 2, 450, 454, 9, 2, 2, 2, 451, 453, 7, 7, 2, 2, 452, 451, 3, 2, 2, 2, 453, 456, 3, 2, 2, 2, 454, 452, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 457, 3, 2, 2, 2, 456, 454, 3, 2, 2, 2, 457, 465, 5, 316, 159, 2, 458, 460, 7, 7, 2, 2, 459, 458, 3, 2, 2, 2, 460, 463, 3, 2, 2, 2, 461, 459, 3, 2, 2, 2, 461, 462, 3, 2, 2, 2, 462, 464, 3, 2, 2, 2, 463, 461, 3, 2, 2, 2, 464, 466, 5, 84, 43, 2, 465, 461, 3, 2, 2, 2, 465, 466, 3, 2, 2, 2, 466, 474, 3, 2, 2, 2, 467, 469, 7, 7, 2, 2, 468, 467, 3, 2, 2, 2, 469, 472, 3, 2, 2, 2, 470, 468, 3, 2, 2, 2, 470, 471, 3, 2, 2, 2, 471, 473, 3, 2, 2, 2, 472, 470, 3, 2, 2, 2, 473, 475, 5, 20, 11, 2, 474, 470, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 490, 3, 2, 2, 2, 476, 478, 7, 7, 2, 2, 477, 476, 3, 2, 2, 2, 478, 481, 3, 2, 2, 2, 479, 477, 3, 2, 2, 2, 479, 480, 3, 2, 2, 2, 480, 482, 3, 2, 2, 2, 481, 479, 3, 2, 2, 2, 482, 486, 7, 28, 2, 2, 483, 485, 7, 7, 2, 2, 484, 483, 3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 484, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487, 489, 3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 489, 491, 5, 26, 14, 2, 490, 479, 3, 2, 2, 2, 490, 491, 3, 2, 2, 2, 491, 499, 3, 2, 2, 2, 492, 494, 7, 7, 2, 2, 493, 492, 3, 2, 2, 2, 494, 497, 3, 2, 2, 2, 495, 493, 3, 2, 2, 2, 495, 496, 3, 2, 2, 2, 496, 498, 3, 2, 2, 2, 497, 495, 3, 2, 2, 2, 498, 500, 5, 116, 59, 2, 499, 495, 3, 2, 2, 2, 499, 500, 3, 2, 2, 2, 500, 515, 3, 2, 2, 2, 501, 503, 7, 7, 2, 2, 502, 501, 3, 2, 2, 2, 503, 506, 3, 2, 2, 2, 504, 502, 3, 2, 2, 2, 504, 505, 3, 2, 2, 2, 505, 507, 3, 2, 2, 2, 506, 504, 3, 2, 2, 2, 507, 516, 5, 36, 19, 2, 508, 510, 7, 7, 2, 2, 509, 508, 3, 2, 2, 2, 510, 513, 3, 2, 2, 2, 511, 509, 3, 2, 2, 2, 511, 512, 3, 2, 2, 2, 512, 514, 3, 2, 2, 2, 513, 511, 3, 2, 2, 2, 514, 516, 5, 48, 25, 2, 515, 504, 3, 2, 2, 2, 515, 511, 3, 2, 2, 2, 515, 516, 3, 2, 2, 2, 516, 19, 3, 2, 2, 2, 517, 519, 5, 280, 141, 2, 518, 517, 3, 2, 2, 2, 518, 519, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 524, 7, 70, 2, 2, 521, 523, 7, 7, 2, 2, 522, 521, 3, 2, 2, 2, 523, 526, 3, 2, 2, 2, 524, 522, 3, 2, 2, 2, 524, 525, 3, 2, 2, 2, 525, 528, 3, 2, 2, 2, 526, 524, 3, 2, 2, 2, 527, 518, 3, 2, 2, 2, 527, 528, 3, 2, 2, 2, 528, 529, 3, 2, 2, 2, 529, 530, 5, 22, 12, 2, 530, 21, 3, 2, 2, 2, 531, 535, 7, 11, 2, 2, 532, 534, 7, 7, 2, 2, 533, 532, 3, 2, 2, 2, 534, 537, 3, 2, 2, 2, 535, 533, 3, 2, 2, 2, 535, 536, 3, 2, 2, 2, 536, 558, 3, 2, 2, 2, 537, 535, 3, 2, 2, 2, 538, 555, 5, 24, 13, 2, 539, 541, 7, 7, 2, 2, 540, 539, 3, 2, 2, 2, 541, 544, 3, 2, 2, 2, 542, 540, 3, 2, 2, 2, 542, 543, 3, 2, 2, 2, 543, 545, 3, 2, 2, 2, 544, 542, 3, 2, 2, 2, 545, 549, 7, 10, 2, 2, 546, 548, 7, 7, 2, 2, 547, 546, 3, 2, 2, 2, 548, 551, 3, 2, 2, 2, 549, 547, 3, 2, 2, 2, 549, 550, 3, 2, 2, 2, 550, 552, 3, 2, 2, 2, 551, 549, 3, 2, 2, 2, 552, 554, 5, 24, 13, 2, 553, 542, 3, 2, 2, 2, 554, 557, 3, 2, 2, 2, 555, 553, 3, 2, 2, 2, 555, 556, 3, 2, 2, 2, 556, 559, 3, 2, 2, 2, 557, 555, 3, 2, 2, 2, 558, 538, 3, 2, 2, 2, 558, 559, 3, 2, 2, 2, 559, 563, 3, 2, 2, 2, 560, 562, 7, 7, 2, 2, 561, 560, 3, 2, 2, 2, 562, 565, 3, 2, 2, 2, 563, 561, 3, 2, 2, 2, 563, 564, 3, 2, 2, 2, 564, 566, 3, 2, 2, 2, 565, 563, 3, 2, 2, 2, 566, 567, 7, 12, 2, 2, 567, 23, 3, 2, 2, 2, 568, 570, 5, 280, 141, 2, 569, 568, 3, 2, 2, 2, 569, 570, 3, 2, 2, 2, 570, 572, 3, 2, 2, 2, 571, 573, 9, 3, 2, 2, 572, 571, 3, 2, 2, 2, 572, 573, 3, 2, 2, 2, 573, 577, 3, 2, 2, 2, 574, 576, 7, 7, 2, 2, 575, 574, 3, 2, 2, 2, 576, 579, 3, 2, 2, 2, 577, 575, 3, 2, 2, 2, 577, 578, 3, 2, 2, 2, 578, 580, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 580, 581, 5, 316, 159, 2, 581, 585, 7, 28, 2, 2, 582, 584, 7, 7, 2, 2, 583, 582, 3, 2, 2, 2, 584, 587, 3, 2, 2, 2, 585, 583, 3, 2, 2, 2, 585, 586, 3, 2, 2, 2, 586, 588, 3, 2, 2, 2, 587, 585, 3, 2, 2, 2, 588, 603, 5, 92, 47, 2, 589, 591, 7, 7, 2, 2, 590, 589, 3, 2, 2, 2, 591, 594, 3, 2, 2, 2, 592, 590, 3, 2, 2, 2, 592, 593, 3, 2, 2, 2, 593, 595, 3, 2, 2, 2, 594, 592, 3, 2, 2, 2, 595, 599, 7, 30, 2, 2, 596, 598, 7, 7, 2, 2, 597, 596, 3, 2, 2, 2, 598, 601, 3, 2, 2, 2, 599, 597, 3, 2, 2, 2, 599, 600, 3, 2, 2, 2, 600, 602, 3, 2, 2, 2, 601, 599, 3, 2, 2, 2, 602, 604, 5, 130, 66, 2, 603, 592, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 25, 3, 2, 2, 2, 605, 622, 5, 28, 15, 2, 606, 608, 7, 7, 2, 2, 607, 606, 3, 2, 2, 2, 608, 611, 3, 2, 2, 2, 609, 607, 3, 2, 2, 2, 609, 610, 3, 2, 2, 2, 610, 612, 3, 2, 2, 2, 611, 609, 3, 2, 2, 2, 612, 616, 7, 10, 2, 2, 613, 615, 7, 7, 2, 2, 614, 613, 3, 2, 2, 2, 615, 618, 3, 2, 2, 2, 616, 614, 3, 2, 2, 2, 616, 617, 3, 2, 2, 2, 617, 619, 3, 2, 2, 2, 618, 616, 3, 2, 2, 2, 619, 621, 5, 28, 15, 2, 620, 609, 3, 2, 2, 2, 621, 624, 3, 2, 2, 2, 622, 620, 3, 2, 2, 2, 622, 623, 3, 2, 2, 2, 623, 27, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 625, 627, 5, 306, 154, 2, 626, 625, 3, 2, 2, 2, 627, 630, 3, 2, 2, 2, 628, 626, 3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 634, 3, 2, 2, 2, 630, 628, 3, 2, 2, 2, 631, 633, 7, 7, 2, 2, 632, 631, 3, 2, 2, 2, 633, 636, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 634, 635, 3, 2, 2, 2, 635, 637, 3, 2, 2, 2, 636, 634, 3, 2, 2, 2, 637, 638, 5, 30, 16, 2, 638, 29, 3, 2, 2, 2, 639, 644, 5, 32, 17, 2, 640, 644, 5, 34, 18, 2, 641, 644, 5, 108, 55, 2, 642, 644, 5, 104, 53, 2, 643, 639, 3, 2, 2, 2, 643, 640, 3, 2, 2, 2, 643, 641, 3, 2, 2, 2, 643, 642, 3, 2, 2, 2, 644, 31, 3, 2, 2, 2, 645, 646, 5, 108, 55, 2, 646, 647, 5, 176, 89, 2, 647, 33, 3, 2, 2, 2, 648, 651, 5, 108, 55, 2, 649, 651, 5, 104, 53, 2, 650, 648, 3, 2, 2, 2, 650, 649, 3, 2, 2, 2, 651, 655, 3, 2, 2, 2, 652, 654, 7, 7, 2, 2, 653, 652, 3, 2, 2, 2, 654, 657, 3, 2, 2, 2, 655, 653, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2, 656, 658, 3, 2, 2, 2, 657, 655, 3, 2, 2, 2, 658, 662, 7, 71, 2, 2, 659, 661, 7, 7, 2, 2, 660, 659, 3, 2, 2, 2, 661, 664, 3, 2, 2, 2, 662, 660, 3, 2, 2, 2, 662, 663, 3, 2, 2, 2, 663, 665, 3, 2, 2, 2, 664, 662, 3, 2, 2, 2, 665, 666, 5, 130, 66, 2, 666, 35, 3, 2, 2, 2, 667, 671, 7, 15, 2, 2, 668, 670, 7, 7, 2, 2, 669, 668, 3, 2, 2, 2, 670, 673, 3, 2, 2, 2, 671, 669, 3, 2, 2, 2, 671, 672, 3, 2, 2, 2, 672, 674, 3, 2, 2, 2, 673, 671, 3, 2, 2, 2, 674, 678, 5, 38, 20, 2, 675, 677, 7, 7, 2, 2, 676, 675, 3, 2, 2, 2, 677, 680, 3, 2, 2, 2, 678, 676, 3, 2, 2, 2, 678, 679, 3, 2, 2, 2, 679, 681, 3, 2, 2, 2, 680, 678, 3, 2, 2, 2, 681, 682, 7, 16, 2, 2, 682, 37, 3, 2, 2, 2, 683, 685, 5, 40, 21, 2, 684, 686, 5, 332, 167, 2, 685, 684, 3, 2, 2, 2, 685, 686, 3, 2, 2, 2, 686, 688, 3, 2, 2, 2, 687, 683, 3, 2, 2, 2, 688, 691, 3, 2, 2, 2, 689, 687, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 39, 3, 2, 2, 2, 691, 689, 3, 2, 2, 2, 692, 697, 5, 126, 64, 2, 693, 697, 5, 68, 35, 2, 694, 697, 5, 42, 22, 2, 695, 697, 5, 44, 23, 2, 696, 692, 3, 2, 2, 2, 696, 693, 3, 2, 2, 2, 696, 694, 3, 2, 2, 2, 696, 695, 3, 2, 2, 2, 697, 41, 3, 2, 2, 2, 698, 702, 7, 73, 2, 2, 699, 701, 7, 7, 2, 2, 700, 699, 3, 2, 2, 2, 701, 704, 3, 2, 2, 2, 702, 700, 3, 2, 2, 2, 702, 703, 3, 2, 2, 2, 703, 705, 3, 2, 2, 2, 704, 702, 3, 2, 2, 2, 705, 706, 5, 120, 61, 2, 706, 43, 3, 2, 2, 2, 707, 709, 5, 280, 141, 2, 708, 707, 3, 2, 2, 2, 708, 709, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 714, 7, 70, 2, 2, 711, 713, 7, 7, 2, 2, 712, 711, 3, 2, 2, 2, 713, 716, 3, 2, 2, 2, 714, 712, 3, 2, 2, 2, 714, 715, 3, 2, 2, 2, 715, 717, 3, 2, 2, 2, 716, 714, 3, 2, 2, 2, 717, 732, 5, 56, 29, 2, 718, 720, 7, 7, 2, 2, 719, 718, 3, 2, 2, 2, 720, 723, 3, 2, 2, 2, 721, 719, 3, 2, 2, 2, 721, 722, 3, 2, 2, 2, 722, 724, 3, 2, 2, 2, 723, 721, 3, 2, 2, 2, 724, 728, 7, 28, 2, 2, 725, 727, 7, 7, 2, 2, 726, 725, 3, 2, 2, 2, 727, 730, 3, 2, 2, 2, 728, 726, 3, 2, 2, 2, 728, 729, 3, 2, 2, 2, 729, 731, 3, 2, 2, 2, 730, 728, 3, 2, 2, 2, 731, 733, 5, 46, 24, 2, 732, 721, 3, 2, 2, 2, 732, 733, 3, 2, 2, 2, 733, 737, 3, 2, 2, 2, 734, 736, 7, 7, 2, 2, 735, 734, 3, 2, 2, 2, 736, 739, 3, 2, 2, 2, 737, 735, 3, 2, 2, 2, 737, 738, 3, 2, 2, 2, 738, 741, 3, 2, 2, 2, 739, 737, 3, 2, 2, 2, 740, 742, 5, 120, 61, 2, 741, 740, 3, 2, 2, 2, 741, 742, 3, 2, 2, 2, 742, 45, 3, 2, 2, 2, 743, 747, 7, 74, 2, 2, 744, 746, 7, 7, 2, 2, 745, 744, 3, 2, 2, 2, 746, 749, 3, 2, 2, 2, 747, 745, 3, 2, 2, 2, 747, 748, 3, 2, 2, 2, 748, 750, 3, 2, 2, 2, 749, 747, 3, 2, 2, 2, 750, 760, 5, 176, 89, 2, 751, 755, 7, 75, 2, 2, 752, 754, 7, 7, 2, 2, 753, 752, 3, 2, 2, 2, 754, 757, 3, 2, 2, 2, 755, 753, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 758, 3, 2, 2, 2, 757, 755, 3, 2, 2, 2, 758, 760, 5, 176, 89, 2, 759, 743, 3, 2, 2, 2, 759, 751, 3, 2, 2, 2, 760, 47, 3, 2, 2, 2, 761, 765, 7, 15, 2, 2, 762, 764, 7, 7, 2, 2, 763, 762, 3, 2, 2, 2, 764, 767, 3, 2, 2, 2, 765, 763, 3, 2, 2, 2, 765, 766, 3, 2, 2, 2, 766, 769, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 768, 770, 5, 50, 26, 2, 769, 768, 3, 2, 2, 2, 769, 770, 3, 2, 2, 2, 770, 785, 3, 2, 2, 2, 771, 773, 7, 7, 2, 2, 772, 771, 3, 2, 2, 2, 773, 776, 3, 2, 2, 2, 774, 772, 3, 2, 2, 2, 774, 775, 3, 2, 2, 2, 775, 777, 3, 2, 2, 2, 776, 774, 3, 2, 2, 2, 777, 781, 7, 29, 2, 2, 778, 780, 7, 7, 2, 2, 779, 778, 3, 2, 2, 2, 780, 783, 3, 2, 2, 2, 781, 779, 3, 2, 2, 2, 781, 782, 3, 2, 2, 2, 782, 784, 3, 2, 2, 2, 783, 781, 3, 2, 2, 2, 784, 786, 5, 38, 20, 2, 785, 774, 3, 2, 2, 2, 785, 786, 3, 2, 2, 2, 786, 790, 3, 2, 2, 2, 787, 789, 7, 7, 2, 2, 788, 787, 3, 2, 2, 2, 789, 792, 3, 2, 2, 2, 790, 788, 3, 2, 2, 2, 790, 791, 3, 2, 2, 2, 791, 793, 3, 2, 2, 2, 792, 790, 3, 2, 2, 2, 793, 794, 7, 16, 2, 2, 794, 49, 3, 2, 2, 2, 795, 812, 5, 52, 27, 2, 796, 798, 7, 7, 2, 2, 797, 796, 3, 2, 2, 2, 798, 801, 3, 2, 2, 2, 799, 797, 3, 2, 2, 2, 799, 800, 3, 2, 2, 2, 800, 802, 3, 2, 2, 2, 801, 799, 3, 2, 2, 2, 802, 806, 7, 10, 2, 2, 803, 805, 7, 7, 2, 2, 804, 803, 3, 2, 2, 2, 805, 808, 3, 2, 2, 2, 806, 804, 3, 2, 2, 2, 806, 807, 3, 2, 2, 2, 807, 809, 3, 2, 2, 2, 808, 806, 3, 2, 2, 2, 809, 811, 5, 52, 27, 2, 810, 799, 3, 2, 2, 2, 811, 814, 3, 2, 2, 2, 812, 810, 3, 2, 2, 2, 812, 813, 3, 2, 2, 2, 813, 818, 3, 2, 2, 2, 814, 812, 3, 2, 2, 2, 815, 817, 7, 7, 2, 2, 816, 815, 3, 2, 2, 2, 817, 820, 3, 2, 2, 2, 818, 816, 3, 2, 2, 2, 818, 819, 3, 2, 2, 2, 819, 822, 3, 2, 2, 2, 820, 818, 3, 2, 2, 2, 821, 823, 7, 10, 2, 2, 822, 821, 3, 2, 2, 2, 822, 823, 3, 2, 2, 2, 823, 51, 3, 2, 2, 2, 824, 828, 5, 280, 141, 2, 825, 827, 7, 7, 2, 2, 826, 825, 3, 2, 2, 2, 827, 830, 3, 2, 2, 2, 828, 826, 3, 2, 2, 2, 828, 829, 3, 2, 2, 2, 829, 832, 3, 2, 2, 2, 830, 828, 3, 2, 2, 2, 831, 824, 3, 2, 2, 2, 831, 832, 3, 2, 2, 2, 832, 833, 3, 2, 2, 2, 833, 841, 5, 316, 159, 2, 834, 836, 7, 7, 2, 2, 835, 834, 3, 2, 2, 2, 836, 839, 3, 2, 2, 2, 837, 835, 3, 2, 2, 2, 837, 838, 3, 2, 2, 2, 838, 840, 3, 2, 2, 2, 839, 837, 3, 2, 2, 2, 840, 842, 5, 176, 89, 2, 841, 837, 3, 2, 2, 2, 841, 842, 3, 2, 2, 2, 842, 850, 3, 2, 2, 2, 843, 845, 7, 7, 2, 2, 844, 843, 3, 2, 2, 2, 845, 848, 3, 2, 2, 2, 846, 844, 3, 2, 2, 2, 846, 847, 3, 2, 2, 2, 847, 849, 3, 2, 2, 2, 848, 846, 3, 2, 2, 2, 849, 851, 5, 36, 19, 2, 850, 846, 3, 2, 2, 2, 850, 851, 3, 2, 2, 2, 851, 53, 3, 2, 2, 2, 852, 854, 5, 280, 141, 2, 853, 852, 3, 2, 2, 2, 853, 854, 3, 2, 2, 2, 854, 855, 3, 2, 2, 2, 855, 863, 7, 65, 2, 2, 856, 858, 7, 7, 2, 2, 857, 856, 3, 2, 2, 2, 858, 861, 3, 2, 2, 2, 859, 857, 3, 2, 2, 2, 859, 860, 3, 2, 2, 2, 860, 862, 3, 2, 2, 2, 861, 859, 3, 2, 2, 2, 862, 864, 5, 84, 43, 2, 863, 859, 3, 2, 2, 2, 863, 864, 3, 2, 2, 2, 864, 880, 3, 2, 2, 2, 865, 867, 7, 7, 2, 2, 866, 865, 3, 2, 2, 2, 867, 870, 3, 2, 2, 2, 868, 866, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 871, 3, 2, 2, 2, 870, 868, 3, 2, 2, 2, 871, 875, 5, 106, 54, 2, 872, 874, 7, 7, 2, 2, 873, 872, 3, 2, 2, 2, 874, 877, 3, 2, 2, 2, 875, 873, 3, 2, 2, 2, 875, 876, 3, 2, 2, 2, 876, 878, 3, 2, 2, 2, 877, 875, 3, 2, 2, 2, 878, 879, 7, 9, 2, 2, 879, 881, 3, 2, 2, 2, 880, 868, 3, 2, 2, 2, 880, 881, 3, 2, 2, 2, 881, 885, 3, 2, 2, 2, 882, 884, 7, 7, 2, 2, 883, 882, 3, 2, 2, 2, 884, 887, 3, 2, 2, 2, 885, 883, 3, 2, 2, 2, 885, 886, 3, 2, 2, 2, 886, 888, 3, 2, 2, 2, 887, 885, 3, 2, 2, 2, 888, 892, 5, 316, 159, 2, 889, 891, 7, 7, 2, 2, 890, 889, 3, 2, 2, 2, 891, 894, 3, 2, 2, 2, 892, 890, 3, 2, 2, 2, 892, 893, 3, 2, 2, 2, 893, 895, 3, 2, 2, 2, 894, 892, 3, 2, 2, 2, 895, 910, 5, 56, 29, 2, 896, 898, 7, 7, 2, 2, 897, 896, 3, 2, 2, 2, 898, 901, 3, 2, 2, 2, 899, 897, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 902, 3, 2, 2, 2, 901, 899, 3, 2, 2, 2, 902, 906, 7, 28, 2, 2, 903, 905, 7, 7, 2, 2, 904, 903, 3, 2, 2, 2, 905, 908, 3, 2, 2, 2, 906, 904, 3, 2, 2, 2, 906, 907, 3, 2, 2, 2, 907, 909, 3, 2, 2, 2, 908, 906, 3, 2, 2, 2, 909, 911, 5, 92, 47, 2, 910, 899, 3, 2, 2, 2, 910, 911, 3, 2, 2, 2, 911, 919, 3, 2, 2, 2, 912, 914, 7, 7, 2, 2, 913, 912, 3, 2, 2, 2, 914, 917, 3, 2, 2, 2, 915, 913, 3, 2, 2, 2, 915, 916, 3, 2, 2, 2, 916, 918, 3, 2, 2, 2, 917, 915, 3, 2, 2, 2, 918, 920, 5, 116, 59, 2, 919, 915, 3, 2, 2, 2, 919, 920, 3, 2, 2, 2, 920, 928, 3, 2, 2, 2, 921, 923, 7, 7, 2, 2, 922, 921, 3, 2, 2, 2, 923, 926, 3, 2, 2, 2, 924, 922, 3, 2, 2, 2, 924, 925, 3, 2, 2, 2, 925, 927, 3, 2, 2, 2, 926, 924, 3, 2, 2, 2, 927, 929, 5, 64, 33, 2, 928, 924, 3, 2, 2, 2, 928, 929, 3, 2, 2, 2, 929, 55, 3, 2, 2, 2, 930, 934, 7, 11, 2, 2, 931, 933, 7, 7, 2, 2, 932, 931, 3, 2, 2, 2, 933, 936, 3, 2, 2, 2, 934, 932, 3, 2, 2, 2, 934, 935, 3, 2, 2, 2, 935, 957, 3, 2, 2, 2, 936, 934, 3, 2, 2, 2, 937, 954, 5, 58, 30, 2, 938, 940, 7, 7, 2, 2, 939, 938, 3, 2, 2, 2, 940, 943, 3, 2, 2, 2, 941, 939, 3, 2, 2, 2, 941, 942, 3, 2, 2, 2, 942, 944, 3, 2, 2, 2, 943, 941, 3, 2, 2, 2, 944, 948, 7, 10, 2, 2, 945, 947, 7, 7, 2, 2, 946, 945, 3, 2, 2, 2, 947, 950, 3, 2, 2, 2, 948, 946, 3, 2, 2, 2, 948, 949, 3, 2, 2, 2, 949, 951, 3, 2, 2, 2, 950, 948, 3, 2, 2, 2, 951, 953, 5, 58, 30, 2, 952, 941, 3, 2, 2, 2, 953, 956, 3, 2, 2, 2, 954, 952, 3, 2, 2, 2, 954, 955, 3, 2, 2, 2, 955, 958, 3, 2, 2, 2, 956, 954, 3, 2, 2, 2, 957, 937, 3, 2, 2, 2, 957, 958, 3, 2, 2, 2, 958, 962, 3, 2, 2, 2, 959, 961, 7, 7, 2, 2, 960, 959, 3, 2, 2, 2, 961, 964, 3, 2, 2, 2, 962, 960, 3, 2, 2, 2, 962, 963, 3, 2, 2, 2, 963, 965, 3, 2, 2, 2, 964, 962, 3, 2, 2, 2, 965, 966, 7, 12, 2, 2, 966, 57, 3, 2, 2, 2, 967, 969, 5, 280, 141, 2, 968, 967, 3, 2, 2, 2, 968, 969, 3, 2, 2, 2, 969, 970, 3, 2, 2, 2, 970, 985, 5, 60, 31, 2, 971, 973, 7, 7, 2, 2, 972, 971, 3, 2, 2, 2, 973, 976, 3, 2, 2, 2, 974, 972, 3, 2, 2, 2, 974, 975, 3, 2, 2, 2, 975, 977, 3, 2, 2, 2, 976, 974, 3, 2, 2, 2, 977, 981, 7, 30, 2, 2, 978, 980, 7, 7, 2, 2, 979, 978, 3, 2, 2, 2, 980, 983, 3, 2, 2, 2, 981, 979, 3, 2, 2, 2, 981, 982, 3, 2, 2, 2, 982, 984, 3, 2, 2, 2, 983, 981, 3, 2, 2, 2, 984, 986, 5, 130, 66, 2, 985, 974, 3, 2, 2, 2, 985, 986, 3, 2, 2, 2, 986, 59, 3, 2, 2, 2, 987, 991, 5, 316, 159, 2, 988, 990, 7, 7, 2, 2, 989, 988, 3, 2, 2, 2, 990, 993, 3, 2, 2, 2, 991, 989, 3, 2, 2, 2, 991, 992, 3, 2, 2, 2, 992, 994, 3, 2, 2, 2, 993, 991, 3, 2, 2, 2, 994, 998, 7, 28, 2, 2, 995, 997, 7, 7, 2, 2, 996, 995, 3, 2, 2, 2, 997, 1000, 3, 2, 2, 2, 998, 996, 3, 2, 2, 2, 998, 999, 3, 2, 2, 2, 999, 1001, 3, 2, 2, 2, 1000, 998, 3, 2, 2, 2, 1001, 1002, 5, 92, 47, 2, 1002, 61, 3, 2, 2, 2, 1003, 1007, 5, 316, 159, 2, 1004, 1006, 7, 7, 2, 2, 1005, 1004, 3, 2, 2, 2, 1006, 1009, 3, 2, 2, 2, 1007, 1005, 3, 2, 2, 2, 1007, 1008, 3, 2, 2, 2, 1008, 1018, 3, 2, 2, 2, 1009, 1007, 3, 2, 2, 2, 1010, 1014, 7, 28, 2, 2, 1011, 1013, 7, 7, 2, 2, 1012, 1011, 3, 2, 2, 2, 1013, 1016, 3, 2, 2, 2, 1014, 1012, 3, 2, 2, 2, 1014, 1015, 3, 2, 2, 2, 1015, 1017, 3, 2, 2, 2, 1016, 1014, 3, 2, 2, 2, 1017, 1019, 5, 92, 47, 2, 1018, 1010, 3, 2, 2, 2, 1018, 1019, 3, 2, 2, 2, 1019, 63, 3, 2, 2, 2, 1020, 1030, 5, 120, 61, 2, 1021, 1025, 7, 30, 2, 2, 1022, 1024, 7, 7, 2, 2, 1023, 1022, 3, 2, 2, 2, 1024, 1027, 3, 2, 2, 2, 1025, 1023, 3, 2, 2, 2, 1025, 1026, 3, 2, 2, 2, 1026, 1028, 3, 2, 2, 2, 1027, 1025, 3, 2, 2, 2, 1028, 1030, 5, 130, 66, 2, 1029, 1020, 3, 2, 2, 2, 1029, 1021, 3, 2, 2, 2, 1030, 65, 3, 2, 2, 2, 1031, 1033, 5, 280, 141, 2, 1032, 1031, 3, 2, 2, 2, 1032, 1033, 3, 2, 2, 2, 1033, 1034, 3, 2, 2, 2, 1034, 1038, 7, 66, 2, 2, 1035, 1037, 7, 7, 2, 2, 1036, 1035, 3, 2, 2, 2, 1037, 1040, 3, 2, 2, 2, 1038, 1036, 3, 2, 2, 2, 1038, 1039, 3, 2, 2, 2, 1039, 1041, 3, 2, 2, 2, 1040, 1038, 3, 2, 2, 2, 1041, 1056, 5, 316, 159, 2, 1042, 1044, 7, 7, 2, 2, 1043, 1042, 3, 2, 2, 2, 1044, 1047, 3, 2, 2, 2, 1045, 1043, 3, 2, 2, 2, 1045, 1046, 3, 2, 2, 2, 1046, 1048, 3, 2, 2, 2, 1047, 1045, 3, 2, 2, 2, 1048, 1052, 7, 28, 2, 2, 1049, 1051, 7, 7, 2, 2, 1050, 1049, 3, 2, 2, 2, 1051, 1054, 3, 2, 2, 2, 1052, 1050, 3, 2, 2, 2, 1052, 1053, 3, 2, 2, 2, 1053, 1055, 3, 2, 2, 2, 1054, 1052, 3, 2, 2, 2, 1055, 1057, 5, 26, 14, 2, 1056, 1045, 3, 2, 2, 2, 1056, 1057, 3, 2, 2, 2, 1057, 1065, 3, 2, 2, 2, 1058, 1060, 7, 7, 2, 2, 1059, 1058, 3, 2, 2, 2, 1060, 1063, 3, 2, 2, 2, 1061, 1059, 3, 2, 2, 2, 1061, 1062, 3, 2, 2, 2, 1062, 1064, 3, 2, 2, 2, 1063, 1061, 3, 2, 2, 2, 1064, 1066, 5, 36, 19, 2, 1065, 1061, 3, 2, 2, 2, 1065, 1066, 3, 2, 2, 2, 1066, 67, 3, 2, 2, 2, 1067, 1069, 5, 280, 141, 2, 1068, 1067, 3, 2, 2, 2, 1068, 1069, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070, 1074, 7, 72, 2, 2, 1071, 1073, 7, 7, 2, 2, 1072, 1071, 3, 2, 2, 2, 1073, 1076, 3, 2, 2, 2, 1074, 1072, 3, 2, 2, 2, 1074, 1075, 3, 2, 2, 2, 1075, 1077, 3, 2, 2, 2, 1076, 1074, 3, 2, 2, 2, 1077, 1085, 7, 66, 2, 2, 1078, 1080, 7, 7, 2, 2, 1079, 1078, 3, 2, 2, 2, 1080, 1083, 3, 2, 2, 2, 1081, 1079, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 1084, 3, 2, 2, 2, 1083, 1081, 3, 2, 2, 2, 1084, 1086, 5, 316, 159, 2, 1085, 1081, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086, 1101, 3, 2, 2, 2, 1087, 1089, 7, 7, 2, 2, 1088, 1087, 3, 2, 2, 2, 1089, 1092, 3, 2, 2, 2, 1090, 1088, 3, 2, 2, 2, 1090, 1091, 3, 2, 2, 2, 1091, 1093, 3, 2, 2, 2, 1092, 1090, 3, 2, 2, 2, 1093, 1097, 7, 28, 2, 2, 1094, 1096, 7, 7, 2, 2, 1095, 1094, 3, 2, 2, 2, 1096, 1099, 3, 2, 2, 2, 1097, 1095, 3, 2, 2, 2, 1097, 1098, 3, 2, 2, 2, 1098, 1100, 3, 2, 2, 2, 1099, 1097, 3, 2, 2, 2, 1100, 1102, 5, 26, 14, 2, 1101, 1090, 3, 2, 2, 2, 1101, 1102, 3, 2, 2, 2, 1102, 1110, 3, 2, 2, 2, 1103, 1105, 7, 7, 2, 2, 1104, 1103, 3, 2, 2, 2, 1105, 1108, 3, 2, 2, 2, 1106, 1104, 3, 2, 2, 2, 1106, 1107, 3, 2, 2, 2, 1107, 1109, 3, 2, 2, 2, 1108, 1106, 3, 2, 2, 2, 1109, 1111, 5, 36, 19, 2, 1110, 1106, 3, 2, 2, 2, 1110, 1111, 3, 2, 2, 2, 1111, 69, 3, 2, 2, 2, 1112, 1114, 5, 280, 141, 2, 1113, 1112, 3, 2, 2, 2, 1113, 1114, 3, 2, 2, 2, 1114, 1115, 3, 2, 2, 2, 1115, 1123, 9, 3, 2, 2, 1116, 1118, 7, 7, 2, 2, 1117, 1116, 3, 2, 2, 2, 1118, 1121, 3, 2, 2, 2, 1119, 1117, 3, 2, 2, 2, 1119, 1120, 3, 2, 2, 2, 1120, 1122, 3, 2, 2, 2, 1121, 1119, 3, 2, 2, 2, 1122, 1124, 5, 84, 43, 2, 1123, 1119, 3, 2, 2, 2, 1123, 1124, 3, 2, 2, 2, 1124, 1140, 3, 2, 2, 2, 1125, 1127, 7, 7, 2, 2, 1126, 1125, 3, 2, 2, 2, 1127, 1130, 3, 2, 2, 2, 1128, 1126, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1131, 3, 2, 2, 2, 1130, 1128, 3, 2, 2, 2, 1131, 1135, 5, 106, 54, 2, 1132, 1134, 7, 7, 2, 2, 1133, 1132, 3, 2, 2, 2, 1134, 1137, 3, 2, 2, 2, 1135, 1133, 3, 2, 2, 2, 1135, 1136, 3, 2, 2, 2, 1136, 1138, 3, 2, 2, 2, 1137, 1135, 3, 2, 2, 2, 1138, 1139, 7, 9, 2, 2, 1139, 1141, 3, 2, 2, 2, 1140, 1128, 3, 2, 2, 2, 1140, 1141, 3, 2, 2, 2, 1141, 1145, 3, 2, 2, 2, 1142, 1144, 7, 7, 2, 2, 1143, 1142, 3, 2, 2, 2, 1144, 1147, 3, 2, 2, 2, 1145, 1143, 3, 2, 2, 2, 1145, 1146, 3, 2, 2, 2, 1146, 1150, 3, 2, 2, 2, 1147, 1145, 3, 2, 2, 2, 1148, 1151, 5, 72, 37, 2, 1149, 1151, 5, 74, 38, 2, 1150, 1148, 3, 2, 2, 2, 1150, 1149, 3, 2, 2, 2, 1151, 1159, 3, 2, 2, 2, 1152, 1154, 7, 7, 2, 2, 1153, 1152, 3, 2, 2, 2, 1154, 1157, 3, 2, 2, 2, 1155, 1153, 3, 2, 2, 2, 1155, 1156, 3, 2, 2, 2, 1156, 1158, 3, 2, 2, 2, 1157, 1155, 3, 2, 2, 2, 1158, 1160, 5, 116, 59, 2, 1159, 1155, 3, 2, 2, 2, 1159, 1160, 3, 2, 2, 2, 1160, 1178, 3, 2, 2, 2, 1161, 1163, 7, 7, 2, 2, 1162, 1161, 3, 2, 2, 2, 1163, 1166, 3, 2, 2, 2, 1164, 1162, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1176, 3, 2, 2, 2, 1166, 1164, 3, 2, 2, 2, 1167, 1171, 7, 30, 2, 2, 1168, 1170, 7, 7, 2, 2, 1169, 1168, 3, 2, 2, 2, 1170, 1173, 3, 2, 2, 2, 1171, 1169, 3, 2, 2, 2, 1171, 1172, 3, 2, 2, 2, 1172, 1174, 3, 2, 2, 2, 1173, 1171, 3, 2, 2, 2, 1174, 1177, 5, 130, 66, 2, 1175, 1177, 5, 76, 39, 2, 1176, 1167, 3, 2, 2, 2, 1176, 1175, 3, 2, 2, 2, 1177, 1179, 3, 2, 2, 2, 1178, 1164, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1186, 3, 2, 2, 2, 1180, 1182, 7, 7, 2, 2, 1181, 1180, 3, 2, 2, 2, 1182, 1183, 3, 2, 2, 2, 1183, 1181, 3, 2, 2, 2, 1183, 1184, 3, 2, 2, 2, 1184, 1185, 3, 2, 2, 2, 1185, 1187, 7, 29, 2, 2, 1186, 1181, 3, 2, 2, 2, 1186, 1187, 3, 2, 2, 2, 1187, 1191, 3, 2, 2, 2, 1188, 1190, 7, 7, 2, 2, 1189, 1188, 3, 2, 2, 2, 1190, 1193, 3, 2, 2, 2, 1191, 1189, 3, 2, 2, 2, 1191, 1192, 3, 2, 2, 2, 1192, 1224, 3, 2, 2, 2, 1193, 1191, 3, 2, 2, 2, 1194, 1196, 5, 78, 40, 2, 1195, 1194, 3, 2, 2, 2, 1195, 1196, 3, 2, 2, 2, 1196, 1207, 3, 2, 2, 2, 1197, 1199, 7, 7, 2, 2, 1198, 1197, 3, 2, 2, 2, 1199, 1202, 3, 2, 2, 2, 1200, 1198, 3, 2, 2, 2, 1200, 1201, 3, 2, 2, 2, 1201, 1204, 3, 2, 2, 2, 1202, 1200, 3, 2, 2, 2, 1203, 1205, 5, 330, 166, 2, 1204, 1203, 3, 2, 2, 2, 1204, 1205, 3, 2, 2, 2, 1205, 1206, 3, 2, 2, 2, 1206, 1208, 5, 80, 41, 2, 1207, 1200, 3, 2, 2, 2, 1207, 1208, 3, 2, 2, 2, 1208, 1225, 3, 2, 2, 2, 1209, 1211, 5, 80, 41, 2, 1210, 1209, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1222, 3, 2, 2, 2, 1212, 1214, 7, 7, 2, 2, 1213, 1212, 3, 2, 2, 2, 1214, 1217, 3, 2, 2, 2, 1215, 1213, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216, 1219, 3, 2, 2, 2, 1217, 1215, 3, 2, 2, 2, 1218, 1220, 5, 330, 166, 2, 1219, 1218, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 1223, 5, 78, 40, 2, 1222, 1215, 3, 2, 2, 2, 1222, 1223, 3, 2, 2, 2, 1223, 1225, 3, 2, 2, 2, 1224, 1195, 3, 2, 2, 2, 1224, 1210, 3, 2, 2, 2, 1225, 71, 3, 2, 2, 2, 1226, 1230, 7, 11, 2, 2, 1227, 1229, 7, 7, 2, 2, 1228, 1227, 3, 2, 2, 2, 1229, 1232, 3, 2, 2, 2, 1230, 1228, 3, 2, 2, 2, 1230, 1231, 3, 2, 2, 2, 1231, 1233, 3, 2, 2, 2, 1232, 1230, 3, 2, 2, 2, 1233, 1250, 5, 74, 38, 2, 1234, 1236, 7, 7, 2, 2, 1235, 1234, 3, 2, 2, 2, 1236, 1239, 3, 2, 2, 2, 1237, 1235, 3, 2, 2, 2, 1237, 1238, 3, 2, 2, 2, 1238, 1240, 3, 2, 2, 2, 1239, 1237, 3, 2, 2, 2, 1240, 1244, 7, 10, 2, 2, 1241, 1243, 7, 7, 2, 2, 1242, 1241, 3, 2, 2, 2, 1243, 1246, 3, 2, 2, 2, 1244, 1242, 3, 2, 2, 2, 1244, 1245, 3, 2, 2, 2, 1245, 1247, 3, 2, 2, 2, 1246, 1244, 3, 2, 2, 2, 1247, 1249, 5, 74, 38, 2, 1248, 1237, 3, 2, 2, 2, 1249, 1252, 3, 2, 2, 2, 1250, 1248, 3, 2, 2, 2, 1250, 1251, 3, 2, 2, 2, 1251, 1256, 3, 2, 2, 2, 1252, 1250, 3, 2, 2, 2, 1253, 1255, 7, 7, 2, 2, 1254, 1253, 3, 2, 2, 2, 1255, 1258, 3, 2, 2, 2, 1256, 1254, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1259, 3, 2, 2, 2, 1258, 1256, 3, 2, 2, 2, 1259, 1260, 7, 12, 2, 2, 1260, 73, 3, 2, 2, 2, 1261, 1263, 5, 306, 154, 2, 1262, 1261, 3, 2, 2, 2, 1263, 1266, 3, 2, 2, 2, 1264, 1262, 3, 2, 2, 2, 1264, 1265, 3, 2, 2, 2, 1265, 1270, 3, 2, 2, 2, 1266, 1264, 3, 2, 2, 2, 1267, 1269, 7, 7, 2, 2, 1268, 1267, 3, 2, 2, 2, 1269, 1272, 3, 2, 2, 2, 1270, 1268, 3, 2, 2, 2, 1270, 1271, 3, 2, 2, 2, 1271, 1273, 3, 2, 2, 2, 1272, 1270, 3, 2, 2, 2, 1273, 1288, 5, 316, 159, 2, 1274, 1276, 7, 7, 2, 2, 1275, 1274, 3, 2, 2, 2, 1276, 1279, 3, 2, 2, 2, 1277, 1275, 3, 2, 2, 2, 1277, 1278, 3, 2, 2, 2, 1278, 1280, 3, 2, 2, 2, 1279, 1277, 3, 2, 2, 2, 1280, 1284, 7, 28, 2, 2, 1281, 1283, 7, 7, 2, 2, 1282, 1281, 3, 2, 2, 2, 1283, 1286, 3, 2, 2, 2, 1284, 1282, 3, 2, 2, 2, 1284, 1285, 3, 2, 2, 2, 1285, 1287, 3, 2, 2, 2, 1286, 1284, 3, 2, 2, 2, 1287, 1289, 5, 92, 47, 2, 1288, 1277, 3, 2, 2, 2, 1288, 1289, 3, 2, 2, 2, 1289, 75, 3, 2, 2, 2, 1290, 1294, 7, 71, 2, 2, 1291, 1293, 7, 7, 2, 2, 1292, 1291, 3, 2, 2, 2, 1293, 1296, 3, 2, 2, 2, 1294, 1292, 3, 2, 2, 2, 1294, 1295, 3, 2, 2, 2, 1295, 1297, 3, 2, 2, 2, 1296, 1294, 3, 2, 2, 2, 1297, 1298, 5, 130, 66, 2, 1298, 77, 3, 2, 2, 2, 1299, 1301, 5, 280, 141, 2, 1300, 1299, 3, 2, 2, 2, 1300, 1301, 3, 2, 2, 2, 1301, 1302, 3, 2, 2, 2, 1302, 1345, 7, 97, 2, 2, 1303, 1305, 5, 280, 141, 2, 1304, 1303, 3, 2, 2, 2, 1304, 1305, 3, 2, 2, 2, 1305, 1306, 3, 2, 2, 2, 1306, 1310, 7, 97, 2, 2, 1307, 1309, 7, 7, 2, 2, 1308, 1307, 3, 2, 2, 2, 1309, 1312, 3, 2, 2, 2, 1310, 1308, 3, 2, 2, 2, 1310, 1311, 3, 2, 2, 2, 1311, 1313, 3, 2, 2, 2, 1312, 1310, 3, 2, 2, 2, 1313, 1317, 7, 11, 2, 2, 1314, 1316, 7, 7, 2, 2, 1315, 1314, 3, 2, 2, 2, 1316, 1319, 3, 2, 2, 2, 1317, 1315, 3, 2, 2, 2, 1317, 1318, 3, 2, 2, 2, 1318, 1320, 3, 2, 2, 2, 1319, 1317, 3, 2, 2, 2, 1320, 1335, 7, 12, 2, 2, 1321, 1323, 7, 7, 2, 2, 1322, 1321, 3, 2, 2, 2, 1323, 1326, 3, 2, 2, 2, 1324, 1322, 3, 2, 2, 2, 1324, 1325, 3, 2, 2, 2, 1325, 1327, 3, 2, 2, 2, 1326, 1324, 3, 2, 2, 2, 1327, 1331, 7, 28, 2, 2, 1328, 1330, 7, 7, 2, 2, 1329, 1328, 3, 2, 2, 2, 1330, 1333, 3, 2, 2, 2, 1331, 1329, 3, 2, 2, 2, 1331, 1332, 3, 2, 2, 2, 1332, 1334, 3, 2, 2, 2, 1333, 1331, 3, 2, 2, 2, 1334, 1336, 5, 92, 47, 2, 1335, 1324, 3, 2, 2, 2, 1335, 1336, 3, 2, 2, 2, 1336, 1340, 3, 2, 2, 2, 1337, 1339, 7, 7, 2, 2, 1338, 1337, 3, 2, 2, 2, 1339, 1342, 3, 2, 2, 2, 1340, 1338, 3, 2, 2, 2, 1340, 1341, 3, 2, 2, 2, 1341, 1343, 3, 2, 2, 2, 1342, 1340, 3, 2, 2, 2, 1343, 1345, 5, 64, 33, 2, 1344, 1300, 3, 2, 2, 2, 1344, 1304, 3, 2, 2, 2, 1345, 79, 3, 2, 2, 2, 1346, 1348, 5, 280, 141, 2, 1347, 1346, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 1349, 3, 2, 2, 2, 1349, 1395, 7, 98, 2, 2, 1350, 1352, 5, 280, 141, 2, 1351, 1350, 3, 2, 2, 2, 1351, 1352, 3, 2, 2, 2, 1352, 1353, 3, 2, 2, 2, 1353, 1357, 7, 98, 2, 2, 1354, 1356, 7, 7, 2, 2, 1355, 1354, 3, 2, 2, 2, 1356, 1359, 3, 2, 2, 2, 1357, 1355, 3, 2, 2, 2, 1357, 1358, 3, 2, 2, 2, 1358, 1360, 3, 2, 2, 2, 1359, 1357, 3, 2, 2, 2, 1360, 1365, 7, 11, 2, 2, 1361, 1364, 5, 306, 154, 2, 1362, 1364, 5, 298, 150, 2, 1363, 1361, 3, 2, 2, 2, 1363, 1362, 3, 2, 2, 2, 1364, 1367, 3, 2, 2, 2, 1365, 1363, 3, 2, 2, 2, 1365, 1366, 3, 2, 2, 2, 1366, 1368, 3, 2, 2, 2, 1367, 1365, 3, 2, 2, 2, 1368, 1369, 5, 62, 32, 2, 1369, 1384, 7, 12, 2, 2, 1370, 1372, 7, 7, 2, 2, 1371, 1370, 3, 2, 2, 2, 1372, 1375, 3, 2, 2, 2, 1373, 1371, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1373, 3, 2, 2, 2, 1376, 1380, 7, 28, 2, 2, 1377, 1379, 7, 7, 2, 2, 1378, 1377, 3, 2, 2, 2, 1379, 1382, 3, 2, 2, 2, 1380, 1378, 3, 2, 2, 2, 1380, 1381, 3, 2, 2, 2, 1381, 1383, 3, 2, 2, 2, 1382, 1380, 3, 2, 2, 2, 1383, 1385, 5, 92, 47, 2, 1384, 1373, 3, 2, 2, 2, 1384, 1385, 3, 2, 2, 2, 1385, 1389, 3, 2, 2, 2, 1386, 1388, 7, 7, 2, 2, 1387, 1386, 3, 2, 2, 2, 1388, 1391, 3, 2, 2, 2, 1389, 1387, 3, 2, 2, 2, 1389, 1390, 3, 2, 2, 2, 1390, 1392, 3, 2, 2, 2, 1391, 1389, 3, 2, 2, 2, 1392, 1393, 5, 64, 33, 2, 1393, 1395, 3, 2, 2, 2, 1394, 1347, 3, 2, 2, 2, 1394, 1351, 3, 2, 2, 2, 1395, 81, 3, 2, 2, 2, 1396, 1398, 5, 280, 141, 2, 1397, 1396, 3, 2, 2, 2, 1397, 1398, 3, 2, 2, 2, 1398, 1399, 3, 2, 2, 2, 1399, 1403, 7, 69, 2, 2, 1400, 1402, 7, 7, 2, 2, 1401, 1400, 3, 2, 2, 2, 1402, 1405, 3, 2, 2, 2, 1403, 1401, 3, 2, 2, 2, 1403, 1404, 3, 2, 2, 2, 1404, 1406, 3, 2, 2, 2, 1405, 1403, 3, 2, 2, 2, 1406, 1414, 5, 316, 159, 2, 1407, 1409, 7, 7, 2, 2, 1408, 1407, 3, 2, 2, 2, 1409, 1412, 3, 2, 2, 2, 1410, 1408, 3, 2, 2, 2, 1410, 1411, 3, 2, 2, 2, 1411, 1413, 3, 2, 2, 2, 1412, 1410, 3, 2, 2, 2, 1413, 1415, 5, 84, 43, 2, 1414, 1410, 3, 2, 2, 2, 1414, 1415, 3, 2, 2, 2, 1415, 1419, 3, 2, 2, 2, 1416, 1418, 7, 7, 2, 2, 1417, 1416, 3, 2, 2, 2, 1418, 1421, 3, 2, 2, 2, 1419, 1417, 3, 2, 2, 2, 1419, 1420, 3, 2, 2, 2, 1420, 1422, 3, 2, 2, 2, 1421, 1419, 3, 2, 2, 2, 1422, 1426, 7, 30, 2, 2, 1423, 1425, 7, 7, 2, 2, 1424, 1423, 3, 2, 2, 2, 1425, 1428, 3, 2, 2, 2, 1426, 1424, 3, 2, 2, 2, 1426, 1427, 3, 2, 2, 2, 1427, 1429, 3, 2, 2, 2, 1428, 1426, 3, 2, 2, 2, 1429, 1430, 5, 92, 47, 2, 1430, 83, 3, 2, 2, 2, 1431, 1435, 7, 46, 2, 2, 1432, 1434, 7, 7, 2, 2, 1433, 1432, 3, 2, 2, 2, 1434, 1437, 3, 2, 2, 2, 1435, 1433, 3, 2, 2, 2, 1435, 1436, 3, 2, 2, 2, 1436, 1438, 3, 2, 2, 2, 1437, 1435, 3, 2, 2, 2, 1438, 1455, 5, 86, 44, 2, 1439, 1441, 7, 7, 2, 2, 1440, 1439, 3, 2, 2, 2, 1441, 1444, 3, 2, 2, 2, 1442, 1440, 3, 2, 2, 2, 1442, 1443, 3, 2, 2, 2, 1443, 1445, 3, 2, 2, 2, 1444, 1442, 3, 2, 2, 2, 1445, 1449, 7, 10, 2, 2, 1446, 1448, 7, 7, 2, 2, 1447, 1446, 3, 2, 2, 2, 1448, 1451, 3, 2, 2, 2, 1449, 1447, 3, 2, 2, 2, 1449, 1450, 3, 2, 2, 2, 1450, 1452, 3, 2, 2, 2, 1451, 1449, 3, 2, 2, 2, 1452, 1454, 5, 86, 44, 2, 1453, 1442, 3, 2, 2, 2, 1454, 1457, 3, 2, 2, 2, 1455, 1453, 3, 2, 2, 2, 1455, 1456, 3, 2, 2, 2, 1456, 1461, 3, 2, 2, 2, 1457, 1455, 3, 2, 2, 2, 1458, 1460, 7, 7, 2, 2, 1459, 1458, 3, 2, 2, 2, 1460, 1463, 3, 2, 2, 2, 1461, 1459, 3, 2, 2, 2, 1461, 1462, 3, 2, 2, 2, 1462, 1464, 3, 2, 2, 2, 1463, 1461, 3, 2, 2, 2, 1464, 1465, 7, 47, 2, 2, 1465, 85, 3, 2, 2, 2, 1466, 1468, 5, 88, 45, 2, 1467, 1466, 3, 2, 2, 2, 1467, 1468, 3, 2, 2, 2, 1468, 1472, 3, 2, 2, 2, 1469, 1471, 7, 7, 2, 2, 1470, 1469, 3, 2, 2, 2, 1471, 1474, 3, 2, 2, 2, 1472, 1470, 3, 2, 2, 2, 1472, 1473, 3, 2, 2, 2, 1473, 1475, 3, 2, 2, 2, 1474, 1472, 3, 2, 2, 2, 1475, 1490, 5, 316, 159, 2, 1476, 1478, 7, 7, 2, 2, 1477, 1476, 3, 2, 2, 2, 1478, 1481, 3, 2, 2, 2, 1479, 1477, 3, 2, 2, 2, 1479, 1480, 3, 2, 2, 2, 1480, 1482, 3, 2, 2, 2, 1481, 1479, 3, 2, 2, 2, 1482, 1486, 7, 28, 2, 2, 1483, 1485, 7, 7, 2, 2, 1484, 1483, 3, 2, 2, 2, 1485, 1488, 3, 2, 2, 2, 1486, 1484, 3, 2, 2, 2, 1486, 1487, 3, 2, 2, 2, 1487, 1489, 3, 2, 2, 2, 1488, 1486, 3, 2, 2, 2, 1489, 1491, 5, 92, 47, 2, 1490, 1479, 3, 2, 2, 2, 1490, 1491, 3, 2, 2, 2, 1491, 87, 3, 2, 2, 2, 1492, 1494, 5, 90, 46, 2, 1493, 1492, 3, 2, 2, 2, 1494, 1495, 3, 2, 2, 2, 1495, 1493, 3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 89, 3, 2, 2, 2, 1497, 1501, 5, 300, 151, 2, 1498, 1500, 7, 7, 2, 2, 1499, 1498, 3, 2, 2, 2, 1500, 1503, 3, 2, 2, 2, 1501, 1499, 3, 2, 2, 2, 1501, 1502, 3, 2, 2, 2, 1502, 1513, 3, 2, 2, 2, 1503, 1501, 3, 2, 2, 2, 1504, 1508, 5, 290, 146, 2, 1505, 1507, 7, 7, 2, 2, 1506, 1505, 3, 2, 2, 2, 1507, 1510, 3, 2, 2, 2, 1508, 1506, 3, 2, 2, 2, 1508, 1509, 3, 2, 2, 2, 1509, 1513, 3, 2, 2, 2, 1510, 1508, 3, 2, 2, 2, 1511, 1513, 5, 306, 154, 2, 1512, 1497, 3, 2, 2, 2, 1512, 1504, 3, 2, 2, 2, 1512, 1511, 3, 2, 2, 2, 1513, 91, 3, 2, 2, 2, 1514, 1516, 5, 94, 48, 2, 1515, 1514, 3, 2, 2, 2, 1515, 1516, 3, 2, 2, 2, 1516, 1521, 3, 2, 2, 2, 1517, 1522, 5, 98, 50, 2, 1518, 1522, 5, 100, 51, 2, 1519, 1522, 5, 102, 52, 2, 1520, 1522, 5, 104, 53, 2, 1521, 1517, 3, 2, 2, 2, 1521, 1518, 3, 2, 2, 2, 1521, 1519, 3, 2, 2, 2, 1521, 1520, 3, 2, 2, 2, 1522, 93, 3, 2, 2, 2, 1523, 1525, 5, 96, 49, 2, 1524, 1523, 3, 2, 2, 2, 1525, 1526, 3, 2, 2, 2, 1526, 1524, 3, 2, 2, 2, 1526, 1527, 3, 2, 2, 2, 1527, 95, 3, 2, 2, 2, 1528, 1537, 5, 306, 154, 2, 1529, 1533, 7, 123, 2, 2, 1530, 1532, 7, 7, 2, 2, 1531, 1530, 3, 2, 2, 2, 1532, 1535, 3, 2, 2, 2, 1533, 1531, 3, 2, 2, 2, 1533, 1534, 3, 2, 2, 2, 1534, 1537, 3, 2, 2, 2, 1535, 1533, 3, 2, 2, 2, 1536, 1528, 3, 2, 2, 2, 1536, 1529, 3, 2, 2, 2, 1537, 97, 3, 2, 2, 2, 1538, 1542, 7, 11, 2, 2, 1539, 1541, 7, 7, 2, 2, 1540, 1539, 3, 2, 2, 2, 1541, 1544, 3, 2, 2, 2, 1542, 1540, 3, 2, 2, 2, 1542, 1543, 3, 2, 2, 2, 1543, 1545, 3, 2, 2, 2, 1544, 1542, 3, 2, 2, 2, 1545, 1549, 5, 92, 47, 2, 1546, 1548, 7, 7, 2, 2, 1547, 1546, 3, 2, 2, 2, 1548, 1551, 3, 2, 2, 2, 1549, 1547, 3, 2, 2, 2, 1549, 1550, 3, 2, 2, 2, 1550, 1552, 3, 2, 2, 2, 1551, 1549, 3, 2, 2, 2, 1552, 1553, 7, 12, 2, 2, 1553, 99, 3, 2, 2, 2, 1554, 1557, 5, 102, 52, 2, 1555, 1557, 5, 98, 50, 2, 1556, 1554, 3, 2, 2, 2, 1556, 1555, 3, 2, 2, 2, 1557, 1561, 3, 2, 2, 2, 1558, 1560, 7, 7, 2, 2, 1559, 1558, 3, 2, 2, 2, 1560, 1563, 3, 2, 2, 2, 1561, 1559, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562, 1565, 3, 2, 2, 2, 1563, 1561, 3, 2, 2, 2, 1564, 1566, 5, 322, 162, 2, 1565, 1564, 3, 2, 2, 2, 1566, 1567, 3, 2, 2, 2, 1567, 1565, 3, 2, 2, 2, 1567, 1568, 3, 2, 2, 2, 1568, 101, 3, 2, 2, 2, 1569, 1572, 5, 108, 55, 2, 1570, 1572, 7, 99, 2, 2, 1571, 1569, 3, 2, 2, 2, 1571, 1570, 3, 2, 2, 2, 1572, 103, 3, 2, 2, 2, 1573, 1577, 5, 106, 54, 2, 1574, 1576, 7, 7, 2, 2, 1575, 1574, 3, 2, 2, 2, 1576, 1579, 3, 2, 2, 2, 1577, 1575, 3, 2, 2, 2, 1577, 1578, 3, 2, 2, 2, 1578, 1580, 3, 2, 2, 2, 1579, 1577, 3, 2, 2, 2, 1580, 1584, 7, 9, 2, 2, 1581, 1583, 7, 7, 2, 2, 1582, 1581, 3, 2, 2, 2, 1583, 1586, 3, 2, 2, 2, 1584, 1582, 3, 2, 2, 2, 1584, 1585, 3, 2, 2, 2, 1585, 1588, 3, 2, 2, 2, 1586, 1584, 3, 2, 2, 2, 1587, 1573, 3, 2, 2, 2, 1587, 1588, 3, 2, 2, 2, 1588, 1589, 3, 2, 2, 2, 1589, 1593, 5, 114, 58, 2, 1590, 1592, 7, 7, 2, 2, 1591, 1590, 3, 2, 2, 2, 1592, 1595, 3, 2, 2, 2, 1593, 1591, 3, 2, 2, 2, 1593, 1594, 3, 2, 2, 2, 1594, 1596, 3, 2, 2, 2, 1595, 1593, 3, 2, 2, 2, 1596, 1600, 7, 36, 2, 2, 1597, 1599, 7, 7, 2, 2, 1598, 1597, 3, 2, 2, 2, 1599, 1602, 3, 2, 2, 2, 1600, 1598, 3, 2, 2, 2, 1600, 1601, 3, 2, 2, 2, 1601, 1603, 3, 2, 2, 2, 1602, 1600, 3, 2, 2, 2, 1603, 1604, 5, 92, 47, 2, 1604, 105, 3, 2, 2, 2, 1605, 1607, 5, 94, 48, 2, 1606, 1605, 3, 2, 2, 2, 1606, 1607, 3, 2, 2, 2, 1607, 1611, 3, 2, 2, 2, 1608, 1612, 5, 98, 50, 2, 1609, 1612, 5, 100, 51, 2, 1610, 1612, 5, 102, 52, 2, 1611, 1608, 3, 2, 2, 2, 1611, 1609, 3, 2, 2, 2, 1611, 1610, 3, 2, 2, 2, 1612, 107, 3, 2, 2, 2, 1613, 1630, 5, 112, 57, 2, 1614, 1616, 7, 7, 2, 2, 1615, 1614, 3, 2, 2, 2, 1616, 1619, 3, 2, 2, 2, 1617, 1615, 3, 2, 2, 2, 1617, 1618, 3, 2, 2, 2, 1618, 1620, 3, 2, 2, 2, 1619, 1617, 3, 2, 2, 2, 1620, 1624, 7, 9, 2, 2, 1621, 1623, 7, 7, 2, 2, 1622, 1621, 3, 2, 2, 2, 1623, 1626, 3, 2, 2, 2, 1624, 1622, 3, 2, 2, 2, 1624, 1625, 3, 2, 2, 2, 1625, 1627, 3, 2, 2, 2, 1626, 1624, 3, 2, 2, 2, 1627, 1629, 5, 112, 57, 2, 1628, 1617, 3, 2, 2, 2, 1629, 1632, 3, 2, 2, 2, 1630, 1628, 3, 2, 2, 2, 1630, 1631, 3, 2, 2, 2, 1631, 109, 3, 2, 2, 2, 1632, 1630, 3, 2, 2, 2, 1633, 1637, 7, 11, 2, 2, 1634, 1636, 7, 7, 2, 2, 1635, 1634, 3, 2, 2, 2, 1636, 1639, 3, 2, 2, 2, 1637, 1635, 3, 2, 2, 2, 1637, 1638, 3, 2, 2, 2, 1638, 1640, 3, 2, 2, 2, 1639, 1637, 3, 2, 2, 2, 1640, 1644, 5, 108, 55, 2, 1641, 1643, 7, 7, 2, 2, 1642, 1641, 3, 2, 2, 2, 1643, 1646, 3, 2, 2, 2, 1644, 1642, 3, 2, 2, 2, 1644, 1645, 3, 2, 2, 2, 1645, 1647, 3, 2, 2, 2, 1646, 1644, 3, 2, 2, 2, 1647, 1648, 7, 12, 2, 2, 1648, 1666, 3, 2, 2, 2, 1649, 1653, 7, 11, 2, 2, 1650, 1652, 7, 7, 2, 2, 1651, 1650, 3, 2, 2, 2, 1652, 1655, 3, 2, 2, 2, 1653, 1651, 3, 2, 2, 2, 1653, 1654, 3, 2, 2, 2, 1654, 1656, 3, 2, 2, 2, 1655, 1653, 3, 2, 2, 2, 1656, 1660, 5, 110, 56, 2, 1657, 1659, 7, 7, 2, 2, 1658, 1657, 3, 2, 2, 2, 1659, 1662, 3, 2, 2, 2, 1660, 1658, 3, 2, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1663, 3, 2, 2, 2, 1662, 1660, 3, 2, 2, 2, 1663, 1664, 7, 12, 2, 2, 1664, 1666, 3, 2, 2, 2, 1665, 1633, 3, 2, 2, 2, 1665, 1649, 3, 2, 2, 2, 1666, 111, 3, 2, 2, 2, 1667, 1675, 5, 316, 159, 2, 1668, 1670, 7, 7, 2, 2, 1669, 1668, 3, 2, 2, 2, 1670, 1673, 3, 2, 2, 2, 1671, 1669, 3, 2, 2, 2, 1671, 1672, 3, 2, 2, 2, 1672, 1674, 3, 2, 2, 2, 1673, 1671, 3, 2, 2, 2, 1674, 1676, 5, 178, 90, 2, 1675, 1671, 3, 2, 2, 2, 1675, 1676, 3, 2, 2, 2, 1676, 113, 3, 2, 2, 2, 1677, 1681, 7, 11, 2, 2, 1678, 1680, 7, 7, 2, 2, 1679, 1678, 3, 2, 2, 2, 1680, 1683, 3, 2, 2, 2, 1681, 1679, 3, 2, 2, 2, 1681, 1682, 3, 2, 2, 2, 1682, 1686, 3, 2, 2, 2, 1683, 1681, 3, 2, 2, 2, 1684, 1687, 5, 60, 31, 2, 1685, 1687, 5, 92, 47, 2, 1686, 1684, 3, 2, 2, 2, 1686, 1685, 3, 2, 2, 2, 1686, 1687, 3, 2, 2, 2, 1687, 1707, 3, 2, 2, 2, 1688, 1690, 7, 7, 2, 2, 1689, 1688, 3, 2, 2, 2, 1690, 1693, 3, 2, 2, 2, 1691, 1689, 3, 2, 2, 2, 1691, 1692, 3, 2, 2, 2, 1692, 1694, 3, 2, 2, 2, 1693, 1691, 3, 2, 2, 2, 1694, 1698, 7, 10, 2, 2, 1695, 1697, 7, 7, 2, 2, 1696, 1695, 3, 2, 2, 2, 1697, 1700, 3, 2, 2, 2, 1698, 1696, 3, 2, 2, 2, 1698, 1699, 3, 2, 2, 2, 1699, 1703, 3, 2, 2, 2, 1700, 1698, 3, 2, 2, 2, 1701, 1704, 5, 60, 31, 2, 1702, 1704, 5, 92, 47, 2, 1703, 1701, 3, 2, 2, 2, 1703, 1702, 3, 2, 2, 2, 1704, 1706, 3, 2, 2, 2, 1705, 1691, 3, 2, 2, 2, 1706, 1709, 3, 2, 2, 2, 1707, 1705, 3, 2, 2, 2, 1707, 1708, 3, 2, 2, 2, 1708, 1713, 3, 2, 2, 2, 1709, 1707, 3, 2, 2, 2, 1710, 1712, 7, 7, 2, 2, 1711, 1710, 3, 2, 2, 2, 1712, 1715, 3, 2, 2, 2, 1713, 1711, 3, 2, 2, 2, 1713, 1714, 3, 2, 2, 2, 1714, 1716, 3, 2, 2, 2, 1715, 1713, 3, 2, 2, 2, 1716, 1717, 7, 12, 2, 2, 1717, 115, 3, 2, 2, 2, 1718, 1722, 7, 77, 2, 2, 1719, 1721, 7, 7, 2, 2, 1720, 1719, 3, 2, 2, 2, 1721, 1724, 3, 2, 2, 2, 1722, 1720, 3, 2, 2, 2, 1722, 1723, 3, 2, 2, 2, 1723, 1725, 3, 2, 2, 2, 1724, 1722, 3, 2, 2, 2, 1725, 1742, 5, 118, 60, 2, 1726, 1728, 7, 7, 2, 2, 1727, 1726, 3, 2, 2, 2, 1728, 1731, 3, 2, 2, 2, 1729, 1727, 3, 2, 2, 2, 1729, 1730, 3, 2, 2, 2, 1730, 1732, 3, 2, 2, 2, 1731, 1729, 3, 2, 2, 2, 1732, 1736, 7, 10, 2, 2, 1733, 1735, 7, 7, 2, 2, 1734, 1733, 3, 2, 2, 2, 1735, 1738, 3, 2, 2, 2, 1736, 1734, 3, 2, 2, 2, 1736, 1737, 3, 2, 2, 2, 1737, 1739, 3, 2, 2, 2, 1738, 1736, 3, 2, 2, 2, 1739, 1741, 5, 118, 60, 2, 1740, 1729, 3, 2, 2, 2, 1741, 1744, 3, 2, 2, 2, 1742, 1740, 3, 2, 2, 2, 1742, 1743, 3, 2, 2, 2, 1743, 117, 3, 2, 2, 2, 1744, 1742, 3, 2, 2, 2, 1745, 1747, 5, 306, 154, 2, 1746, 1745, 3, 2, 2, 2, 1747, 1750, 3, 2, 2, 2, 1748, 1746, 3, 2, 2, 2, 1748, 1749, 3, 2, 2, 2, 1749, 1751, 3, 2, 2, 2, 1750, 1748, 3, 2, 2, 2, 1751, 1755, 5, 316, 159, 2, 1752, 1754, 7, 7, 2, 2, 1753, 1752, 3, 2, 2, 2, 1754, 1757, 3, 2, 2, 2, 1755, 1753, 3, 2, 2, 2, 1755, 1756, 3, 2, 2, 2, 1756, 1758, 3, 2, 2, 2, 1757, 1755, 3, 2, 2, 2, 1758, 1762, 7, 28, 2, 2, 1759, 1761, 7, 7, 2, 2, 1760, 1759, 3, 2, 2, 2, 1761, 1764, 3, 2, 2, 2, 1762, 1760, 3, 2, 2, 2, 1762, 1763, 3, 2, 2, 2, 1763, 1765, 3, 2, 2, 2, 1764, 1762, 3, 2, 2, 2, 1765, 1766, 5, 92, 47, 2, 1766, 119, 3, 2, 2, 2, 1767, 1771, 7, 15, 2, 2, 1768, 1770, 7, 7, 2, 2, 1769, 1768, 3, 2, 2, 2, 1770, 1773, 3, 2, 2, 2, 1771, 1769, 3, 2, 2, 2, 1771, 1772, 3, 2, 2, 2, 1772, 1774, 3, 2, 2, 2, 1773, 1771, 3, 2, 2, 2, 1774, 1778, 5, 122, 62, 2, 1775, 1777, 7, 7, 2, 2, 1776, 1775, 3, 2, 2, 2, 1777, 1780, 3, 2, 2, 2, 1778, 1776, 3, 2, 2, 2, 1778, 1779, 3, 2, 2, 2, 1779, 1781, 3, 2, 2, 2, 1780, 1778, 3, 2, 2, 2, 1781, 1782, 7, 16, 2, 2, 1782, 121, 3, 2, 2, 2, 1783, 1789, 5, 124, 63, 2, 1784, 1785, 5, 332, 167, 2, 1785, 1786, 5, 124, 63, 2, 1786, 1788, 3, 2, 2, 2, 1787, 1784, 3, 2, 2, 2, 1788, 1791, 3, 2, 2, 2, 1789, 1787, 3, 2, 2, 2, 1789, 1790, 3, 2, 2, 2, 1790, 1793, 3, 2, 2, 2, 1791, 1789, 3, 2, 2, 2, 1792, 1794, 5, 332, 167, 2, 1793, 1792, 3, 2, 2, 2, 1793, 1794, 3, 2, 2, 2, 1794, 1796, 3, 2, 2, 2, 1795, 1783, 3, 2, 2, 2, 1795, 1796, 3, 2, 2, 2, 1796, 123, 3, 2, 2, 2, 1797, 1800, 5, 304, 153, 2, 1798, 1800, 5, 306, 154, 2, 1799, 1797, 3, 2, 2, 2, 1799, 1798, 3, 2, 2, 2, 1800, 1803, 3, 2, 2, 2, 1801, 1799, 3, 2, 2, 2, 1801, 1802, 3, 2, 2, 2, 1802, 1808, 3, 2, 2, 2, 1803, 1801, 3, 2, 2, 2, 1804, 1809, 5, 126, 64, 2, 1805, 1809, 5, 128, 65, 2, 1806, 1809, 5, 246, 124, 2, 1807, 1809, 5, 130, 66, 2, 1808, 1804, 3, 2, 2, 2, 1808, 1805, 3, 2, 2, 2, 1808, 1806, 3, 2, 2, 2, 1808, 1807, 3, 2, 2, 2, 1809, 125, 3, 2, 2, 2, 1810, 1816, 5, 18, 10, 2, 1811, 1816, 5, 66, 34, 2, 1812, 1816, 5, 54, 28, 2, 1813, 1816, 5, 70, 36, 2, 1814, 1816, 5, 82, 42, 2, 1815, 1810, 3, 2, 2, 2, 1815, 1811, 3, 2, 2, 2, 1815, 1812, 3, 2, 2, 2, 1815, 1813, 3, 2, 2, 2, 1815, 1814, 3, 2, 2, 2, 1816, 127, 3, 2, 2, 2, 1817, 1818, 5, 162, 82, 2, 1818, 1822, 7, 30, 2, 2, 1819, 1821, 7, 7, 2, 2, 1820, 1819, 3, 2, 2, 2, 1821, 1824, 3, 2, 2, 2, 1822, 1820, 3, 2, 2, 2, 1822, 1823, 3, 2, 2, 2, 1823, 1825, 3, 2, 2, 2, 1824, 1822, 3, 2, 2, 2, 1825, 1826, 5, 130, 66, 2, 1826, 1838, 3, 2, 2, 2, 1827, 1828, 5, 164, 83, 2, 1828, 1832, 5, 258, 130, 2, 1829, 1831, 7, 7, 2, 2, 1830, 1829, 3, 2, 2, 2, 1831, 1834, 3, 2, 2, 2, 1832, 1830, 3, 2, 2, 2, 1832, 1833, 3, 2, 2, 2, 1833, 1835, 3, 2, 2, 2, 1834, 1832, 3, 2, 2, 2, 1835, 1836, 5, 130, 66, 2, 1836, 1838, 3, 2, 2, 2, 1837, 1817, 3, 2, 2, 2, 1837, 1827, 3, 2, 2, 2, 1838, 129, 3, 2, 2, 2, 1839, 1840, 5, 132, 67, 2, 1840, 131, 3, 2, 2, 2, 1841, 1858, 5, 134, 68, 2, 1842, 1844, 7, 7, 2, 2, 1843, 1842, 3, 2, 2, 2, 1844, 1847, 3, 2, 2, 2, 1845, 1843, 3, 2, 2, 2, 1845, 1846, 3, 2, 2, 2, 1846, 1848, 3, 2, 2, 2, 1847, 1845, 3, 2, 2, 2, 1848, 1852, 7, 25, 2, 2, 1849, 1851, 7, 7, 2, 2, 1850, 1849, 3, 2, 2, 2, 1851, 1854, 3, 2, 2, 2, 1852, 1850, 3, 2, 2, 2, 1852, 1853, 3, 2, 2, 2, 1853, 1855, 3, 2, 2, 2, 1854, 1852, 3, 2, 2, 2, 1855, 1857, 5, 134, 68, 2, 1856, 1845, 3, 2, 2, 2, 1857, 1860, 3, 2, 2, 2, 1858, 1856, 3, 2, 2, 2, 1858, 1859, 3, 2, 2, 2, 1859, 133, 3, 2, 2, 2, 1860, 1858, 3, 2, 2, 2, 1861, 1878, 5, 136, 69, 2, 1862, 1864, 7, 7, 2, 2, 1863, 1862, 3, 2, 2, 2, 1864, 1867, 3, 2, 2, 2, 1865, 1863, 3, 2, 2, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1868, 3, 2, 2, 2, 1867, 1865, 3, 2, 2, 2, 1868, 1872, 7, 24, 2, 2, 1869, 1871, 7, 7, 2, 2, 1870, 1869, 3, 2, 2, 2, 1871, 1874, 3, 2, 2, 2, 1872, 1870, 3, 2, 2, 2, 1872, 1873, 3, 2, 2, 2, 1873, 1875, 3, 2, 2, 2, 1874, 1872, 3, 2, 2, 2, 1875, 1877, 5, 136, 69, 2, 1876, 1865, 3, 2, 2, 2, 1877, 1880, 3, 2, 2, 2, 1878, 1876, 3, 2, 2, 2, 1878, 1879, 3, 2, 2, 2, 1879, 135, 3, 2, 2, 2, 1880, 1878, 3, 2, 2, 2, 1881, 1893, 5, 138, 70, 2, 1882, 1886, 5, 260, 131, 2, 1883, 1885, 7, 7, 2, 2, 1884, 1883, 3, 2, 2, 2, 1885, 1888, 3, 2, 2, 2, 1886, 1884, 3, 2, 2, 2, 1886, 1887, 3, 2, 2, 2, 1887, 1889, 3, 2, 2, 2, 1888, 1886, 3, 2, 2, 2, 1889, 1890, 5, 138, 70, 2, 1890, 1892, 3, 2, 2, 2, 1891, 1882, 3, 2, 2, 2, 1892, 1895, 3, 2, 2, 2, 1893, 1891, 3, 2, 2, 2, 1893, 1894, 3, 2, 2, 2, 1894, 137, 3, 2, 2, 2, 1895, 1893, 3, 2, 2, 2, 1896, 1906, 5, 140, 71, 2, 1897, 1901, 5, 262, 132, 2, 1898, 1900, 7, 7, 2, 2, 1899, 1898, 3, 2, 2, 2, 1900, 1903, 3, 2, 2, 2, 1901, 1899, 3, 2, 2, 2, 1901, 1902, 3, 2, 2, 2, 1902, 1904, 3, 2, 2, 2, 1903, 1901, 3, 2, 2, 2, 1904, 1905, 5, 140, 71, 2, 1905, 1907, 3, 2, 2, 2, 1906, 1897, 3, 2, 2, 2, 1906, 1907, 3, 2, 2, 2, 1907, 139, 3, 2, 2, 2, 1908, 1929, 5, 142, 72, 2, 1909, 1913, 5, 264, 133, 2, 1910, 1912, 7, 7, 2, 2, 1911, 1910, 3, 2, 2, 2, 1912, 1915, 3, 2, 2, 2, 1913, 1911, 3, 2, 2, 2, 1913, 1914, 3, 2, 2, 2, 1914, 1916, 3, 2, 2, 2, 1915, 1913, 3, 2, 2, 2, 1916, 1917, 5, 142, 72, 2, 1917, 1928, 3, 2, 2, 2, 1918, 1922, 5, 266, 134, 2, 1919, 1921, 7, 7, 2, 2, 1920, 1919, 3, 2, 2, 2, 1921, 1924, 3, 2, 2, 2, 1922, 1920, 3, 2, 2, 2, 1922, 1923, 3, 2, 2, 2, 1923, 1925, 3, 2, 2, 2, 1924, 1922, 3, 2, 2, 2, 1925, 1926, 5, 92, 47, 2, 1926, 1928, 3, 2, 2, 2, 1927, 1909, 3, 2, 2, 2, 1927, 1918, 3, 2, 2, 2, 1928, 1931, 3, 2, 2, 2, 1929, 1927, 3, 2, 2, 2, 1929, 1930, 3, 2, 2, 2, 1930, 141, 3, 2, 2, 2, 1931, 1929, 3, 2, 2, 2, 1932, 1950, 5, 144, 73, 2, 1933, 1935, 7, 7, 2, 2, 1934, 1933, 3, 2, 2, 2, 1935, 1938, 3, 2, 2, 2, 1936, 1934, 3, 2, 2, 2, 1936, 1937, 3, 2, 2, 2, 1937, 1939, 3, 2, 2, 2, 1938, 1936, 3, 2, 2, 2, 1939, 1943, 5, 324, 163, 2, 1940, 1942, 7, 7, 2, 2, 1941, 1940, 3, 2, 2, 2, 1942, 1945, 3, 2, 2, 2, 1943, 1941, 3, 2, 2, 2, 1943, 1944, 3, 2, 2, 2, 1944, 1946, 3, 2, 2, 2, 1945, 1943, 3, 2, 2, 2, 1946, 1947, 5, 144, 73, 2, 1947, 1949, 3, 2, 2, 2, 1948, 1936, 3, 2, 2, 2, 1949, 1952, 3, 2, 2, 2, 1950, 1948, 3, 2, 2, 2, 1950, 1951, 3, 2, 2, 2, 1951, 143, 3, 2, 2, 2, 1952, 1950, 3, 2, 2, 2, 1953, 1965, 5, 146, 74, 2, 1954, 1958, 5, 316, 159, 2, 1955, 1957, 7, 7, 2, 2, 1956, 1955, 3, 2, 2, 2, 1957, 1960, 3, 2, 2, 2, 1958, 1956, 3, 2, 2, 2, 1958, 1959, 3, 2, 2, 2, 1959, 1961, 3, 2, 2, 2, 1960, 1958, 3, 2, 2, 2, 1961, 1962, 5, 146, 74, 2, 1962, 1964, 3, 2, 2, 2, 1963, 1954, 3, 2, 2, 2, 1964, 1967, 3, 2, 2, 2, 1965, 1963, 3, 2, 2, 2, 1965, 1966, 3, 2, 2, 2, 1966, 145, 3, 2, 2, 2, 1967, 1965, 3, 2, 2, 2, 1968, 1979, 5, 148, 75, 2, 1969, 1973, 7, 38, 2, 2, 1970, 1972, 7, 7, 2, 2, 1971, 1970, 3, 2, 2, 2, 1972, 1975, 3, 2, 2, 2, 1973, 1971, 3, 2, 2, 2, 1973, 1974, 3, 2, 2, 2, 1974, 1976, 3, 2, 2, 2, 1975, 1973, 3, 2, 2, 2, 1976, 1978, 5, 148, 75, 2, 1977, 1969, 3, 2, 2, 2, 1978, 1981, 3, 2, 2, 2, 1979, 1977, 3, 2, 2, 2, 1979, 1980, 3, 2, 2, 2, 1980, 147, 3, 2, 2, 2, 1981, 1979, 3, 2, 2, 2, 1982, 1994, 5, 150, 76, 2, 1983, 1987, 5, 268, 135, 2, 1984, 1986, 7, 7, 2, 2, 1985, 1984, 3, 2, 2, 2, 1986, 1989, 3, 2, 2, 2, 1987, 1985, 3, 2, 2, 2, 1987, 1988, 3, 2, 2, 2, 1988, 1990, 3, 2, 2, 2, 1989, 1987, 3, 2, 2, 2, 1990, 1991, 5, 150, 76, 2, 1991, 1993, 3, 2, 2, 2, 1992, 1983, 3, 2, 2, 2, 1993, 1996, 3, 2, 2, 2, 1994, 1992, 3, 2, 2, 2, 1994, 1995, 3, 2, 2, 2, 1995, 149, 3, 2, 2, 2, 1996, 1994, 3, 2, 2, 2, 1997, 2009, 5, 152, 77, 2, 1998, 2002, 5, 270, 136, 2, 1999, 2001, 7, 7, 2, 2, 2000, 1999, 3, 2, 2, 2, 2001, 2004, 3, 2, 2, 2, 2002, 2000, 3, 2, 2, 2, 2002, 2003, 3, 2, 2, 2, 2003, 2005, 3, 2, 2, 2, 2004, 2002, 3, 2, 2, 2, 2005, 2006, 5, 152, 77, 2, 2006, 2008, 3, 2, 2, 2, 2007, 1998, 3, 2, 2, 2, 2008, 2011, 3, 2, 2, 2, 2009, 2007, 3, 2, 2, 2, 2009, 2010, 3, 2, 2, 2, 2010, 151, 3, 2, 2, 2, 2011, 2009, 3, 2, 2, 2, 2012, 2028, 5, 154, 78, 2, 2013, 2015, 7, 7, 2, 2, 2014, 2013, 3, 2, 2, 2, 2015, 2018, 3, 2, 2, 2, 2016, 2014, 3, 2, 2, 2, 2016, 2017, 3, 2, 2, 2, 2017, 2019, 3, 2, 2, 2, 2018, 2016, 3, 2, 2, 2, 2019, 2023, 5, 272, 137, 2, 2020, 2022, 7, 7, 2, 2, 2021, 2020, 3, 2, 2, 2, 2022, 2025, 3, 2, 2, 2, 2023, 2021, 3, 2, 2, 2, 2023, 2024, 3, 2, 2, 2, 2024, 2026, 3, 2, 2, 2, 2025, 2023, 3, 2, 2, 2, 2026, 2027, 5, 92, 47, 2, 2027, 2029, 3, 2, 2, 2, 2028, 2016, 3, 2, 2, 2, 2028, 2029, 3, 2, 2, 2, 2029, 153, 3, 2, 2, 2, 2030, 2032, 5, 156, 79, 2, 2031, 2030, 3, 2, 2, 2, 2032, 2035, 3, 2, 2, 2, 2033, 2031, 3, 2, 2, 2, 2033, 2034, 3, 2, 2, 2, 2034, 2036, 3, 2, 2, 2, 2035, 2033, 3, 2, 2, 2, 2036, 2037, 5, 158, 80, 2, 2037, 155, 3, 2, 2, 2, 2038, 2048, 5, 306, 154, 2, 2039, 2048, 5, 304, 153, 2, 2040, 2044, 5, 274, 138, 2, 2041, 2043, 7, 7, 2, 2, 2042, 2041, 3, 2, 2, 2, 2043, 2046, 3, 2, 2, 2, 2044, 2042, 3, 2, 2, 2, 2044, 2045, 3, 2, 2, 2, 2045, 2048, 3, 2, 2, 2, 2046, 2044, 3, 2, 2, 2, 2047, 2038, 3, 2, 2, 2, 2047, 2039, 3, 2, 2, 2, 2047, 2040, 3, 2, 2, 2, 2048, 157, 3, 2, 2, 2, 2049, 2057, 5, 188, 95, 2, 2050, 2052, 5, 188, 95, 2, 2051, 2053, 5, 160, 81, 2, 2052, 2051, 3, 2, 2, 2, 2053, 2054, 3, 2, 2, 2, 2054, 2052, 3, 2, 2, 2, 2054, 2055, 3, 2, 2, 2, 2055, 2057, 3, 2, 2, 2, 2056, 2049, 3, 2, 2, 2, 2056, 2050, 3, 2, 2, 2, 2057, 159, 3, 2, 2, 2, 2058, 2064, 5, 276, 139, 2, 2059, 2064, 5, 178, 90, 2, 2060, 2064, 5, 172, 87, 2, 2061, 2064, 5, 168, 85, 2, 2062, 2064, 5, 170, 86, 2, 2063, 2058, 3, 2, 2, 2, 2063, 2059, 3, 2, 2, 2, 2063, 2060, 3, 2, 2, 2, 2063, 2061, 3, 2, 2, 2, 2063, 2062, 3, 2, 2, 2, 2064, 161, 3, 2, 2, 2, 2065, 2066, 5, 158, 80, 2, 2066, 2067, 5, 166, 84, 2, 2067, 2070, 3, 2, 2, 2, 2068, 2070, 5, 316, 159, 2, 2069, 2065, 3, 2, 2, 2, 2069, 2068, 3, 2, 2, 2, 2070, 163, 3, 2, 2, 2, 2071, 2072, 5, 154, 78, 2, 2072, 165, 3, 2, 2, 2, 2073, 2077, 5, 178, 90, 2, 2074, 2077, 5, 168, 85, 2, 2075, 2077, 5, 170, 86, 2, 2076, 2073, 3, 2, 2, 2, 2076, 2074, 3, 2, 2, 2, 2076, 2075, 3, 2, 2, 2, 2077, 167, 3, 2, 2, 2, 2078, 2082, 7, 13, 2, 2, 2079, 2081, 7, 7, 2, 2, 2080, 2079, 3, 2, 2, 2, 2081, 2084, 3, 2, 2, 2, 2082, 2080, 3, 2, 2, 2, 2082, 2083, 3, 2, 2, 2, 2083, 2085, 3, 2, 2, 2, 2084, 2082, 3, 2, 2, 2, 2085, 2102, 5, 130, 66, 2, 2086, 2088, 7, 7, 2, 2, 2087, 2086, 3, 2, 2, 2, 2088, 2091, 3, 2, 2, 2, 2089, 2087, 3, 2, 2, 2, 2089, 2090, 3, 2, 2, 2, 2090, 2092, 3, 2, 2, 2, 2091, 2089, 3, 2, 2, 2, 2092, 2096, 7, 10, 2, 2, 2093, 2095, 7, 7, 2, 2, 2094, 2093, 3, 2, 2, 2, 2095, 2098, 3, 2, 2, 2, 2096, 2094, 3, 2, 2, 2, 2096, 2097, 3, 2, 2, 2, 2097, 2099, 3, 2, 2, 2, 2098, 2096, 3, 2, 2, 2, 2099, 2101, 5, 130, 66, 2, 2100, 2089, 3, 2, 2, 2, 2101, 2104, 3, 2, 2, 2, 2102, 2100, 3, 2, 2, 2, 2102, 2103, 3, 2, 2, 2, 2103, 2108, 3, 2, 2, 2, 2104, 2102, 3, 2, 2, 2, 2105, 2107, 7, 7, 2, 2, 2106, 2105, 3, 2, 2, 2, 2107, 2110, 3, 2, 2, 2, 2108, 2106, 3, 2, 2, 2, 2108, 2109, 3, 2, 2, 2, 2109, 2111, 3, 2, 2, 2, 2110, 2108, 3, 2, 2, 2, 2111, 2112, 7, 14, 2, 2, 2112, 169, 3, 2, 2, 2, 2113, 2115, 7, 7, 2, 2, 2114, 2113, 3, 2, 2, 2, 2115, 2118, 3, 2, 2, 2, 2116, 2114, 3, 2, 2, 2, 2116, 2117, 3, 2, 2, 2, 2117, 2119, 3, 2, 2, 2, 2118, 2116, 3, 2, 2, 2, 2119, 2123, 5, 278, 140, 2, 2120, 2122, 7, 7, 2, 2, 2121, 2120, 3, 2, 2, 2, 2122, 2125, 3, 2, 2, 2, 2123, 2121, 3, 2, 2, 2, 2123, 2124, 3, 2, 2, 2, 2124, 2129, 3, 2, 2, 2, 2125, 2123, 3, 2, 2, 2, 2126, 2130, 5, 316, 159, 2, 2127, 2130, 5, 190, 96, 2, 2128, 2130, 7, 63, 2, 2, 2129, 2126, 3, 2, 2, 2, 2129, 2127, 3, 2, 2, 2, 2129, 2128, 3, 2, 2, 2, 2130, 171, 3, 2, 2, 2, 2131, 2133, 5, 178, 90, 2, 2132, 2131, 3, 2, 2, 2, 2132, 2133, 3, 2, 2, 2, 2133, 2135, 3, 2, 2, 2, 2134, 2136, 5, 176, 89, 2, 2135, 2134, 3, 2, 2, 2, 2135, 2136, 3, 2, 2, 2, 2136, 2137, 3, 2, 2, 2, 2137, 2143, 5, 174, 88, 2, 2138, 2140, 5, 178, 90, 2, 2139, 2138, 3, 2, 2, 2, 2139, 2140, 3, 2, 2, 2, 2140, 2141, 3, 2, 2, 2, 2141, 2143, 5, 176, 89, 2, 2142, 2132, 3, 2, 2, 2, 2142, 2139, 3, 2, 2, 2, 2143, 173, 3, 2, 2, 2, 2144, 2146, 5, 306, 154, 2, 2145, 2144, 3, 2, 2, 2, 2146, 2149, 3, 2, 2, 2, 2147, 2145, 3, 2, 2, 2, 2147, 2148, 3, 2, 2, 2, 2148, 2151, 3, 2, 2, 2, 2149, 2147, 3, 2, 2, 2, 2150, 2152, 5, 304, 153, 2, 2151, 2150, 3, 2, 2, 2, 2151, 2152, 3, 2, 2, 2, 2152, 2156, 3, 2, 2, 2, 2153, 2155, 7, 7, 2, 2, 2154, 2153, 3, 2, 2, 2, 2155, 2158, 3, 2, 2, 2, 2156, 2154, 3, 2, 2, 2, 2156, 2157, 3, 2, 2, 2, 2157, 2159, 3, 2, 2, 2, 2158, 2156, 3, 2, 2, 2, 2159, 2160, 5, 210, 106, 2, 2160, 175, 3, 2, 2, 2, 2161, 2165, 7, 11, 2, 2, 2162, 2164, 7, 7, 2, 2, 2163, 2162, 3, 2, 2, 2, 2164, 2167, 3, 2, 2, 2, 2165, 2163, 3, 2, 2, 2, 2165, 2166, 3, 2, 2, 2, 2166, 2168, 3, 2, 2, 2, 2167, 2165, 3, 2, 2, 2, 2168, 2205, 7, 12, 2, 2, 2169, 2173, 7, 11, 2, 2, 2170, 2172, 7, 7, 2, 2, 2171, 2170, 3, 2, 2, 2, 2172, 2175, 3, 2, 2, 2, 2173, 2171, 3, 2, 2, 2, 2173, 2174, 3, 2, 2, 2, 2174, 2176, 3, 2, 2, 2, 2175, 2173, 3, 2, 2, 2, 2176, 2193, 5, 186, 94, 2, 2177, 2179, 7, 7, 2, 2, 2178, 2177, 3, 2, 2, 2, 2179, 2182, 3, 2, 2, 2, 2180, 2178, 3, 2, 2, 2, 2180, 2181, 3, 2, 2, 2, 2181, 2183, 3, 2, 2, 2, 2182, 2180, 3, 2, 2, 2, 2183, 2187, 7, 10, 2, 2, 2184, 2186, 7, 7, 2, 2, 2185, 2184, 3, 2, 2, 2, 2186, 2189, 3, 2, 2, 2, 2187, 2185, 3, 2, 2, 2, 2187, 2188, 3, 2, 2, 2, 2188, 2190, 3, 2, 2, 2, 2189, 2187, 3, 2, 2, 2, 2190, 2192, 5, 186, 94, 2, 2191, 2180, 3, 2, 2, 2, 2192, 2195, 3, 2, 2, 2, 2193, 2191, 3, 2, 2, 2, 2193, 2194, 3, 2, 2, 2, 2194, 2199, 3, 2, 2, 2, 2195, 2193, 3, 2, 2, 2, 2196, 2198, 7, 7, 2, 2, 2197, 2196, 3, 2, 2, 2, 2198, 2201, 3, 2, 2, 2, 2199, 2197, 3, 2, 2, 2, 2199, 2200, 3, 2, 2, 2, 2200, 2202, 3, 2, 2, 2, 2201, 2199, 3, 2, 2, 2, 2202, 2203, 7, 12, 2, 2, 2203, 2205, 3, 2, 2, 2, 2204, 2161, 3, 2, 2, 2, 2204, 2169, 3, 2, 2, 2, 2205, 177, 3, 2, 2, 2, 2206, 2210, 7, 46, 2, 2, 2207, 2209, 7, 7, 2, 2, 2208, 2207, 3, 2, 2, 2, 2209, 2212, 3, 2, 2, 2, 2210, 2208, 3, 2, 2, 2, 2210, 2211, 3, 2, 2, 2, 2211, 2213, 3, 2, 2, 2, 2212, 2210, 3, 2, 2, 2, 2213, 2230, 5, 180, 91, 2, 2214, 2216, 7, 7, 2, 2, 2215, 2214, 3, 2, 2, 2, 2216, 2219, 3, 2, 2, 2, 2217, 2215, 3, 2, 2, 2, 2217, 2218, 3, 2, 2, 2, 2218, 2220, 3, 2, 2, 2, 2219, 2217, 3, 2, 2, 2, 2220, 2224, 7, 10, 2, 2, 2221, 2223, 7, 7, 2, 2, 2222, 2221, 3, 2, 2, 2, 2223, 2226, 3, 2, 2, 2, 2224, 2222, 3, 2, 2, 2, 2224, 2225, 3, 2, 2, 2, 2225, 2227, 3, 2, 2, 2, 2226, 2224, 3, 2, 2, 2, 2227, 2229, 5, 180, 91, 2, 2228, 2217, 3, 2, 2, 2, 2229, 2232, 3, 2, 2, 2, 2230, 2228, 3, 2, 2, 2, 2230, 2231, 3, 2, 2, 2, 2231, 2236, 3, 2, 2, 2, 2232, 2230, 3, 2, 2, 2, 2233, 2235, 7, 7, 2, 2, 2234, 2233, 3, 2, 2, 2, 2235, 2238, 3, 2, 2, 2, 2236, 2234, 3, 2, 2, 2, 2236, 2237, 3, 2, 2, 2, 2237, 2239, 3, 2, 2, 2, 2238, 2236, 3, 2, 2, 2, 2239, 2240, 7, 47, 2, 2, 2240, 179, 3, 2, 2, 2, 2241, 2243, 5, 182, 92, 2, 2242, 2241, 3, 2, 2, 2, 2242, 2243, 3, 2, 2, 2, 2243, 2244, 3, 2, 2, 2, 2244, 2247, 5, 92, 47, 2, 2245, 2247, 7, 17, 2, 2, 2246, 2242, 3, 2, 2, 2, 2246, 2245, 3, 2, 2, 2, 2247, 181, 3, 2, 2, 2, 2248, 2250, 5, 184, 93, 2, 2249, 2248, 3, 2, 2, 2, 2250, 2251, 3, 2, 2, 2, 2251, 2249, 3, 2, 2, 2, 2251, 2252, 3, 2, 2, 2, 2252, 183, 3, 2, 2, 2, 2253, 2257, 5, 290, 146, 2, 2254, 2256, 7, 7, 2, 2, 2255, 2254, 3, 2, 2, 2, 2256, 2259, 3, 2, 2, 2, 2257, 2255, 3, 2, 2, 2, 2257, 2258, 3, 2, 2, 2, 2258, 2262, 3, 2, 2, 2, 2259, 2257, 3, 2, 2, 2, 2260, 2262, 5, 306, 154, 2, 2261, 2253, 3, 2, 2, 2, 2261, 2260, 3, 2, 2, 2, 2262, 185, 3, 2, 2, 2, 2263, 2265, 5, 306, 154, 2, 2264, 2263, 3, 2, 2, 2, 2264, 2265, 3, 2, 2, 2, 2265, 2269, 3, 2, 2, 2, 2266, 2268, 7, 7, 2, 2, 2267, 2266, 3, 2, 2, 2, 2268, 2271, 3, 2, 2, 2, 2269, 2267, 3, 2, 2, 2, 2269, 2270, 3, 2, 2, 2, 2270, 2286, 3, 2, 2, 2, 2271, 2269, 3, 2, 2, 2, 2272, 2276, 5, 316, 159, 2, 2273, 2275, 7, 7, 2, 2, 2274, 2273, 3, 2, 2, 2, 2275, 2278, 3, 2, 2, 2, 2276, 2274, 3, 2, 2, 2, 2276, 2277, 3, 2, 2, 2, 2277, 2279, 3, 2, 2, 2, 2278, 2276, 3, 2, 2, 2, 2279, 2283, 7, 30, 2, 2, 2280, 2282, 7, 7, 2, 2, 2281, 2280, 3, 2, 2, 2, 2282, 2285, 3, 2, 2, 2, 2283, 2281, 3, 2, 2, 2, 2283, 2284, 3, 2, 2, 2, 2284, 2287, 3, 2, 2, 2, 2285, 2283, 3, 2, 2, 2, 2286, 2272, 3, 2, 2, 2, 2286, 2287, 3, 2, 2, 2, 2287, 2289, 3, 2, 2, 2, 2288, 2290, 7, 17, 2, 2, 2289, 2288, 3, 2, 2, 2, 2289, 2290, 3, 2, 2, 2, 2290, 2294, 3, 2, 2, 2, 2291, 2293, 7, 7, 2, 2, 2292, 2291, 3, 2, 2, 2, 2293, 2296, 3, 2, 2, 2, 2294, 2292, 3, 2, 2, 2, 2294, 2295, 3, 2, 2, 2, 2295, 2297, 3, 2, 2, 2, 2296, 2294, 3, 2, 2, 2, 2297, 2298, 5, 130, 66, 2, 2298, 187, 3, 2, 2, 2, 2299, 2314, 5, 190, 96, 2, 2300, 2314, 5, 194, 98, 2, 2301, 2314, 5, 196, 99, 2, 2302, 2314, 5, 316, 159, 2, 2303, 2314, 5, 256, 129, 2, 2304, 2314, 5, 218, 110, 2, 2305, 2314, 5, 220, 111, 2, 2306, 2314, 5, 192, 97, 2, 2307, 2314, 5, 222, 112, 2, 2308, 2314, 5, 224, 113, 2, 2309, 2314, 5, 228, 115, 2, 2310, 2314, 5, 230, 116, 2, 2311, 2314, 5, 240, 121, 2, 2312, 2314, 5, 254, 128, 2, 2313, 2299, 3, 2, 2, 2, 2313, 2300, 3, 2, 2, 2, 2313, 2301, 3, 2, 2, 2, 2313, 2302, 3, 2, 2, 2, 2313, 2303, 3, 2, 2, 2, 2313, 2304, 3, 2, 2, 2, 2313, 2305, 3, 2, 2, 2, 2313, 2306, 3, 2, 2, 2, 2313, 2307, 3, 2, 2, 2, 2313, 2308, 3, 2, 2, 2, 2313, 2309, 3, 2, 2, 2, 2313, 2310, 3, 2, 2, 2, 2313, 2311, 3, 2, 2, 2, 2313, 2312, 3, 2, 2, 2, 2314, 189, 3, 2, 2, 2, 2315, 2319, 7, 11, 2, 2, 2316, 2318, 7, 7, 2, 2, 2317, 2316, 3, 2, 2, 2, 2318, 2321, 3, 2, 2, 2, 2319, 2317, 3, 2, 2, 2, 2319, 2320, 3, 2, 2, 2, 2320, 2322, 3, 2, 2, 2, 2321, 2319, 3, 2, 2, 2, 2322, 2326, 5, 130, 66, 2, 2323, 2325, 7, 7, 2, 2, 2324, 2323, 3, 2, 2, 2, 2325, 2328, 3, 2, 2, 2, 2326, 2324, 3, 2, 2, 2, 2326, 2327, 3, 2, 2, 2, 2327, 2329, 3, 2, 2, 2, 2328, 2326, 3, 2, 2, 2, 2329, 2330, 7, 12, 2, 2, 2330, 191, 3, 2, 2, 2, 2331, 2335, 7, 13, 2, 2, 2332, 2334, 7, 7, 2, 2, 2333, 2332, 3, 2, 2, 2, 2334, 2337, 3, 2, 2, 2, 2335, 2333, 3, 2, 2, 2, 2335, 2336, 3, 2, 2, 2, 2336, 2338, 3, 2, 2, 2, 2337, 2335, 3, 2, 2, 2, 2338, 2355, 5, 130, 66, 2, 2339, 2341, 7, 7, 2, 2, 2340, 2339, 3, 2, 2, 2, 2341, 2344, 3, 2, 2, 2, 2342, 2340, 3, 2, 2, 2, 2342, 2343, 3, 2, 2, 2, 2343, 2345, 3, 2, 2, 2, 2344, 2342, 3, 2, 2, 2, 2345, 2349, 7, 10, 2, 2, 2346, 2348, 7, 7, 2, 2, 2347, 2346, 3, 2, 2, 2, 2348, 2351, 3, 2, 2, 2, 2349, 2347, 3, 2, 2, 2, 2349, 2350, 3, 2, 2, 2, 2350, 2352, 3, 2, 2, 2, 2351, 2349, 3, 2, 2, 2, 2352, 2354, 5, 130, 66, 2, 2353, 2342, 3, 2, 2, 2, 2354, 2357, 3, 2, 2, 2, 2355, 2353, 3, 2, 2, 2, 2355, 2356, 3, 2, 2, 2, 2356, 2361, 3, 2, 2, 2, 2357, 2355, 3, 2, 2, 2, 2358, 2360, 7, 7, 2, 2, 2359, 2358, 3, 2, 2, 2, 2360, 2363, 3, 2, 2, 2, 2361, 2359, 3, 2, 2, 2, 2361, 2362, 3, 2, 2, 2, 2362, 2364, 3, 2, 2, 2, 2363, 2361, 3, 2, 2, 2, 2364, 2365, 7, 14, 2, 2, 2365, 2375, 3, 2, 2, 2, 2366, 2370, 7, 13, 2, 2, 2367, 2369, 7, 7, 2, 2, 2368, 2367, 3, 2, 2, 2, 2369, 2372, 3, 2, 2, 2, 2370, 2368, 3, 2, 2, 2, 2370, 2371, 3, 2, 2, 2, 2371, 2373, 3, 2, 2, 2, 2372, 2370, 3, 2, 2, 2, 2373, 2375, 7, 14, 2, 2, 2374, 2331, 3, 2, 2, 2, 2374, 2366, 3, 2, 2, 2, 2375, 193, 3, 2, 2, 2, 2376, 2377, 9, 4, 2, 2, 2377, 195, 3, 2, 2, 2, 2378, 2381, 5, 198, 100, 2, 2379, 2381, 5, 200, 101, 2, 2380, 2378, 3, 2, 2, 2, 2380, 2379, 3, 2, 2, 2, 2381, 197, 3, 2, 2, 2, 2382, 2387, 7, 136, 2, 2, 2383, 2386, 5, 202, 102, 2, 2384, 2386, 5, 204, 103, 2, 2385, 2383, 3, 2, 2, 2, 2385, 2384, 3, 2, 2, 2, 2386, 2389, 3, 2, 2, 2, 2387, 2385, 3, 2, 2, 2, 2387, 2388, 3, 2, 2, 2, 2388, 2390, 3, 2, 2, 2, 2389, 2387, 3, 2, 2, 2, 2390, 2391, 7, 162, 2, 2, 2391, 199, 3, 2, 2, 2, 2392, 2398, 7, 137, 2, 2, 2393, 2397, 5, 206, 104, 2, 2394, 2397, 5, 208, 105, 2, 2395, 2397, 7, 168, 2, 2, 2396, 2393, 3, 2, 2, 2, 2396, 2394, 3, 2, 2, 2, 2396, 2395, 3, 2, 2, 2, 2397, 2400, 3, 2, 2, 2, 2398, 2396, 3, 2, 2, 2, 2398, 2399, 3, 2, 2, 2, 2399, 2401, 3, 2, 2, 2, 2400, 2398, 3, 2, 2, 2, 2401, 2402, 7, 167, 2, 2, 2402, 201, 3, 2, 2, 2, 2403, 2404, 9, 5, 2, 2, 2404, 203, 3, 2, 2, 2, 2405, 2406, 7, 166, 2, 2, 2406, 2407, 5, 130, 66, 2, 2407, 2408, 7, 16, 2, 2, 2408, 205, 3, 2, 2, 2, 2409, 2410, 9, 6, 2, 2, 2410, 207, 3, 2, 2, 2, 2411, 2415, 7, 171, 2, 2, 2412, 2414, 7, 7, 2, 2, 2413, 2412, 3, 2, 2, 2, 2414, 2417, 3, 2, 2, 2, 2415, 2413, 3, 2, 2, 2, 2415, 2416, 3, 2, 2, 2, 2416, 2418, 3, 2, 2, 2, 2417, 2415, 3, 2, 2, 2, 2418, 2422, 5, 130, 66, 2, 2419, 2421, 7, 7, 2, 2, 2420, 2419, 3, 2, 2, 2, 2421, 2424, 3, 2, 2, 2, 2422, 2420, 3, 2, 2, 2, 2422, 2423, 3, 2, 2, 2, 2423, 2425, 3, 2, 2, 2, 2424, 2422, 3, 2, 2, 2, 2425, 2426, 7, 16, 2, 2, 2426, 209, 3, 2, 2, 2, 2427, 2431, 7, 15, 2, 2, 2428, 2430, 7, 7, 2, 2, 2429, 2428, 3, 2, 2, 2, 2430, 2433, 3, 2, 2, 2, 2431, 2429, 3, 2, 2, 2, 2431, 2432, 3, 2, 2, 2, 2432, 2434, 3, 2, 2, 2, 2433, 2431, 3, 2, 2, 2, 2434, 2438, 5, 122, 62, 2, 2435, 2437, 7, 7, 2, 2, 2436, 2435, 3, 2, 2, 2, 2437, 2440, 3, 2, 2, 2, 2438, 2436, 3, 2, 2, 2, 2438, 2439, 3, 2, 2, 2, 2439, 2441, 3, 2, 2, 2, 2440, 2438, 3, 2, 2, 2, 2441, 2442, 7, 16, 2, 2, 2442, 2476, 3, 2, 2, 2, 2443, 2447, 7, 15, 2, 2, 2444, 2446, 7, 7, 2, 2, 2445, 2444, 3, 2, 2, 2, 2446, 2449, 3, 2, 2, 2, 2447, 2445, 3, 2, 2, 2, 2447, 2448, 3, 2, 2, 2, 2448, 2451, 3, 2, 2, 2, 2449, 2447, 3, 2, 2, 2, 2450, 2452, 5, 212, 107, 2, 2451, 2450, 3, 2, 2, 2, 2451, 2452, 3, 2, 2, 2, 2452, 2456, 3, 2, 2, 2, 2453, 2455, 7, 7, 2, 2, 2454, 2453, 3, 2, 2, 2, 2455, 2458, 3, 2, 2, 2, 2456, 2454, 3, 2, 2, 2, 2456, 2457, 3, 2, 2, 2, 2457, 2459, 3, 2, 2, 2, 2458, 2456, 3, 2, 2, 2, 2459, 2463, 7, 36, 2, 2, 2460, 2462, 7, 7, 2, 2, 2461, 2460, 3, 2, 2, 2, 2462, 2465, 3, 2, 2, 2, 2463, 2461, 3, 2, 2, 2, 2463, 2464, 3, 2, 2, 2, 2464, 2466, 3, 2, 2, 2, 2465, 2463, 3, 2, 2, 2, 2466, 2470, 5, 122, 62, 2, 2467, 2469, 7, 7, 2, 2, 2468, 2467, 3, 2, 2, 2, 2469, 2472, 3, 2, 2, 2, 2470, 2468, 3, 2, 2, 2, 2470, 2471, 3, 2, 2, 2, 2471, 2473, 3, 2, 2, 2, 2472, 2470, 3, 2, 2, 2, 2473, 2474, 7, 16, 2, 2, 2474, 2476, 3, 2, 2, 2, 2475, 2427, 3, 2, 2, 2, 2475, 2443, 3, 2, 2, 2, 2476, 211, 3, 2, 2, 2, 2477, 2494, 5, 214, 108, 2, 2478, 2480, 7, 7, 2, 2, 2479, 2478, 3, 2, 2, 2, 2480, 2483, 3, 2, 2, 2, 2481, 2479, 3, 2, 2, 2, 2481, 2482, 3, 2, 2, 2, 2482, 2484, 3, 2, 2, 2, 2483, 2481, 3, 2, 2, 2, 2484, 2488, 7, 10, 2, 2, 2485, 2487, 7, 7, 2, 2, 2486, 2485, 3, 2, 2, 2, 2487, 2490, 3, 2, 2, 2, 2488, 2486, 3, 2, 2, 2, 2488, 2489, 3, 2, 2, 2, 2489, 2491, 3, 2, 2, 2, 2490, 2488, 3, 2, 2, 2, 2491, 2493, 5, 214, 108, 2, 2492, 2481, 3, 2, 2, 2, 2493, 2496, 3, 2, 2, 2, 2494, 2492, 3, 2, 2, 2, 2494, 2495, 3, 2, 2, 2, 2495, 213, 3, 2, 2, 2, 2496, 2494, 3, 2, 2, 2, 2497, 2516, 5, 74, 38, 2, 2498, 2513, 5, 72, 37, 2, 2499, 2501, 7, 7, 2, 2, 2500, 2499, 3, 2, 2, 2, 2501, 2504, 3, 2, 2, 2, 2502, 2500, 3, 2, 2, 2, 2502, 2503, 3, 2, 2, 2, 2503, 2505, 3, 2, 2, 2, 2504, 2502, 3, 2, 2, 2, 2505, 2509, 7, 28, 2, 2, 2506, 2508, 7, 7, 2, 2, 2507, 2506, 3, 2, 2, 2, 2508, 2511, 3, 2, 2, 2, 2509, 2507, 3, 2, 2, 2, 2509, 2510, 3, 2, 2, 2, 2510, 2512, 3, 2, 2, 2, 2511, 2509, 3, 2, 2, 2, 2512, 2514, 5, 92, 47, 2, 2513, 2502, 3, 2, 2, 2, 2513, 2514, 3, 2, 2, 2, 2514, 2516, 3, 2, 2, 2, 2515, 2497, 3, 2, 2, 2, 2515, 2498, 3, 2, 2, 2, 2516, 215, 3, 2, 2, 2, 2517, 2533, 7, 65, 2, 2, 2518, 2520, 7, 7, 2, 2, 2519, 2518, 3, 2, 2, 2, 2520, 2523, 3, 2, 2, 2, 2521, 2519, 3, 2, 2, 2, 2521, 2522, 3, 2, 2, 2, 2522, 2524, 3, 2, 2, 2, 2523, 2521, 3, 2, 2, 2, 2524, 2528, 5, 92, 47, 2, 2525, 2527, 7, 7, 2, 2, 2526, 2525, 3, 2, 2, 2, 2527, 2530, 3, 2, 2, 2, 2528, 2526, 3, 2, 2, 2, 2528, 2529, 3, 2, 2, 2, 2529, 2531, 3, 2, 2, 2, 2530, 2528, 3, 2, 2, 2, 2531, 2532, 7, 9, 2, 2, 2532, 2534, 3, 2, 2, 2, 2533, 2521, 3, 2, 2, 2, 2533, 2534, 3, 2, 2, 2, 2534, 2538, 3, 2, 2, 2, 2535, 2537, 7, 7, 2, 2, 2536, 2535, 3, 2, 2, 2, 2537, 2540, 3, 2, 2, 2, 2538, 2536, 3, 2, 2, 2, 2538, 2539, 3, 2, 2, 2, 2539, 2541, 3, 2, 2, 2, 2540, 2538, 3, 2, 2, 2, 2541, 2556, 5, 56, 29, 2, 2542, 2544, 7, 7, 2, 2, 2543, 2542, 3, 2, 2, 2, 2544, 2547, 3, 2, 2, 2, 2545, 2543, 3, 2, 2, 2, 2545, 2546, 3, 2, 2, 2, 2546, 2548, 3, 2, 2, 2, 2547, 2545, 3, 2, 2, 2, 2548, 2552, 7, 28, 2, 2, 2549, 2551, 7, 7, 2, 2, 2550, 2549, 3, 2, 2, 2, 2551, 2554, 3, 2, 2, 2, 2552, 2550, 3, 2, 2, 2, 2552, 2553, 3, 2, 2, 2, 2553, 2555, 3, 2, 2, 2, 2554, 2552, 3, 2, 2, 2, 2555, 2557, 5, 92, 47, 2, 2556, 2545, 3, 2, 2, 2, 2556, 2557, 3, 2, 2, 2, 2557, 2565, 3, 2, 2, 2, 2558, 2560, 7, 7, 2, 2, 2559, 2558, 3, 2, 2, 2, 2560, 2563, 3, 2, 2, 2, 2561, 2559, 3, 2, 2, 2, 2561, 2562, 3, 2, 2, 2, 2562, 2564, 3, 2, 2, 2, 2563, 2561, 3, 2, 2, 2, 2564, 2566, 5, 116, 59, 2, 2565, 2561, 3, 2, 2, 2, 2565, 2566, 3, 2, 2, 2, 2566, 2574, 3, 2, 2, 2, 2567, 2569, 7, 7, 2, 2, 2568, 2567, 3, 2, 2, 2, 2569, 2572, 3, 2, 2, 2, 2570, 2568, 3, 2, 2, 2, 2570, 2571, 3, 2, 2, 2, 2571, 2573, 3, 2, 2, 2, 2572, 2570, 3, 2, 2, 2, 2573, 2575, 5, 64, 33, 2, 2574, 2570, 3, 2, 2, 2, 2574, 2575, 3, 2, 2, 2, 2575, 217, 3, 2, 2, 2, 2576, 2579, 5, 210, 106, 2, 2577, 2579, 5, 216, 109, 2, 2578, 2576, 3, 2, 2, 2, 2578, 2577, 3, 2, 2, 2, 2579, 219, 3, 2, 2, 2, 2580, 2584, 7, 66, 2, 2, 2581, 2583, 7, 7, 2, 2, 2582, 2581, 3, 2, 2, 2, 2583, 2586, 3, 2, 2, 2, 2584, 2582, 3, 2, 2, 2, 2584, 2585, 3, 2, 2, 2, 2585, 2587, 3, 2, 2, 2, 2586, 2584, 3, 2, 2, 2, 2587, 2591, 7, 28, 2, 2, 2588, 2590, 7, 7, 2, 2, 2589, 2588, 3, 2, 2, 2, 2590, 2593, 3, 2, 2, 2, 2591, 2589, 3, 2, 2, 2, 2591, 2592, 3, 2, 2, 2, 2592, 2594, 3, 2, 2, 2, 2593, 2591, 3, 2, 2, 2, 2594, 2602, 5, 26, 14, 2, 2595, 2597, 7, 7, 2, 2, 2596, 2595, 3, 2, 2, 2, 2597, 2600, 3, 2, 2, 2, 2598, 2596, 3, 2, 2, 2, 2598, 2599, 3, 2, 2, 2, 2599, 2601, 3, 2, 2, 2, 2600, 2598, 3, 2, 2, 2, 2601, 2603, 5, 36, 19, 2, 2602, 2598, 3, 2, 2, 2, 2602, 2603, 3, 2, 2, 2, 2603, 2613, 3, 2, 2, 2, 2604, 2608, 7, 66, 2, 2, 2605, 2607, 7, 7, 2, 2, 2606, 2605, 3, 2, 2, 2, 2607, 2610, 3, 2, 2, 2, 2608, 2606, 3, 2, 2, 2, 2608, 2609, 3, 2, 2, 2, 2609, 2611, 3, 2, 2, 2, 2610, 2608, 3, 2, 2, 2, 2611, 2613, 5, 36, 19, 2, 2612, 2580, 3, 2, 2, 2, 2612, 2604, 3, 2, 2, 2, 2613, 221, 3, 2, 2, 2, 2614, 2615, 9, 7, 2, 2, 2615, 223, 3, 2, 2, 2, 2616, 2633, 7, 75, 2, 2, 2617, 2621, 7, 46, 2, 2, 2618, 2620, 7, 7, 2, 2, 2619, 2618, 3, 2, 2, 2, 2620, 2623, 3, 2, 2, 2, 2621, 2619, 3, 2, 2, 2, 2621, 2622, 3, 2, 2, 2, 2622, 2624, 3, 2, 2, 2, 2623, 2621, 3, 2, 2, 2, 2624, 2628, 5, 92, 47, 2, 2625, 2627, 7, 7, 2, 2, 2626, 2625, 3, 2, 2, 2, 2627, 2630, 3, 2, 2, 2, 2628, 2626, 3, 2, 2, 2, 2628, 2629, 3, 2, 2, 2, 2629, 2631, 3, 2, 2, 2, 2630, 2628, 3, 2, 2, 2, 2631, 2632, 7, 47, 2, 2, 2632, 2634, 3, 2, 2, 2, 2633, 2617, 3, 2, 2, 2, 2633, 2634, 3, 2, 2, 2, 2634, 2637, 3, 2, 2, 2, 2635, 2636, 7, 42, 2, 2, 2636, 2638, 5, 316, 159, 2, 2637, 2635, 3, 2, 2, 2, 2637, 2638, 3, 2, 2, 2, 2638, 2641, 3, 2, 2, 2, 2639, 2641, 7, 60, 2, 2, 2640, 2616, 3, 2, 2, 2, 2640, 2639, 3, 2, 2, 2, 2641, 225, 3, 2, 2, 2, 2642, 2645, 5, 120, 61, 2, 2643, 2645, 5, 124, 63, 2, 2644, 2642, 3, 2, 2, 2, 2644, 2643, 3, 2, 2, 2, 2645, 227, 3, 2, 2, 2, 2646, 2650, 7, 78, 2, 2, 2647, 2649, 7, 7, 2, 2, 2648, 2647, 3, 2, 2, 2, 2649, 2652, 3, 2, 2, 2, 2650, 2648, 3, 2, 2, 2, 2650, 2651, 3, 2, 2, 2, 2651, 2653, 3, 2, 2, 2, 2652, 2650, 3, 2, 2, 2, 2653, 2657, 7, 11, 2, 2, 2654, 2656, 7, 7, 2, 2, 2655, 2654, 3, 2, 2, 2, 2656, 2659, 3, 2, 2, 2, 2657, 2655, 3, 2, 2, 2, 2657, 2658, 3, 2, 2, 2, 2658, 2660, 3, 2, 2, 2, 2659, 2657, 3, 2, 2, 2, 2660, 2664, 5, 130, 66, 2, 2661, 2663, 7, 7, 2, 2, 2662, 2661, 3, 2, 2, 2, 2663, 2666, 3, 2, 2, 2, 2664, 2662, 3, 2, 2, 2, 2664, 2665, 3, 2, 2, 2, 2665, 2667, 3, 2, 2, 2, 2666, 2664, 3, 2, 2, 2, 2667, 2671, 7, 12, 2, 2, 2668, 2670, 7, 7, 2, 2, 2669, 2668, 3, 2, 2, 2, 2670, 2673, 3, 2, 2, 2, 2671, 2669, 3, 2, 2, 2, 2671, 2672, 3, 2, 2, 2, 2672, 2674, 3, 2, 2, 2, 2673, 2671, 3, 2, 2, 2, 2674, 2692, 5, 226, 114, 2, 2675, 2677, 7, 29, 2, 2, 2676, 2675, 3, 2, 2, 2, 2676, 2677, 3, 2, 2, 2, 2677, 2681, 3, 2, 2, 2, 2678, 2680, 7, 7, 2, 2, 2679, 2678, 3, 2, 2, 2, 2680, 2683, 3, 2, 2, 2, 2681, 2679, 3, 2, 2, 2, 2681, 2682, 3, 2, 2, 2, 2682, 2684, 3, 2, 2, 2, 2683, 2681, 3, 2, 2, 2, 2684, 2688, 7, 79, 2, 2, 2685, 2687, 7, 7, 2, 2, 2686, 2685, 3, 2, 2, 2, 2687, 2690, 3, 2, 2, 2, 2688, 2686, 3, 2, 2, 2, 2688, 2689, 3, 2, 2, 2, 2689, 2691, 3, 2, 2, 2, 2690, 2688, 3, 2, 2, 2, 2691, 2693, 5, 226, 114, 2, 2692, 2676, 3, 2, 2, 2, 2692, 2693, 3, 2, 2, 2, 2693, 2741, 3, 2, 2, 2, 2694, 2698, 7, 78, 2, 2, 2695, 2697, 7, 7, 2, 2, 2696, 2695, 3, 2, 2, 2, 2697, 2700, 3, 2, 2, 2, 2698, 2696, 3, 2, 2, 2, 2698, 2699, 3, 2, 2, 2, 2699, 2701, 3, 2, 2, 2, 2700, 2698, 3, 2, 2, 2, 2701, 2705, 7, 11, 2, 2, 2702, 2704, 7, 7, 2, 2, 2703, 2702, 3, 2, 2, 2, 2704, 2707, 3, 2, 2, 2, 2705, 2703, 3, 2, 2, 2, 2705, 2706, 3, 2, 2, 2, 2706, 2708, 3, 2, 2, 2, 2707, 2705, 3, 2, 2, 2, 2708, 2712, 5, 130, 66, 2, 2709, 2711, 7, 7, 2, 2, 2710, 2709, 3, 2, 2, 2, 2711, 2714, 3, 2, 2, 2, 2712, 2710, 3, 2, 2, 2, 2712, 2713, 3, 2, 2, 2, 2713, 2715, 3, 2, 2, 2, 2714, 2712, 3, 2, 2, 2, 2715, 2719, 7, 12, 2, 2, 2716, 2718, 7, 7, 2, 2, 2717, 2716, 3, 2, 2, 2, 2718, 2721, 3, 2, 2, 2, 2719, 2717, 3, 2, 2, 2, 2719, 2720, 3, 2, 2, 2, 2720, 2729, 3, 2, 2, 2, 2721, 2719, 3, 2, 2, 2, 2722, 2726, 7, 29, 2, 2, 2723, 2725, 7, 7, 2, 2, 2724, 2723, 3, 2, 2, 2, 2725, 2728, 3, 2, 2, 2, 2726, 2724, 3, 2, 2, 2, 2726, 2727, 3, 2, 2, 2, 2727, 2730, 3, 2, 2, 2, 2728, 2726, 3, 2, 2, 2, 2729, 2722, 3, 2, 2, 2, 2729, 2730, 3, 2, 2, 2, 2730, 2731, 3, 2, 2, 2, 2731, 2735, 7, 79, 2, 2, 2732, 2734, 7, 7, 2, 2, 2733, 2732, 3, 2, 2, 2, 2734, 2737, 3, 2, 2, 2, 2735, 2733, 3, 2, 2, 2, 2735, 2736, 3, 2, 2, 2, 2736, 2738, 3, 2, 2, 2, 2737, 2735, 3, 2, 2, 2, 2738, 2739, 5, 226, 114, 2, 2739, 2741, 3, 2, 2, 2, 2740, 2646, 3, 2, 2, 2, 2740, 2694, 3, 2, 2, 2, 2741, 229, 3, 2, 2, 2, 2742, 2746, 7, 80, 2, 2, 2743, 2745, 7, 7, 2, 2, 2744, 2743, 3, 2, 2, 2, 2745, 2748, 3, 2, 2, 2, 2746, 2744, 3, 2, 2, 2, 2746, 2747, 3, 2, 2, 2, 2747, 2753, 3, 2, 2, 2, 2748, 2746, 3, 2, 2, 2, 2749, 2750, 7, 11, 2, 2, 2750, 2751, 5, 130, 66, 2, 2751, 2752, 7, 12, 2, 2, 2752, 2754, 3, 2, 2, 2, 2753, 2749, 3, 2, 2, 2, 2753, 2754, 3, 2, 2, 2, 2754, 2758, 3, 2, 2, 2, 2755, 2757, 7, 7, 2, 2, 2756, 2755, 3, 2, 2, 2, 2757, 2760, 3, 2, 2, 2, 2758, 2756, 3, 2, 2, 2, 2758, 2759, 3, 2, 2, 2, 2759, 2761, 3, 2, 2, 2, 2760, 2758, 3, 2, 2, 2, 2761, 2765, 7, 15, 2, 2, 2762, 2764, 7, 7, 2, 2, 2763, 2762, 3, 2, 2, 2, 2764, 2767, 3, 2, 2, 2, 2765, 2763, 3, 2, 2, 2, 2765, 2766, 3, 2, 2, 2, 2766, 2777, 3, 2, 2, 2, 2767, 2765, 3, 2, 2, 2, 2768, 2772, 5, 232, 117, 2, 2769, 2771, 7, 7, 2, 2, 2770, 2769, 3, 2, 2, 2, 2771, 2774, 3, 2, 2, 2, 2772, 2770, 3, 2, 2, 2, 2772, 2773, 3, 2, 2, 2, 2773, 2776, 3, 2, 2, 2, 2774, 2772, 3, 2, 2, 2, 2775, 2768, 3, 2, 2, 2, 2776, 2779, 3, 2, 2, 2, 2777, 2775, 3, 2, 2, 2, 2777, 2778, 3, 2, 2, 2, 2778, 2783, 3, 2, 2, 2, 2779, 2777, 3, 2, 2, 2, 2780, 2782, 7, 7, 2, 2, 2781, 2780, 3, 2, 2, 2, 2782, 2785, 3, 2, 2, 2, 2783, 2781, 3, 2, 2, 2, 2783, 2784, 3, 2, 2, 2, 2784, 2786, 3, 2, 2, 2, 2785, 2783, 3, 2, 2, 2, 2786, 2787, 7, 16, 2, 2, 2787, 231, 3, 2, 2, 2, 2788, 2805, 5, 234, 118, 2, 2789, 2791, 7, 7, 2, 2, 2790, 2789, 3, 2, 2, 2, 2791, 2794, 3, 2, 2, 2, 2792, 2790, 3, 2, 2, 2, 2792, 2793, 3, 2, 2, 2, 2793, 2795, 3, 2, 2, 2, 2794, 2792, 3, 2, 2, 2, 2795, 2799, 7, 10, 2, 2, 2796, 2798, 7, 7, 2, 2, 2797, 2796, 3, 2, 2, 2, 2798, 2801, 3, 2, 2, 2, 2799, 2797, 3, 2, 2, 2, 2799, 2800, 3, 2, 2, 2, 2800, 2802, 3, 2, 2, 2, 2801, 2799, 3, 2, 2, 2, 2802, 2804, 5, 234, 118, 2, 2803, 2792, 3, 2, 2, 2, 2804, 2807, 3, 2, 2, 2, 2805, 2803, 3, 2, 2, 2, 2805, 2806, 3, 2, 2, 2, 2806, 2811, 3, 2, 2, 2, 2807, 2805, 3, 2, 2, 2, 2808, 2810, 7, 7, 2, 2, 2809, 2808, 3, 2, 2, 2, 2810, 2813, 3, 2, 2, 2, 2811, 2809, 3, 2, 2, 2, 2811, 2812, 3, 2, 2, 2, 2812, 2814, 3, 2, 2, 2, 2813, 2811, 3, 2, 2, 2, 2814, 2818, 7, 36, 2, 2, 2815, 2817, 7, 7, 2, 2, 2816, 2815, 3, 2, 2, 2, 2817, 2820, 3, 2, 2, 2, 2818, 2816, 3, 2, 2, 2, 2818, 2819, 3, 2, 2, 2, 2819, 2821, 3, 2, 2, 2, 2820, 2818, 3, 2, 2, 2, 2821, 2823, 5, 226, 114, 2, 2822, 2824, 5, 330, 166, 2, 2823, 2822, 3, 2, 2, 2, 2823, 2824, 3, 2, 2, 2, 2824, 2844, 3, 2, 2, 2, 2825, 2829, 7, 79, 2, 2, 2826, 2828, 7, 7, 2, 2, 2827, 2826, 3, 2, 2, 2, 2828, 2831, 3, 2, 2, 2, 2829, 2827, 3, 2, 2, 2, 2829, 2830, 3, 2, 2, 2, 2830, 2832, 3, 2, 2, 2, 2831, 2829, 3, 2, 2, 2, 2832, 2836, 7, 36, 2, 2, 2833, 2835, 7, 7, 2, 2, 2834, 2833, 3, 2, 2, 2, 2835, 2838, 3, 2, 2, 2, 2836, 2834, 3, 2, 2, 2, 2836, 2837, 3, 2, 2, 2, 2837, 2839, 3, 2, 2, 2, 2838, 2836, 3, 2, 2, 2, 2839, 2841, 5, 226, 114, 2, 2840, 2842, 5, 330, 166, 2, 2841, 2840, 3, 2, 2, 2, 2841, 2842, 3, 2, 2, 2, 2842, 2844, 3, 2, 2, 2, 2843, 2788, 3, 2, 2, 2, 2843, 2825, 3, 2, 2, 2, 2844, 233, 3, 2, 2, 2, 2845, 2849, 5, 130, 66, 2, 2846, 2849, 5, 236, 119, 2, 2847, 2849, 5, 238, 120, 2, 2848, 2845, 3, 2, 2, 2, 2848, 2846, 3, 2, 2, 2, 2848, 2847, 3, 2, 2, 2, 2849, 235, 3, 2, 2, 2, 2850, 2854, 5, 264, 133, 2, 2851, 2853, 7, 7, 2, 2, 2852, 2851, 3, 2, 2, 2, 2853, 2856, 3, 2, 2, 2, 2854, 2852, 3, 2, 2, 2, 2854, 2855, 3, 2, 2, 2, 2855, 2857, 3, 2, 2, 2, 2856, 2854, 3, 2, 2, 2, 2857, 2858, 5, 130, 66, 2, 2858, 237, 3, 2, 2, 2, 2859, 2863, 5, 266, 134, 2, 2860, 2862, 7, 7, 2, 2, 2861, 2860, 3, 2, 2, 2, 2862, 2865, 3, 2, 2, 2, 2863, 2861, 3, 2, 2, 2, 2863, 2864, 3, 2, 2, 2, 2864, 2866, 3, 2, 2, 2, 2865, 2863, 3, 2, 2, 2, 2866, 2867, 5, 92, 47, 2, 2867, 239, 3, 2, 2, 2, 2868, 2872, 7, 81, 2, 2, 2869, 2871, 7, 7, 2, 2, 2870, 2869, 3, 2, 2, 2, 2871, 2874, 3, 2, 2, 2, 2872, 2870, 3, 2, 2, 2, 2872, 2873, 3, 2, 2, 2, 2873, 2875, 3, 2, 2, 2, 2874, 2872, 3, 2, 2, 2, 2875, 2903, 5, 120, 61, 2, 2876, 2878, 7, 7, 2, 2, 2877, 2876, 3, 2, 2, 2, 2878, 2881, 3, 2, 2, 2, 2879, 2877, 3, 2, 2, 2, 2879, 2880, 3, 2, 2, 2, 2880, 2882, 3, 2, 2, 2, 2881, 2879, 3, 2, 2, 2, 2882, 2884, 5, 242, 122, 2, 2883, 2879, 3, 2, 2, 2, 2884, 2885, 3, 2, 2, 2, 2885, 2883, 3, 2, 2, 2, 2885, 2886, 3, 2, 2, 2, 2886, 2894, 3, 2, 2, 2, 2887, 2889, 7, 7, 2, 2, 2888, 2887, 3, 2, 2, 2, 2889, 2892, 3, 2, 2, 2, 2890, 2888, 3, 2, 2, 2, 2890, 2891, 3, 2, 2, 2, 2891, 2893, 3, 2, 2, 2, 2892, 2890, 3, 2, 2, 2, 2893, 2895, 5, 244, 123, 2, 2894, 2890, 3, 2, 2, 2, 2894, 2895, 3, 2, 2, 2, 2895, 2904, 3, 2, 2, 2, 2896, 2898, 7, 7, 2, 2, 2897, 2896, 3, 2, 2, 2, 2898, 2901, 3, 2, 2, 2, 2899, 2897, 3, 2, 2, 2, 2899, 2900, 3, 2, 2, 2, 2900, 2902, 3, 2, 2, 2, 2901, 2899, 3, 2, 2, 2, 2902, 2904, 5, 244, 123, 2, 2903, 2883, 3, 2, 2, 2, 2903, 2899, 3, 2, 2, 2, 2904, 241, 3, 2, 2, 2, 2905, 2909, 7, 82, 2, 2, 2906, 2908, 7, 7, 2, 2, 2907, 2906, 3, 2, 2, 2, 2908, 2911, 3, 2, 2, 2, 2909, 2907, 3, 2, 2, 2, 2909, 2910, 3, 2, 2, 2, 2910, 2912, 3, 2, 2, 2, 2911, 2909, 3, 2, 2, 2, 2912, 2916, 7, 11, 2, 2, 2913, 2915, 5, 306, 154, 2, 2914, 2913, 3, 2, 2, 2, 2915, 2918, 3, 2, 2, 2, 2916, 2914, 3, 2, 2, 2, 2916, 2917, 3, 2, 2, 2, 2917, 2919, 3, 2, 2, 2, 2918, 2916, 3, 2, 2, 2, 2919, 2920, 5, 316, 159, 2, 2920, 2921, 7, 28, 2, 2, 2921, 2922, 5, 108, 55, 2, 2922, 2926, 7, 12, 2, 2, 2923, 2925, 7, 7, 2, 2, 2924, 2923, 3, 2, 2, 2, 2925, 2928, 3, 2, 2, 2, 2926, 2924, 3, 2, 2, 2, 2926, 2927, 3, 2, 2, 2, 2927, 2929, 3, 2, 2, 2, 2928, 2926, 3, 2, 2, 2, 2929, 2930, 5, 120, 61, 2, 2930, 243, 3, 2, 2, 2, 2931, 2935, 7, 83, 2, 2, 2932, 2934, 7, 7, 2, 2, 2933, 2932, 3, 2, 2, 2, 2934, 2937, 3, 2, 2, 2, 2935, 2933, 3, 2, 2, 2, 2935, 2936, 3, 2, 2, 2, 2936, 2938, 3, 2, 2, 2, 2937, 2935, 3, 2, 2, 2, 2938, 2939, 5, 120, 61, 2, 2939, 245, 3, 2, 2, 2, 2940, 2944, 5, 248, 125, 2, 2941, 2944, 5, 250, 126, 2, 2942, 2944, 5, 252, 127, 2, 2943, 2940, 3, 2, 2, 2, 2943, 2941, 3, 2, 2, 2, 2943, 2942, 3, 2, 2, 2, 2944, 247, 3, 2, 2, 2, 2945, 2949, 7, 84, 2, 2, 2946, 2948, 7, 7, 2, 2, 2947, 2946, 3, 2, 2, 2, 2948, 2951, 3, 2, 2, 2, 2949, 2947, 3, 2, 2, 2, 2949, 2950, 3, 2, 2, 2, 2950, 2952, 3, 2, 2, 2, 2951, 2949, 3, 2, 2, 2, 2952, 2956, 7, 11, 2, 2, 2953, 2955, 5, 306, 154, 2, 2954, 2953, 3, 2, 2, 2, 2955, 2958, 3, 2, 2, 2, 2956, 2954, 3, 2, 2, 2, 2956, 2957, 3, 2, 2, 2, 2957, 2961, 3, 2, 2, 2, 2958, 2956, 3, 2, 2, 2, 2959, 2962, 5, 74, 38, 2, 2960, 2962, 5, 72, 37, 2, 2961, 2959, 3, 2, 2, 2, 2961, 2960, 3, 2, 2, 2, 2962, 2963, 3, 2, 2, 2, 2963, 2964, 7, 93, 2, 2, 2964, 2965, 5, 130, 66, 2, 2965, 2969, 7, 12, 2, 2, 2966, 2968, 7, 7, 2, 2, 2967, 2966, 3, 2, 2, 2, 2968, 2971, 3, 2, 2, 2, 2969, 2967, 3, 2, 2, 2, 2969, 2970, 3, 2, 2, 2, 2970, 2973, 3, 2, 2, 2, 2971, 2969, 3, 2, 2, 2, 2972, 2974, 5, 226, 114, 2, 2973, 2972, 3, 2, 2, 2, 2973, 2974, 3, 2, 2, 2, 2974, 249, 3, 2, 2, 2, 2975, 2979, 7, 86, 2, 2, 2976, 2978, 7, 7, 2, 2, 2977, 2976, 3, 2, 2, 2, 2978, 2981, 3, 2, 2, 2, 2979, 2977, 3, 2, 2, 2, 2979, 2980, 3, 2, 2, 2, 2980, 2982, 3, 2, 2, 2, 2981, 2979, 3, 2, 2, 2, 2982, 2983, 7, 11, 2, 2, 2983, 2984, 5, 130, 66, 2, 2984, 2988, 7, 12, 2, 2, 2985, 2987, 7, 7, 2, 2, 2986, 2985, 3, 2, 2, 2, 2987, 2990, 3, 2, 2, 2, 2988, 2986, 3, 2, 2, 2, 2988, 2989, 3, 2, 2, 2, 2989, 2991, 3, 2, 2, 2, 2990, 2988, 3, 2, 2, 2, 2991, 2992, 5, 226, 114, 2, 2992, 3012, 3, 2, 2, 2, 2993, 2997, 7, 86, 2, 2, 2994, 2996, 7, 7, 2, 2, 2995, 2994, 3, 2, 2, 2, 2996, 2999, 3, 2, 2, 2, 2997, 2995, 3, 2, 2, 2, 2997, 2998, 3, 2, 2, 2, 2998, 3000, 3, 2, 2, 2, 2999, 2997, 3, 2, 2, 2, 3000, 3001, 7, 11, 2, 2, 3001, 3002, 5, 130, 66, 2, 3002, 3006, 7, 12, 2, 2, 3003, 3005, 7, 7, 2, 2, 3004, 3003, 3, 2, 2, 2, 3005, 3008, 3, 2, 2, 2, 3006, 3004, 3, 2, 2, 2, 3006, 3007, 3, 2, 2, 2, 3007, 3009, 3, 2, 2, 2, 3008, 3006, 3, 2, 2, 2, 3009, 3010, 7, 29, 2, 2, 3010, 3012, 3, 2, 2, 2, 3011, 2975, 3, 2, 2, 2, 3011, 2993, 3, 2, 2, 2, 3012, 251, 3, 2, 2, 2, 3013, 3017, 7, 85, 2, 2, 3014, 3016, 7, 7, 2, 2, 3015, 3014, 3, 2, 2, 2, 3016, 3019, 3, 2, 2, 2, 3017, 3015, 3, 2, 2, 2, 3017, 3018, 3, 2, 2, 2, 3018, 3021, 3, 2, 2, 2, 3019, 3017, 3, 2, 2, 2, 3020, 3022, 5, 226, 114, 2, 3021, 3020, 3, 2, 2, 2, 3021, 3022, 3, 2, 2, 2, 3022, 3026, 3, 2, 2, 2, 3023, 3025, 7, 7, 2, 2, 3024, 3023, 3, 2, 2, 2, 3025, 3028, 3, 2, 2, 2, 3026, 3024, 3, 2, 2, 2, 3026, 3027, 3, 2, 2, 2, 3027, 3029, 3, 2, 2, 2, 3028, 3026, 3, 2, 2, 2, 3029, 3033, 7, 86, 2, 2, 3030, 3032, 7, 7, 2, 2, 3031, 3030, 3, 2, 2, 2, 3032, 3035, 3, 2, 2, 2, 3033, 3031, 3, 2, 2, 2, 3033, 3034, 3, 2, 2, 2, 3034, 3036, 3, 2, 2, 2, 3035, 3033, 3, 2, 2, 2, 3036, 3037, 7, 11, 2, 2, 3037, 3038, 5, 130, 66, 2, 3038, 3039, 7, 12, 2, 2, 3039, 253, 3, 2, 2, 2, 3040, 3044, 7, 87, 2, 2, 3041, 3043, 7, 7, 2, 2, 3042, 3041, 3, 2, 2, 2, 3043, 3046, 3, 2, 2, 2, 3044, 3042, 3, 2, 2, 2, 3044, 3045, 3, 2, 2, 2, 3045, 3047, 3, 2, 2, 2, 3046, 3044, 3, 2, 2, 2, 3047, 3057, 5, 130, 66, 2, 3048, 3050, 9, 8, 2, 2, 3049, 3051, 5, 130, 66, 2, 3050, 3049, 3, 2, 2, 2, 3050, 3051, 3, 2, 2, 2, 3051, 3057, 3, 2, 2, 2, 3052, 3057, 7, 89, 2, 2, 3053, 3057, 7, 57, 2, 2, 3054, 3057, 7, 90, 2, 2, 3055, 3057, 7, 58, 2, 2, 3056, 3040, 3, 2, 2, 2, 3056, 3048, 3, 2, 2, 2, 3056, 3052, 3, 2, 2, 2, 3056, 3053, 3, 2, 2, 2, 3056, 3054, 3, 2, 2, 2, 3056, 3055, 3, 2, 2, 2, 3057, 255, 3, 2, 2, 2, 3058, 3060, 5, 106, 54, 2, 3059, 3058, 3, 2, 2, 2, 3059, 3060, 3, 2, 2, 2, 3060, 3064, 3, 2, 2, 2, 3061, 3063, 7, 7, 2, 2, 3062, 3061, 3, 2, 2, 2, 3063, 3066, 3, 2, 2, 2, 3064, 3062, 3, 2, 2, 2, 3064, 3065, 3, 2, 2, 2, 3065, 3067, 3, 2, 2, 2, 3066, 3064, 3, 2, 2, 2, 3067, 3071, 7, 39, 2, 2, 3068, 3070, 7, 7, 2, 2, 3069, 3068, 3, 2, 2, 2, 3070, 3073, 3, 2, 2, 2, 3071, 3069, 3, 2, 2, 2, 3071, 3072, 3, 2, 2, 2, 3072, 3076, 3, 2, 2, 2, 3073, 3071, 3, 2, 2, 2, 3074, 3077, 5, 316, 159, 2, 3075, 3077, 7, 63, 2, 2, 3076, 3074, 3, 2, 2, 2, 3076, 3075, 3, 2, 2, 2, 3077, 257, 3, 2, 2, 2, 3078, 3079, 9, 9, 2, 2, 3079, 259, 3, 2, 2, 2, 3080, 3081, 9, 10, 2, 2, 3081, 261, 3, 2, 2, 2, 3082, 3083, 9, 11, 2, 2, 3083, 263, 3, 2, 2, 2, 3084, 3085, 9, 12, 2, 2, 3085, 265, 3, 2, 2, 2, 3086, 3087, 9, 13, 2, 2, 3087, 267, 3, 2, 2, 2, 3088, 3089, 9, 14, 2, 2, 3089, 269, 3, 2, 2, 2, 3090, 3091, 9, 15, 2, 2, 3091, 271, 3, 2, 2, 2, 3092, 3093, 9, 16, 2, 2, 3093, 273, 3, 2, 2, 2, 3094, 3100, 7, 22, 2, 2, 3095, 3100, 7, 23, 2, 2, 3096, 3100, 7, 21, 2, 2, 3097, 3100, 7, 20, 2, 2, 3098, 3100, 5, 328, 165, 2, 3099, 3094, 3, 2, 2, 2, 3099, 3095, 3, 2, 2, 2, 3099, 3096, 3, 2, 2, 2, 3099, 3097, 3, 2, 2, 2, 3099, 3098, 3, 2, 2, 2, 3100, 275, 3, 2, 2, 2, 3101, 3106, 7, 22, 2, 2, 3102, 3106, 7, 23, 2, 2, 3103, 3104, 7, 27, 2, 2, 3104, 3106, 5, 328, 165, 2, 3105, 3101, 3, 2, 2, 2, 3105, 3102, 3, 2, 2, 2, 3105, 3103, 3, 2, 2, 2, 3106, 277, 3, 2, 2, 2, 3107, 3111, 7, 9, 2, 2, 3108, 3111, 5, 326, 164, 2, 3109, 3111, 7, 39, 2, 2, 3110, 3107, 3, 2, 2, 2, 3110, 3108, 3, 2, 2, 2, 3110, 3109, 3, 2, 2, 2, 3111, 279, 3, 2, 2, 2, 3112, 3115, 5, 306, 154, 2, 3113, 3115, 5, 282, 142, 2, 3114, 3112, 3, 2, 2, 2, 3114, 3113, 3, 2, 2, 2, 3115, 3116, 3, 2, 2, 2, 3116, 3114, 3, 2, 2, 2, 3116, 3117, 3, 2, 2, 2, 3117, 281, 3, 2, 2, 2, 3118, 3127, 5, 284, 143, 2, 3119, 3127, 5, 286, 144, 2, 3120, 3127, 5, 288, 145, 2, 3121, 3127, 5, 292, 147, 2, 3122, 3127, 5, 294, 148, 2, 3123, 3127, 5, 296, 149, 2, 3124, 3127, 5, 298, 150, 2, 3125, 3127, 5, 302, 152, 2, 3126, 3118, 3, 2, 2, 2, 3126, 3119, 3, 2, 2, 2, 3126, 3120, 3, 2, 2, 2, 3126, 3121, 3, 2, 2, 2, 3126, 3122, 3, 2, 2, 2, 3126, 3123, 3, 2, 2, 2, 3126, 3124, 3, 2, 2, 2, 3126, 3125, 3, 2, 2, 2, 3127, 3131, 3, 2, 2, 2, 3128, 3130, 7, 7, 2, 2, 3129, 3128, 3, 2, 2, 2, 3130, 3133, 3, 2, 2, 2, 3131, 3129, 3, 2, 2, 2, 3131, 3132, 3, 2, 2, 2, 3132, 283, 3, 2, 2, 2, 3133, 3131, 3, 2, 2, 2, 3134, 3135, 9, 17, 2, 2, 3135, 285, 3, 2, 2, 2, 3136, 3137, 9, 18, 2, 2, 3137, 287, 3, 2, 2, 2, 3138, 3139, 9, 19, 2, 2, 3139, 289, 3, 2, 2, 2, 3140, 3141, 9, 20, 2, 2, 3141, 291, 3, 2, 2, 2, 3142, 3143, 9, 21, 2, 2, 3143, 293, 3, 2, 2, 2, 3144, 3145, 7, 128, 2, 2, 3145, 295, 3, 2, 2, 2, 3146, 3147, 9, 22, 2, 2, 3147, 297, 3, 2, 2, 2, 3148, 3149, 9, 23, 2, 2, 3149, 299, 3, 2, 2, 2, 3150, 3151, 7, 133, 2, 2, 3151, 301, 3, 2, 2, 2, 3152, 3153, 9, 24, 2, 2, 3153, 303, 3, 2, 2, 2, 3154, 3158, 7, 148, 2, 2, 3155, 3157, 7, 7, 2, 2, 3156, 3155, 3, 2, 2, 2, 3157, 3160, 3, 2, 2, 2, 3158, 3156, 3, 2, 2, 2, 3158, 3159, 3, 2, 2, 2, 3159, 305, 3, 2, 2, 2, 3160, 3158, 3, 2, 2, 2, 3161, 3164, 5, 308, 155, 2, 3162, 3164, 5, 310, 156, 2, 3163, 3161, 3, 2, 2, 2, 3163, 3162, 3, 2, 2, 2, 3164, 3168, 3, 2, 2, 2, 3165, 3167, 7, 7, 2, 2, 3166, 3165, 3, 2, 2, 2, 3167, 3170, 3, 2, 2, 2, 3168, 3166, 3, 2, 2, 2, 3168, 3169, 3, 2, 2, 2, 3169, 307, 3, 2, 2, 2, 3170, 3168, 3, 2, 2, 2, 3171, 3175, 5, 312, 157, 2, 3172, 3174, 7, 7, 2, 2, 3173, 3172, 3, 2, 2, 2, 3174, 3177, 3, 2, 2, 2, 3175, 3173, 3, 2, 2, 2, 3175, 3176, 3, 2, 2, 2, 3176, 3178, 3, 2, 2, 2, 3177, 3175, 3, 2, 2, 2, 3178, 3182, 7, 28, 2, 2, 3179, 3181, 7, 7, 2, 2, 3180, 3179, 3, 2, 2, 2, 3181, 3184, 3, 2, 2, 2, 3182, 3180, 3, 2, 2, 2, 3182, 3183, 3, 2, 2, 2, 3183, 3185, 3, 2, 2, 2, 3184, 3182, 3, 2, 2, 2, 3185, 3186, 5, 314, 158, 2, 3186, 3190, 3, 2, 2, 2, 3187, 3188, 7, 42, 2, 2, 3188, 3190, 5, 314, 158, 2, 3189, 3171, 3, 2, 2, 2, 3189, 3187, 3, 2, 2, 2, 3190, 309, 3, 2, 2, 2, 3191, 3195, 5, 312, 157, 2, 3192, 3194, 7, 7, 2, 2, 3193, 3192, 3, 2, 2, 2, 3194, 3197, 3, 2, 2, 2, 3195, 3193, 3, 2, 2, 2, 3195, 3196, 3, 2, 2, 2, 3196, 3198, 3, 2, 2, 2, 3197, 3195, 3, 2, 2, 2, 3198, 3202, 7, 28, 2, 2, 3199, 3201, 7, 7, 2, 2, 3200, 3199, 3, 2, 2, 2, 3201, 3204, 3, 2, 2, 2, 3202, 3200, 3, 2, 2, 2, 3202, 3203, 3, 2, 2, 2, 3203, 3205, 3, 2, 2, 2, 3204, 3202, 3, 2, 2, 2, 3205, 3207, 7, 13, 2, 2, 3206, 3208, 5, 314, 158, 2, 3207, 3206, 3, 2, 2, 2, 3208, 3209, 3, 2, 2, 2, 3209, 3207, 3, 2, 2, 2, 3209, 3210, 3, 2, 2, 2, 3210, 3211, 3, 2, 2, 2, 3211, 3212, 7, 14, 2, 2, 3212, 3223, 3, 2, 2, 2, 3213, 3214, 7, 42, 2, 2, 3214, 3216, 7, 13, 2, 2, 3215, 3217, 5, 314, 158, 2, 3216, 3215, 3, 2, 2, 2, 3217, 3218, 3, 2, 2, 2, 3218, 3216, 3, 2, 2, 2, 3218, 3219, 3, 2, 2, 2, 3219, 3220, 3, 2, 2, 2, 3220, 3221, 7, 14, 2, 2, 3221, 3223, 3, 2, 2, 2, 3222, 3191, 3, 2, 2, 2, 3222, 3213, 3, 2, 2, 2, 3223, 311, 3, 2, 2, 2, 3224, 3225, 9, 25, 2, 2, 3225, 313, 3, 2, 2, 2, 3226, 3229, 5, 32, 17, 2, 3227, 3229, 5, 108, 55, 2, 3228, 3226, 3, 2, 2, 2, 3228, 3227, 3, 2, 2, 2, 3229, 315, 3, 2, 2, 2, 3230, 3231, 9, 26, 2, 2, 3231, 317, 3, 2, 2, 2, 3232, 3243, 5, 316, 159, 2, 3233, 3235, 7, 7, 2, 2, 3234, 3233, 3, 2, 2, 2, 3235, 3238, 3, 2, 2, 2, 3236, 3234, 3, 2, 2, 2, 3236, 3237, 3, 2, 2, 2, 3237, 3239, 3, 2, 2, 2, 3238, 3236, 3, 2, 2, 2, 3239, 3240, 7, 9, 2, 2, 3240, 3242, 5, 316, 159, 2, 3241, 3236, 3, 2, 2, 2, 3242, 3245, 3, 2, 2, 2, 3243, 3241, 3, 2, 2, 2, 3243, 3244, 3, 2, 2, 2, 3244, 319, 3, 2, 2, 2, 3245, 3243, 3, 2, 2, 2, 3246, 3248, 7, 3, 2, 2, 3247, 3249, 7, 7, 2, 2, 3248, 3247, 3, 2, 2, 2, 3249, 3250, 3, 2, 2, 2, 3250, 3248, 3, 2, 2, 2, 3250, 3251, 3, 2, 2, 2, 3251, 321, 3, 2, 2, 2, 3252, 3253, 9, 27, 2, 2, 3253, 323, 3, 2, 2, 2, 3254, 3255, 7, 45, 2, 2, 3255, 3256, 7, 28, 2, 2, 3256, 325, 3, 2, 2, 2, 3257, 3258, 7, 45, 2, 2, 3258, 3259, 7, 9, 2, 2, 3259, 327, 3, 2, 2, 2, 3260, 3261, 9, 28, 2, 2, 3261, 329, 3, 2, 2, 2, 3262, 3266, 9, 29, 2, 2, 3263, 3265, 7, 7, 2, 2, 3264, 3263, 3, 2, 2, 2, 3265, 3268, 3, 2, 2, 2, 3266, 3264, 3, 2, 2, 2, 3266, 3267, 3, 2, 2, 2, 3267, 3271, 3, 2, 2, 2, 3268, 3266, 3, 2, 2, 2, 3269, 3271, 7, 2, 2, 3, 3270, 3262, 3, 2, 2, 2, 3270, 3269, 3, 2, 2, 2, 3271, 331, 3, 2, 2, 2, 3272, 3274, 9, 29, 2, 2, 3273, 3272, 3, 2, 2, 2, 3274, 3275, 3, 2, 2, 2, 3275, 3273, 3, 2, 2, 2, 3275, 3276, 3, 2, 2, 2, 3276, 3279, 3, 2, 2, 2, 3277, 3279, 7, 2, 2, 3, 3278, 3273, 3, 2, 2, 2, 3278, 3277, 3, 2, 2, 2, 3279, 333, 3, 2, 2, 2, 497, 335, 340, 346, 354, 360, 365, 371, 381, 390, 397, 404, 409, 414, 420, 422, 427, 435, 438, 445, 448, 454, 461, 465, 470, 474, 479, 486, 490, 495, 499, 504, 511, 515, 518, 524, 527, 535, 542, 549, 555, 558, 563, 569, 572, 577, 585, 592, 599, 603, 609, 616, 622, 628, 634, 643, 650, 655, 662, 671, 678, 685, 689, 696, 702, 708, 714, 721, 728, 732, 737, 741, 747, 755, 759, 765, 769, 774, 781, 785, 790, 799, 806, 812, 818, 822, 828, 831, 837, 841, 846, 850, 853, 859, 863, 868, 875, 880, 885, 892, 899, 906, 910, 915, 919, 924, 928, 934, 941, 948, 954, 957, 962, 968, 974, 981, 985, 991, 998, 1007, 1014, 1018, 1025, 1029, 1032, 1038, 1045, 1052, 1056, 1061, 1065, 1068, 1074, 1081, 1085, 1090, 1097, 1101, 1106, 1110, 1113, 1119, 1123, 1128, 1135, 1140, 1145, 1150, 1155, 1159, 1164, 1171, 1176, 1178, 1183, 1186, 1191, 1195, 1200, 1204, 1207, 1210, 1215, 1219, 1222, 1224, 1230, 1237, 1244, 1250, 1256, 1264, 1270, 1277, 1284, 1288, 1294, 1300, 1304, 1310, 1317, 1324, 1331, 1335, 1340, 1344, 1347, 1351, 1357, 1363, 1365, 1373, 1380, 1384, 1389, 1394, 1397, 1403, 1410, 1414, 1419, 1426, 1435, 1442, 1449, 1455, 1461, 1467, 1472, 1479, 1486, 1490, 1495, 1501, 1508, 1512, 1515, 1521, 1526, 1533, 1536, 1542, 1549, 1556, 1561, 1567, 1571, 1577, 1584, 1587, 1593, 1600, 1606, 1611, 1617, 1624, 1630, 1637, 1644, 1653, 1660, 1665, 1671, 1675, 1681, 1686, 1691, 1698, 1703, 1707, 1713, 1722, 1729, 1736, 1742, 1748, 1755, 1762, 1771, 1778, 1789, 1793, 1795, 1799, 1801, 1808, 1815, 1822, 1832, 1837, 1845, 1852, 1858, 1865, 1872, 1878, 1886, 1893, 1901, 1906, 1913, 1922, 1927, 1929, 1936, 1943, 1950, 1958, 1965, 1973, 1979, 1987, 1994, 2002, 2009, 2016, 2023, 2028, 2033, 2044, 2047, 2054, 2056, 2063, 2069, 2076, 2082, 2089, 2096, 2102, 2108, 2116, 2123, 2129, 2132, 2135, 2139, 2142, 2147, 2151, 2156, 2165, 2173, 2180, 2187, 2193, 2199, 2204, 2210, 2217, 2224, 2230, 2236, 2242, 2246, 2251, 2257, 2261, 2264, 2269, 2276, 2283, 2286, 2289, 2294, 2313, 2319, 2326, 2335, 2342, 2349, 2355, 2361, 2370, 2374, 2380, 2385, 2387, 2396, 2398, 2415, 2422, 2431, 2438, 2447, 2451, 2456, 2463, 2470, 2475, 2481, 2488, 2494, 2502, 2509, 2513, 2515, 2521, 2528, 2533, 2538, 2545, 2552, 2556, 2561, 2565, 2570, 2574, 2578, 2584, 2591, 2598, 2602, 2608, 2612, 2621, 2628, 2633, 2637, 2640, 2644, 2650, 2657, 2664, 2671, 2676, 2681, 2688, 2692, 2698, 2705, 2712, 2719, 2726, 2729, 2735, 2740, 2746, 2753, 2758, 2765, 2772, 2777, 2783, 2792, 2799, 2805, 2811, 2818, 2823, 2829, 2836, 2841, 2843, 2848, 2854, 2863, 2872, 2879, 2885, 2890, 2894, 2899, 2903, 2909, 2916, 2926, 2935, 2943, 2949, 2956, 2961, 2969, 2973, 2979, 2988, 2997, 3006, 3011, 3017, 3021, 3026, 3033, 3044, 3050, 3056, 3059, 3064, 3071, 3076, 3099, 3105, 3110, 3114, 3116, 3126, 3131, 3158, 3163, 3168, 3175, 3182, 3189, 3195, 3202, 3209, 3218, 3222, 3228, 3236, 3243, 3250, 3266, 3270, 3275, 3278] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.java deleted file mode 100644 index 416b419..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.java +++ /dev/null @@ -1,18386 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.kotlin;// Generated from KotlinParser.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.NoViableAltException; -import org.antlr.v4.runtime.Parser; -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.RecognitionException; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.ParserATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.Utils; -import org.antlr.v4.runtime.tree.ParseTreeListener; -import org.antlr.v4.runtime.tree.TerminalNode; - -import java.util.List; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class KotlinParser extends Parser { - static { RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ShebangLine=1, DelimitedComment=2, LineComment=3, WS=4, NL=5, RESERVED=6, - DOT=7, COMMA=8, LPAREN=9, RPAREN=10, LSQUARE=11, RSQUARE=12, LCURL=13, - RCURL=14, MULT=15, MOD=16, DIV=17, ADD=18, SUB=19, INCR=20, DECR=21, CONJ=22, - DISJ=23, EXCL_WS=24, EXCL_NO_WS=25, COLON=26, SEMICOLON=27, ASSIGNMENT=28, - ADD_ASSIGNMENT=29, SUB_ASSIGNMENT=30, MULT_ASSIGNMENT=31, DIV_ASSIGNMENT=32, - MOD_ASSIGNMENT=33, ARROW=34, DOUBLE_ARROW=35, RANGE=36, COLONCOLON=37, - DOUBLE_SEMICOLON=38, HASH=39, AT=40, AT_WS=41, QUEST_WS=42, QUEST_NO_WS=43, - LANGLE=44, RANGLE=45, LE=46, GE=47, EXCL_EQ=48, EXCL_EQEQ=49, AS_SAFE=50, - EQEQ=51, EQEQEQ=52, SINGLE_QUOTE=53, RETURN_AT=54, CONTINUE_AT=55, BREAK_AT=56, - THIS_AT=57, SUPER_AT=58, PACKAGE=59, IMPORT=60, CLASS=61, INTERFACE=62, - FUN=63, OBJECT=64, VAL=65, VAR=66, TYPE_ALIAS=67, CONSTRUCTOR=68, BY=69, - COMPANION=70, INIT=71, THIS=72, SUPER=73, TYPEOF=74, WHERE=75, IF=76, - ELSE=77, WHEN=78, TRY=79, CATCH=80, FINALLY=81, FOR=82, DO=83, WHILE=84, - THROW=85, RETURN=86, CONTINUE=87, BREAK=88, AS=89, IS=90, IN=91, NOT_IS=92, - NOT_IN=93, OUT=94, GETTER=95, SETTER=96, DYNAMIC=97, AT_FILE=98, AT_FIELD=99, - AT_PROPERTY=100, AT_GET=101, AT_SET=102, AT_RECEIVER=103, AT_PARAM=104, - AT_SETPARAM=105, AT_DELEGATE=106, PUBLIC=107, PRIVATE=108, PROTECTED=109, - INTERNAL=110, ENUM=111, SEALED=112, ANNOTATION=113, DATA=114, INNER=115, - TAILREC=116, OPERATOR=117, INLINE=118, INFIX=119, EXTERNAL=120, SUSPEND=121, - OVERRIDE=122, ABSTRACT=123, FINAL=124, OPEN=125, CONST=126, LATEINIT=127, - VARARG=128, NOINLINE=129, CROSSINLINE=130, REIFIED=131, EXPECT=132, ACTUAL=133, - QUOTE_OPEN=134, TRIPLE_QUOTE_OPEN=135, RealLiteral=136, FloatLiteral=137, - DoubleLiteral=138, LongLiteral=139, IntegerLiteral=140, HexLiteral=141, - BinLiteral=142, BooleanLiteral=143, NullLiteral=144, Identifier=145, IdentifierAt=146, - FieldIdentifier=147, CharacterLiteral=148, ErrorCharacter=149, UNICODE_CLASS_LL=150, - UNICODE_CLASS_LM=151, UNICODE_CLASS_LO=152, UNICODE_CLASS_LT=153, UNICODE_CLASS_LU=154, - UNICODE_CLASS_ND=155, UNICODE_CLASS_NL=156, Inside_Comment=157, Inside_WS=158, - Inside_NL=159, QUOTE_CLOSE=160, LineStrRef=161, LineStrText=162, LineStrEscapedChar=163, - LineStrExprStart=164, TRIPLE_QUOTE_CLOSE=165, MultiLineStringQuote=166, - MultiLineStrRef=167, MultiLineStrText=168, MultiLineStrExprStart=169; - public static final int - RULE_kotlinFile = 0, RULE_script = 1, RULE_fileAnnotation = 2, RULE_packageHeader = 3, - RULE_importList = 4, RULE_importHeader = 5, RULE_importAlias = 6, RULE_topLevelObject = 7, - RULE_classDeclaration = 8, RULE_primaryConstructor = 9, RULE_classParameters = 10, - RULE_classParameter = 11, RULE_delegationSpecifiers = 12, RULE_annotatedDelegationSpecifier = 13, - RULE_delegationSpecifier = 14, RULE_constructorInvocation = 15, RULE_explicitDelegation = 16, - RULE_classBody = 17, RULE_classMemberDeclarations = 18, RULE_classMemberDeclaration = 19, - RULE_anonymousInitializer = 20, RULE_secondaryConstructor = 21, RULE_constructorDelegationCall = 22, - RULE_enumClassBody = 23, RULE_enumEntries = 24, RULE_enumEntry = 25, RULE_functionDeclaration = 26, - RULE_functionValueParameters = 27, RULE_functionValueParameter = 28, RULE_parameter = 29, - RULE_setterParameter = 30, RULE_functionBody = 31, RULE_objectDeclaration = 32, - RULE_companionObject = 33, RULE_propertyDeclaration = 34, RULE_multiVariableDeclaration = 35, - RULE_variableDeclaration = 36, RULE_propertyDelegate = 37, RULE_getter = 38, - RULE_setter = 39, RULE_typeAlias = 40, RULE_typeParameters = 41, RULE_typeParameter = 42, - RULE_typeParameterModifiers = 43, RULE_typeParameterModifier = 44, RULE_type = 45, - RULE_typeModifiers = 46, RULE_typeModifier = 47, RULE_parenthesizedType = 48, - RULE_nullableType = 49, RULE_typeReference = 50, RULE_functionType = 51, - RULE_receiverType = 52, RULE_userType = 53, RULE_parenthesizedUserType = 54, - RULE_simpleUserType = 55, RULE_functionTypeParameters = 56, RULE_typeConstraints = 57, - RULE_typeConstraint = 58, RULE_block = 59, RULE_statements = 60, RULE_statement = 61, - RULE_declaration = 62, RULE_assignment = 63, RULE_expression = 64, RULE_disjunction = 65, - RULE_conjunction = 66, RULE_equality = 67, RULE_comparison = 68, RULE_infixOperation = 69, - RULE_elvisExpression = 70, RULE_infixFunctionCall = 71, RULE_rangeExpression = 72, - RULE_additiveExpression = 73, RULE_multiplicativeExpression = 74, RULE_asExpression = 75, - RULE_prefixUnaryExpression = 76, RULE_unaryPrefix = 77, RULE_postfixUnaryExpression = 78, - RULE_postfixUnarySuffix = 79, RULE_directlyAssignableExpression = 80, - RULE_assignableExpression = 81, RULE_assignableSuffix = 82, RULE_indexingSuffix = 83, - RULE_navigationSuffix = 84, RULE_callSuffix = 85, RULE_annotatedLambda = 86, - RULE_valueArguments = 87, RULE_typeArguments = 88, RULE_typeProjection = 89, - RULE_typeProjectionModifiers = 90, RULE_typeProjectionModifier = 91, RULE_valueArgument = 92, - RULE_primaryExpression = 93, RULE_parenthesizedExpression = 94, RULE_collectionLiteral = 95, - RULE_literalConstant = 96, RULE_stringLiteral = 97, RULE_lineStringLiteral = 98, - RULE_multiLineStringLiteral = 99, RULE_lineStringContent = 100, RULE_lineStringExpression = 101, - RULE_multiLineStringContent = 102, RULE_multiLineStringExpression = 103, - RULE_lambdaLiteral = 104, RULE_lambdaParameters = 105, RULE_lambdaParameter = 106, - RULE_anonymousFunction = 107, RULE_functionLiteral = 108, RULE_objectLiteral = 109, - RULE_thisExpression = 110, RULE_superExpression = 111, RULE_controlStructureBody = 112, - RULE_ifExpression = 113, RULE_whenExpression = 114, RULE_whenEntry = 115, - RULE_whenCondition = 116, RULE_rangeTest = 117, RULE_typeTest = 118, RULE_tryExpression = 119, - RULE_catchBlock = 120, RULE_finallyBlock = 121, RULE_loopStatement = 122, - RULE_forStatement = 123, RULE_whileStatement = 124, RULE_doWhileStatement = 125, - RULE_jumpExpression = 126, RULE_callableReference = 127, RULE_assignmentAndOperator = 128, - RULE_equalityOperator = 129, RULE_comparisonOperator = 130, RULE_inOperator = 131, - RULE_isOperator = 132, RULE_additiveOperator = 133, RULE_multiplicativeOperator = 134, - RULE_asOperator = 135, RULE_prefixUnaryOperator = 136, RULE_postfixUnaryOperator = 137, - RULE_memberAccessOperator = 138, RULE_modifiers = 139, RULE_modifier = 140, - RULE_classModifier = 141, RULE_memberModifier = 142, RULE_visibilityModifier = 143, - RULE_varianceModifier = 144, RULE_functionModifier = 145, RULE_propertyModifier = 146, - RULE_inheritanceModifier = 147, RULE_parameterModifier = 148, RULE_reificationModifier = 149, - RULE_platformModifier = 150, RULE_label = 151, RULE_annotation = 152, - RULE_singleAnnotation = 153, RULE_multiAnnotation = 154, RULE_annotationUseSiteTarget = 155, - RULE_unescapedAnnotation = 156, RULE_simpleIdentifier = 157, RULE_identifier = 158, - RULE_shebangLine = 159, RULE_quest = 160, RULE_elvis = 161, RULE_safeNav = 162, - RULE_excl = 163, RULE_semi = 164, RULE_semis = 165; - private static String[] makeRuleNames() { - return new String[] { - "kotlinFile", "script", "fileAnnotation", "packageHeader", "importList", - "importHeader", "importAlias", "topLevelObject", "classDeclaration", - "primaryConstructor", "classParameters", "classParameter", "delegationSpecifiers", - "annotatedDelegationSpecifier", "delegationSpecifier", "constructorInvocation", - "explicitDelegation", "classBody", "classMemberDeclarations", "classMemberDeclaration", - "anonymousInitializer", "secondaryConstructor", "constructorDelegationCall", - "enumClassBody", "enumEntries", "enumEntry", "functionDeclaration", "functionValueParameters", - "functionValueParameter", "parameter", "setterParameter", "functionBody", - "objectDeclaration", "companionObject", "propertyDeclaration", "multiVariableDeclaration", - "variableDeclaration", "propertyDelegate", "getter", "setter", "typeAlias", - "typeParameters", "typeParameter", "typeParameterModifiers", "typeParameterModifier", - "type", "typeModifiers", "typeModifier", "parenthesizedType", "nullableType", - "typeReference", "functionType", "receiverType", "userType", "parenthesizedUserType", - "simpleUserType", "functionTypeParameters", "typeConstraints", "typeConstraint", - "block", "statements", "statement", "declaration", "assignment", "expression", - "disjunction", "conjunction", "equality", "comparison", "infixOperation", - "elvisExpression", "infixFunctionCall", "rangeExpression", "additiveExpression", - "multiplicativeExpression", "asExpression", "prefixUnaryExpression", - "unaryPrefix", "postfixUnaryExpression", "postfixUnarySuffix", "directlyAssignableExpression", - "assignableExpression", "assignableSuffix", "indexingSuffix", "navigationSuffix", - "callSuffix", "annotatedLambda", "valueArguments", "typeArguments", "typeProjection", - "typeProjectionModifiers", "typeProjectionModifier", "valueArgument", - "primaryExpression", "parenthesizedExpression", "collectionLiteral", - "literalConstant", "stringLiteral", "lineStringLiteral", "multiLineStringLiteral", - "lineStringContent", "lineStringExpression", "multiLineStringContent", - "multiLineStringExpression", "lambdaLiteral", "lambdaParameters", "lambdaParameter", - "anonymousFunction", "functionLiteral", "objectLiteral", "thisExpression", - "superExpression", "controlStructureBody", "ifExpression", "whenExpression", - "whenEntry", "whenCondition", "rangeTest", "typeTest", "tryExpression", - "catchBlock", "finallyBlock", "loopStatement", "forStatement", "whileStatement", - "doWhileStatement", "jumpExpression", "callableReference", "assignmentAndOperator", - "equalityOperator", "comparisonOperator", "inOperator", "isOperator", - "additiveOperator", "multiplicativeOperator", "asOperator", "prefixUnaryOperator", - "postfixUnaryOperator", "memberAccessOperator", "modifiers", "modifier", - "classModifier", "memberModifier", "visibilityModifier", "varianceModifier", - "functionModifier", "propertyModifier", "inheritanceModifier", "parameterModifier", - "reificationModifier", "platformModifier", "label", "annotation", "singleAnnotation", - "multiAnnotation", "annotationUseSiteTarget", "unescapedAnnotation", - "simpleIdentifier", "identifier", "shebangLine", "quest", "elvis", "safeNav", - "excl", "semi", "semis" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, null, "'...'", "'.'", "','", "'('", "')'", - "'['", "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", - "'--'", "'&&'", "'||'", null, "'!'", "':'", "';'", "'='", "'+='", "'-='", - "'*='", "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", - "'@'", null, null, "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", - "'as?'", "'=='", "'==='", "'''", null, null, null, null, null, "'package'", - "'import'", "'class'", "'interface'", "'fun'", "'object'", "'val'", "'var'", - "'typealias'", "'constructor'", "'by'", "'companion'", "'init'", "'this'", - "'super'", "'typeof'", "'where'", "'if'", "'else'", "'when'", "'try'", - "'catch'", "'finally'", "'for'", "'do'", "'while'", "'throw'", "'return'", - "'continue'", "'break'", "'as'", "'is'", "'in'", null, null, "'out'", - "'get'", "'set'", "'dynamic'", "'@file'", "'@field'", "'@property'", - "'@get'", "'@set'", "'@receiver'", "'@param'", "'@setparam'", "'@delegate'", - "'public'", "'private'", "'protected'", "'internal'", "'enum'", "'sealed'", - "'annotation'", "'data'", "'inner'", "'tailrec'", "'operator'", "'inline'", - "'infix'", "'external'", "'suspend'", "'override'", "'abstract'", "'final'", - "'open'", "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", - "'reified'", "'expect'", "'actual'", null, "'\"\"\"'", null, null, null, - null, null, null, null, null, "'null'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", - "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", - "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL_WS", - "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", - "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", - "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT", "AT_WS", "QUEST_WS", - "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", - "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", - "BREAK_AT", "THIS_AT", "SUPER_AT", "PACKAGE", "IMPORT", "CLASS", "INTERFACE", - "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", - "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", - "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", "RETURN", "CONTINUE", - "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", "OUT", "GETTER", "SETTER", - "DYNAMIC", "AT_FILE", "AT_FIELD", "AT_PROPERTY", "AT_GET", "AT_SET", - "AT_RECEIVER", "AT_PARAM", "AT_SETPARAM", "AT_DELEGATE", "PUBLIC", "PRIVATE", - "PROTECTED", "INTERNAL", "ENUM", "SEALED", "ANNOTATION", "DATA", "INNER", - "TAILREC", "OPERATOR", "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", - "ABSTRACT", "FINAL", "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", - "CROSSINLINE", "REIFIED", "EXPECT", "ACTUAL", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", - "RealLiteral", "FloatLiteral", "DoubleLiteral", "LongLiteral", "IntegerLiteral", - "HexLiteral", "BinLiteral", "BooleanLiteral", "NullLiteral", "Identifier", - "IdentifierAt", "FieldIdentifier", "CharacterLiteral", "ErrorCharacter", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "Inside_Comment", - "Inside_WS", "Inside_NL", "QUOTE_CLOSE", "LineStrRef", "LineStrText", - "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", - "MultiLineStrRef", "MultiLineStrText", "MultiLineStrExprStart" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - @Override - public String getGrammarFileName() { return "KotlinParser.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public ATN getATN() { return _ATN; } - - public KotlinParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - public static class KotlinFileContext extends ParserRuleContext { - public PackageHeaderContext packageHeader() { - return getRuleContext(PackageHeaderContext.class,0); - } - public ImportListContext importList() { - return getRuleContext(ImportListContext.class,0); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public ShebangLineContext shebangLine() { - return getRuleContext(ShebangLineContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List fileAnnotation() { - return getRuleContexts(FileAnnotationContext.class); - } - public FileAnnotationContext fileAnnotation(int i) { - return getRuleContext(FileAnnotationContext.class,i); - } - public List topLevelObject() { - return getRuleContexts(TopLevelObjectContext.class); - } - public TopLevelObjectContext topLevelObject(int i) { - return getRuleContext(TopLevelObjectContext.class,i); - } - public KotlinFileContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_kotlinFile; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterKotlinFile(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitKotlinFile(this); - } - } - - public final KotlinFileContext kotlinFile() throws RecognitionException { - KotlinFileContext _localctx = new KotlinFileContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_kotlinFile); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(333); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ShebangLine) { - { - setState(332); - shebangLine(); - } - } - - setState(338); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(335); - match(NL); - } - } - setState(340); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(344); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_FILE) { - { - { - setState(341); - fileAnnotation(); - } - } - setState(346); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(347); - packageHeader(); - setState(348); - importList(); - setState(352); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT - 40)) | (1L << (CLASS - 40)) | (1L << (INTERFACE - 40)) | (1L << (FUN - 40)) | (1L << (OBJECT - 40)) | (1L << (VAL - 40)) | (1L << (VAR - 40)) | (1L << (TYPE_ALIAS - 40)) | (1L << (AT_FIELD - 40)) | (1L << (AT_PROPERTY - 40)) | (1L << (AT_GET - 40)) | (1L << (AT_SET - 40)) | (1L << (AT_RECEIVER - 40)))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (AT_PARAM - 104)) | (1L << (AT_SETPARAM - 104)) | (1L << (AT_DELEGATE - 104)) | (1L << (PUBLIC - 104)) | (1L << (PRIVATE - 104)) | (1L << (PROTECTED - 104)) | (1L << (INTERNAL - 104)) | (1L << (ENUM - 104)) | (1L << (SEALED - 104)) | (1L << (ANNOTATION - 104)) | (1L << (DATA - 104)) | (1L << (INNER - 104)) | (1L << (TAILREC - 104)) | (1L << (OPERATOR - 104)) | (1L << (INLINE - 104)) | (1L << (INFIX - 104)) | (1L << (EXTERNAL - 104)) | (1L << (SUSPEND - 104)) | (1L << (OVERRIDE - 104)) | (1L << (ABSTRACT - 104)) | (1L << (FINAL - 104)) | (1L << (OPEN - 104)) | (1L << (CONST - 104)) | (1L << (LATEINIT - 104)) | (1L << (VARARG - 104)) | (1L << (NOINLINE - 104)) | (1L << (CROSSINLINE - 104)) | (1L << (EXPECT - 104)) | (1L << (ACTUAL - 104)))) != 0)) { - { - { - setState(349); - topLevelObject(); - } - } - setState(354); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(355); - match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ScriptContext extends ParserRuleContext { - public PackageHeaderContext packageHeader() { - return getRuleContext(PackageHeaderContext.class,0); - } - public ImportListContext importList() { - return getRuleContext(ImportListContext.class,0); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public ShebangLineContext shebangLine() { - return getRuleContext(ShebangLineContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List fileAnnotation() { - return getRuleContexts(FileAnnotationContext.class); - } - public FileAnnotationContext fileAnnotation(int i) { - return getRuleContext(FileAnnotationContext.class,i); - } - public List statement() { - return getRuleContexts(StatementContext.class); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public List semi() { - return getRuleContexts(SemiContext.class); - } - public SemiContext semi(int i) { - return getRuleContext(SemiContext.class,i); - } - public ScriptContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_script; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterScript(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitScript(this); - } - } - - public final ScriptContext script() throws RecognitionException { - ScriptContext _localctx = new ScriptContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_script); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(358); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ShebangLine) { - { - setState(357); - shebangLine(); - } - } - - setState(363); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,5,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(360); - match(NL); - } - } - } - setState(365); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,5,_ctx); - } - setState(369); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_FILE) { - { - { - setState(366); - fileAnnotation(); - } - } - setState(371); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(372); - packageHeader(); - setState(373); - importList(); - setState(379); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NL) | (1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << IMPORT) | (1L << CLASS) | (1L << INTERFACE) | (1L << FUN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (OBJECT - 64)) | (1L << (VAL - 64)) | (1L << (VAR - 64)) | (1L << (TYPE_ALIAS - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (FOR - 64)) | (1L << (DO - 64)) | (1L << (WHILE - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (GETTER - 64)) | (1L << (SETTER - 64)) | (1L << (DYNAMIC - 64)) | (1L << (AT_FIELD - 64)) | (1L << (AT_PROPERTY - 64)) | (1L << (AT_GET - 64)) | (1L << (AT_SET - 64)) | (1L << (AT_RECEIVER - 64)) | (1L << (AT_PARAM - 64)) | (1L << (AT_SETPARAM - 64)) | (1L << (AT_DELEGATE - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)) | (1L << (LATEINIT - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)) | (1L << (RealLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (IdentifierAt - 128)) | (1L << (CharacterLiteral - 128)))) != 0)) { - { - { - setState(374); - statement(); - setState(375); - semi(); - } - } - setState(381); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(382); - match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FileAnnotationContext extends ParserRuleContext { - public TerminalNode AT_FILE() { return getToken(KotlinParser.AT_FILE, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List unescapedAnnotation() { - return getRuleContexts(UnescapedAnnotationContext.class); - } - public UnescapedAnnotationContext unescapedAnnotation(int i) { - return getRuleContext(UnescapedAnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FileAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fileAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFileAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFileAnnotation(this); - } - } - - public final FileAnnotationContext fileAnnotation() throws RecognitionException { - FileAnnotationContext _localctx = new FileAnnotationContext(_ctx, getState()); - enterRule(_localctx, 4, RULE_fileAnnotation); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(384); - match(AT_FILE); - setState(388); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(385); - match(NL); - } - } - setState(390); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(391); - match(COLON); - setState(395); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(392); - match(NL); - } - } - setState(397); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(407); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LSQUARE: - { - setState(398); - match(LSQUARE); - setState(400); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(399); - unescapedAnnotation(); - } - } - setState(402); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (IMPORT - 60)) | (1L << (CONSTRUCTOR - 60)) | (1L << (BY - 60)) | (1L << (COMPANION - 60)) | (1L << (INIT - 60)) | (1L << (WHERE - 60)) | (1L << (CATCH - 60)) | (1L << (FINALLY - 60)) | (1L << (OUT - 60)) | (1L << (GETTER - 60)) | (1L << (SETTER - 60)) | (1L << (DYNAMIC - 60)) | (1L << (PUBLIC - 60)) | (1L << (PRIVATE - 60)) | (1L << (PROTECTED - 60)) | (1L << (INTERNAL - 60)) | (1L << (ENUM - 60)) | (1L << (SEALED - 60)) | (1L << (ANNOTATION - 60)) | (1L << (DATA - 60)) | (1L << (INNER - 60)) | (1L << (TAILREC - 60)) | (1L << (OPERATOR - 60)) | (1L << (INLINE - 60)) | (1L << (INFIX - 60)) | (1L << (EXTERNAL - 60)) | (1L << (SUSPEND - 60)) | (1L << (OVERRIDE - 60)) | (1L << (ABSTRACT - 60)))) != 0) || ((((_la - 124)) & ~0x3f) == 0 && ((1L << (_la - 124)) & ((1L << (FINAL - 124)) | (1L << (OPEN - 124)) | (1L << (CONST - 124)) | (1L << (LATEINIT - 124)) | (1L << (VARARG - 124)) | (1L << (NOINLINE - 124)) | (1L << (CROSSINLINE - 124)) | (1L << (REIFIED - 124)) | (1L << (EXPECT - 124)) | (1L << (ACTUAL - 124)) | (1L << (Identifier - 124)))) != 0) ); - setState(404); - match(RSQUARE); - } - break; - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(406); - unescapedAnnotation(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(412); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,12,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(409); - match(NL); - } - } - } - setState(414); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,12,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PackageHeaderContext extends ParserRuleContext { - public TerminalNode PACKAGE() { return getToken(KotlinParser.PACKAGE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public PackageHeaderContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_packageHeader; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPackageHeader(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPackageHeader(this); - } - } - - public final PackageHeaderContext packageHeader() throws RecognitionException { - PackageHeaderContext _localctx = new PackageHeaderContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_packageHeader); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(420); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PACKAGE) { - { - setState(415); - match(PACKAGE); - setState(416); - identifier(); - setState(418); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { - case 1: - { - setState(417); - semi(); - } - break; - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportListContext extends ParserRuleContext { - public List importHeader() { - return getRuleContexts(ImportHeaderContext.class); - } - public ImportHeaderContext importHeader(int i) { - return getRuleContext(ImportHeaderContext.class,i); - } - public ImportListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importList; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterImportList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitImportList(this); - } - } - - public final ImportListContext importList() throws RecognitionException { - ImportListContext _localctx = new ImportListContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_importList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(425); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,15,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(422); - importHeader(); - } - } - } - setState(427); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,15,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportHeaderContext extends ParserRuleContext { - public TerminalNode IMPORT() { return getToken(KotlinParser.IMPORT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public ImportAliasContext importAlias() { - return getRuleContext(ImportAliasContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public ImportHeaderContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importHeader; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterImportHeader(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitImportHeader(this); - } - } - - public final ImportHeaderContext importHeader() throws RecognitionException { - ImportHeaderContext _localctx = new ImportHeaderContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_importHeader); - try { - enterOuterAlt(_localctx, 1); - { - setState(428); - match(IMPORT); - setState(429); - identifier(); - setState(433); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DOT: - { - setState(430); - match(DOT); - setState(431); - match(MULT); - } - break; - case AS: - { - setState(432); - importAlias(); - } - break; - case EOF: - case NL: - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case SEMICOLON: - case COLONCOLON: - case AT: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case IMPORT: - case CLASS: - case INTERFACE: - case FUN: - case OBJECT: - case VAL: - case VAR: - case TYPE_ALIAS: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case FOR: - case DO: - case WHILE: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - case RealLiteral: - case LongLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case BooleanLiteral: - case NullLiteral: - case Identifier: - case IdentifierAt: - case CharacterLiteral: - break; - default: - break; - } - setState(436); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { - case 1: - { - setState(435); - semi(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportAliasContext extends ParserRuleContext { - public TerminalNode AS() { return getToken(KotlinParser.AS, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ImportAliasContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importAlias; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterImportAlias(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitImportAlias(this); - } - } - - public final ImportAliasContext importAlias() throws RecognitionException { - ImportAliasContext _localctx = new ImportAliasContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_importAlias); - try { - enterOuterAlt(_localctx, 1); - { - setState(438); - match(AS); - setState(439); - simpleIdentifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TopLevelObjectContext extends ParserRuleContext { - public DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public SemisContext semis() { - return getRuleContext(SemisContext.class,0); - } - public TopLevelObjectContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_topLevelObject; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTopLevelObject(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTopLevelObject(this); - } - } - - public final TopLevelObjectContext topLevelObject() throws RecognitionException { - TopLevelObjectContext _localctx = new TopLevelObjectContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_topLevelObject); - try { - enterOuterAlt(_localctx, 1); - { - setState(441); - declaration(); - setState(443); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { - case 1: - { - setState(442); - semis(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassDeclarationContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public TerminalNode INTERFACE() { return getToken(KotlinParser.INTERFACE, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public PrimaryConstructorContext primaryConstructor() { - return getRuleContext(PrimaryConstructorContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public EnumClassBodyContext enumClassBody() { - return getRuleContext(EnumClassBodyContext.class,0); - } - public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassDeclaration(this); - } - } - - public final ClassDeclarationContext classDeclaration() throws RecognitionException { - ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_classDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(446); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(445); - modifiers(); - } - } - - setState(448); - _la = _input.LA(1); - if ( !(_la==CLASS || _la==INTERFACE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(452); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(449); - match(NL); - } - } - setState(454); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(455); - simpleIdentifier(); - setState(463); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { - case 1: - { - setState(459); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(456); - match(NL); - } - } - setState(461); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(462); - typeParameters(); - } - break; - } - setState(472); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) { - case 1: - { - setState(468); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(465); - match(NL); - } - } - setState(470); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(471); - primaryConstructor(); - } - break; - } - setState(488); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { - case 1: - { - setState(477); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(474); - match(NL); - } - } - setState(479); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(480); - match(COLON); - setState(484); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,26,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(481); - match(NL); - } - } - } - setState(486); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,26,_ctx); - } - setState(487); - delegationSpecifiers(); - } - break; - } - setState(497); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) { - case 1: - { - setState(493); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(490); - match(NL); - } - } - setState(495); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(496); - typeConstraints(); - } - break; - } - setState(513); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { - case 1: - { - setState(502); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(499); - match(NL); - } - } - setState(504); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(505); - classBody(); - } - break; - case 2: - { - setState(509); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(506); - match(NL); - } - } - setState(511); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(512); - enumClassBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryConstructorContext extends ParserRuleContext { - public ClassParametersContext classParameters() { - return getRuleContext(ClassParametersContext.class,0); - } - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public PrimaryConstructorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primaryConstructor; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPrimaryConstructor(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPrimaryConstructor(this); - } - } - - public final PrimaryConstructorContext primaryConstructor() throws RecognitionException { - PrimaryConstructorContext _localctx = new PrimaryConstructorContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_primaryConstructor); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(525); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (AT_FIELD - 40)) | (1L << (AT_PROPERTY - 40)) | (1L << (AT_GET - 40)) | (1L << (AT_SET - 40)) | (1L << (AT_RECEIVER - 40)))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (AT_PARAM - 104)) | (1L << (AT_SETPARAM - 104)) | (1L << (AT_DELEGATE - 104)) | (1L << (PUBLIC - 104)) | (1L << (PRIVATE - 104)) | (1L << (PROTECTED - 104)) | (1L << (INTERNAL - 104)) | (1L << (ENUM - 104)) | (1L << (SEALED - 104)) | (1L << (ANNOTATION - 104)) | (1L << (DATA - 104)) | (1L << (INNER - 104)) | (1L << (TAILREC - 104)) | (1L << (OPERATOR - 104)) | (1L << (INLINE - 104)) | (1L << (INFIX - 104)) | (1L << (EXTERNAL - 104)) | (1L << (SUSPEND - 104)) | (1L << (OVERRIDE - 104)) | (1L << (ABSTRACT - 104)) | (1L << (FINAL - 104)) | (1L << (OPEN - 104)) | (1L << (CONST - 104)) | (1L << (LATEINIT - 104)) | (1L << (VARARG - 104)) | (1L << (NOINLINE - 104)) | (1L << (CROSSINLINE - 104)) | (1L << (EXPECT - 104)) | (1L << (ACTUAL - 104)))) != 0)) { - { - setState(516); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(515); - modifiers(); - } - } - - setState(518); - match(CONSTRUCTOR); - setState(522); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(519); - match(NL); - } - } - setState(524); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(527); - classParameters(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List classParameter() { - return getRuleContexts(ClassParameterContext.class); - } - public ClassParameterContext classParameter(int i) { - return getRuleContext(ClassParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public ClassParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassParameters(this); - } - } - - public final ClassParametersContext classParameters() throws RecognitionException { - ClassParametersContext _localctx = new ClassParametersContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_classParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(529); - match(LPAREN); - setState(533); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,36,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(530); - match(NL); - } - } - } - setState(535); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,36,_ctx); - } - setState(556); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { - case 1: - { - setState(536); - classParameter(); - setState(553); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,39,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(540); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(537); - match(NL); - } - } - setState(542); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(543); - match(COMMA); - setState(547); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,38,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(544); - match(NL); - } - } - } - setState(549); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,38,_ctx); - } - setState(550); - classParameter(); - } - } - } - setState(555); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,39,_ctx); - } - } - break; - } - setState(561); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(558); - match(NL); - } - } - setState(563); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(564); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode VAL() { return getToken(KotlinParser.VAL, 0); } - public TerminalNode VAR() { return getToken(KotlinParser.VAR, 0); } - public ClassParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassParameter(this); - } - } - - public final ClassParameterContext classParameter() throws RecognitionException { - ClassParameterContext _localctx = new ClassParameterContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_classParameter); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(567); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { - case 1: - { - setState(566); - modifiers(); - } - break; - } - setState(570); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VAL || _la==VAR) { - { - setState(569); - _la = _input.LA(1); - if ( !(_la==VAL || _la==VAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(575); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(572); - match(NL); - } - } - setState(577); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(578); - simpleIdentifier(); - setState(579); - match(COLON); - setState(583); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(580); - match(NL); - } - } - setState(585); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(586); - type(); - setState(601); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { - case 1: - { - setState(590); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(587); - match(NL); - } - } - setState(592); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(593); - match(ASSIGNMENT); - setState(597); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,47,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(594); - match(NL); - } - } - } - setState(599); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,47,_ctx); - } - setState(600); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DelegationSpecifiersContext extends ParserRuleContext { - public List annotatedDelegationSpecifier() { - return getRuleContexts(AnnotatedDelegationSpecifierContext.class); - } - public AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier(int i) { - return getRuleContext(AnnotatedDelegationSpecifierContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public DelegationSpecifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delegationSpecifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDelegationSpecifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDelegationSpecifiers(this); - } - } - - public final DelegationSpecifiersContext delegationSpecifiers() throws RecognitionException { - DelegationSpecifiersContext _localctx = new DelegationSpecifiersContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_delegationSpecifiers); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(603); - annotatedDelegationSpecifier(); - setState(620); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(607); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(604); - match(NL); - } - } - setState(609); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(610); - match(COMMA); - setState(614); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,50,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(611); - match(NL); - } - } - } - setState(616); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,50,_ctx); - } - setState(617); - annotatedDelegationSpecifier(); - } - } - } - setState(622); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotatedDelegationSpecifierContext extends ParserRuleContext { - public DelegationSpecifierContext delegationSpecifier() { - return getRuleContext(DelegationSpecifierContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotatedDelegationSpecifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotatedDelegationSpecifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnnotatedDelegationSpecifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnnotatedDelegationSpecifier(this); - } - } - - public final AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier() throws RecognitionException { - AnnotatedDelegationSpecifierContext _localctx = new AnnotatedDelegationSpecifierContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_annotatedDelegationSpecifier); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(626); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,52,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(623); - annotation(); - } - } - } - setState(628); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,52,_ctx); - } - setState(632); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(629); - match(NL); - } - } - setState(634); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(635); - delegationSpecifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DelegationSpecifierContext extends ParserRuleContext { - public ConstructorInvocationContext constructorInvocation() { - return getRuleContext(ConstructorInvocationContext.class,0); - } - public ExplicitDelegationContext explicitDelegation() { - return getRuleContext(ExplicitDelegationContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public DelegationSpecifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delegationSpecifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDelegationSpecifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDelegationSpecifier(this); - } - } - - public final DelegationSpecifierContext delegationSpecifier() throws RecognitionException { - DelegationSpecifierContext _localctx = new DelegationSpecifierContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_delegationSpecifier); - try { - setState(641); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(637); - constructorInvocation(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(638); - explicitDelegation(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(639); - userType(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(640); - functionType(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorInvocationContext extends ParserRuleContext { - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public ConstructorInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorInvocation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterConstructorInvocation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitConstructorInvocation(this); - } - } - - public final ConstructorInvocationContext constructorInvocation() throws RecognitionException { - ConstructorInvocationContext _localctx = new ConstructorInvocationContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_constructorInvocation); - try { - enterOuterAlt(_localctx, 1); - { - setState(643); - userType(); - setState(644); - valueArguments(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExplicitDelegationContext extends ParserRuleContext { - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ExplicitDelegationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitDelegation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterExplicitDelegation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitExplicitDelegation(this); - } - } - - public final ExplicitDelegationContext explicitDelegation() throws RecognitionException { - ExplicitDelegationContext _localctx = new ExplicitDelegationContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_explicitDelegation); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(648); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { - case 1: - { - setState(646); - userType(); - } - break; - case 2: - { - setState(647); - functionType(); - } - break; - } - setState(653); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(650); - match(NL); - } - } - setState(655); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(656); - match(BY); - setState(660); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,57,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(657); - match(NL); - } - } - } - setState(662); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,57,_ctx); - } - setState(663); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public ClassMemberDeclarationsContext classMemberDeclarations() { - return getRuleContext(ClassMemberDeclarationsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassBody(this); - } - } - - public final ClassBodyContext classBody() throws RecognitionException { - ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_classBody); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(665); - match(LCURL); - setState(669); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,58,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(666); - match(NL); - } - } - } - setState(671); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,58,_ctx); - } - setState(672); - classMemberDeclarations(); - setState(676); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(673); - match(NL); - } - } - setState(678); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(679); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassMemberDeclarationsContext extends ParserRuleContext { - public List classMemberDeclaration() { - return getRuleContexts(ClassMemberDeclarationContext.class); - } - public ClassMemberDeclarationContext classMemberDeclaration(int i) { - return getRuleContext(ClassMemberDeclarationContext.class,i); - } - public List semis() { - return getRuleContexts(SemisContext.class); - } - public SemisContext semis(int i) { - return getRuleContext(SemisContext.class,i); - } - public ClassMemberDeclarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classMemberDeclarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassMemberDeclarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassMemberDeclarations(this); - } - } - - public final ClassMemberDeclarationsContext classMemberDeclarations() throws RecognitionException { - ClassMemberDeclarationsContext _localctx = new ClassMemberDeclarationsContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_classMemberDeclarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(687); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT - 40)) | (1L << (CLASS - 40)) | (1L << (INTERFACE - 40)) | (1L << (FUN - 40)) | (1L << (OBJECT - 40)) | (1L << (VAL - 40)) | (1L << (VAR - 40)) | (1L << (TYPE_ALIAS - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (AT_FIELD - 40)) | (1L << (AT_PROPERTY - 40)) | (1L << (AT_GET - 40)) | (1L << (AT_SET - 40)) | (1L << (AT_RECEIVER - 40)))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (AT_PARAM - 104)) | (1L << (AT_SETPARAM - 104)) | (1L << (AT_DELEGATE - 104)) | (1L << (PUBLIC - 104)) | (1L << (PRIVATE - 104)) | (1L << (PROTECTED - 104)) | (1L << (INTERNAL - 104)) | (1L << (ENUM - 104)) | (1L << (SEALED - 104)) | (1L << (ANNOTATION - 104)) | (1L << (DATA - 104)) | (1L << (INNER - 104)) | (1L << (TAILREC - 104)) | (1L << (OPERATOR - 104)) | (1L << (INLINE - 104)) | (1L << (INFIX - 104)) | (1L << (EXTERNAL - 104)) | (1L << (SUSPEND - 104)) | (1L << (OVERRIDE - 104)) | (1L << (ABSTRACT - 104)) | (1L << (FINAL - 104)) | (1L << (OPEN - 104)) | (1L << (CONST - 104)) | (1L << (LATEINIT - 104)) | (1L << (VARARG - 104)) | (1L << (NOINLINE - 104)) | (1L << (CROSSINLINE - 104)) | (1L << (EXPECT - 104)) | (1L << (ACTUAL - 104)))) != 0)) { - { - { - setState(681); - classMemberDeclaration(); - setState(683); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { - case 1: - { - setState(682); - semis(); - } - break; - } - } - } - setState(689); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassMemberDeclarationContext extends ParserRuleContext { - public DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public CompanionObjectContext companionObject() { - return getRuleContext(CompanionObjectContext.class,0); - } - public AnonymousInitializerContext anonymousInitializer() { - return getRuleContext(AnonymousInitializerContext.class,0); - } - public SecondaryConstructorContext secondaryConstructor() { - return getRuleContext(SecondaryConstructorContext.class,0); - } - public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classMemberDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassMemberDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassMemberDeclaration(this); - } - } - - public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { - ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_classMemberDeclaration); - try { - setState(694); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(690); - declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(691); - companionObject(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(692); - anonymousInitializer(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(693); - secondaryConstructor(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnonymousInitializerContext extends ParserRuleContext { - public TerminalNode INIT() { return getToken(KotlinParser.INIT, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnonymousInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymousInitializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnonymousInitializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnonymousInitializer(this); - } - } - - public final AnonymousInitializerContext anonymousInitializer() throws RecognitionException { - AnonymousInitializerContext _localctx = new AnonymousInitializerContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_anonymousInitializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(696); - match(INIT); - setState(700); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(697); - match(NL); - } - } - setState(702); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(703); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SecondaryConstructorContext extends ParserRuleContext { - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public FunctionValueParametersContext functionValueParameters() { - return getRuleContext(FunctionValueParametersContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public ConstructorDelegationCallContext constructorDelegationCall() { - return getRuleContext(ConstructorDelegationCallContext.class,0); - } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public SecondaryConstructorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_secondaryConstructor; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSecondaryConstructor(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSecondaryConstructor(this); - } - } - - public final SecondaryConstructorContext secondaryConstructor() throws RecognitionException { - SecondaryConstructorContext _localctx = new SecondaryConstructorContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_secondaryConstructor); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(706); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(705); - modifiers(); - } - } - - setState(708); - match(CONSTRUCTOR); - setState(712); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(709); - match(NL); - } - } - setState(714); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(715); - functionValueParameters(); - setState(730); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { - case 1: - { - setState(719); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(716); - match(NL); - } - } - setState(721); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(722); - match(COLON); - setState(726); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(723); - match(NL); - } - } - setState(728); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(729); - constructorDelegationCall(); - } - break; - } - setState(735); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,69,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(732); - match(NL); - } - } - } - setState(737); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,69,_ctx); - } - setState(739); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LCURL) { - { - setState(738); - block(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorDelegationCallContext extends ParserRuleContext { - public TerminalNode THIS() { return getToken(KotlinParser.THIS, 0); } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode SUPER() { return getToken(KotlinParser.SUPER, 0); } - public ConstructorDelegationCallContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorDelegationCall; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterConstructorDelegationCall(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitConstructorDelegationCall(this); - } - } - - public final ConstructorDelegationCallContext constructorDelegationCall() throws RecognitionException { - ConstructorDelegationCallContext _localctx = new ConstructorDelegationCallContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_constructorDelegationCall); - int _la; - try { - setState(757); - _errHandler.sync(this); - switch (_input.LA(1)) { - case THIS: - enterOuterAlt(_localctx, 1); - { - setState(741); - match(THIS); - setState(745); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(742); - match(NL); - } - } - setState(747); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(748); - valueArguments(); - } - break; - case SUPER: - enterOuterAlt(_localctx, 2); - { - setState(749); - match(SUPER); - setState(753); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(750); - match(NL); - } - } - setState(755); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(756); - valueArguments(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumClassBodyContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntriesContext enumEntries() { - return getRuleContext(EnumEntriesContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public ClassMemberDeclarationsContext classMemberDeclarations() { - return getRuleContext(ClassMemberDeclarationsContext.class,0); - } - public EnumClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumClassBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterEnumClassBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitEnumClassBody(this); - } - } - - public final EnumClassBodyContext enumClassBody() throws RecognitionException { - EnumClassBodyContext _localctx = new EnumClassBodyContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_enumClassBody); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(759); - match(LCURL); - setState(763); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,74,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(760); - match(NL); - } - } - } - setState(765); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,74,_ctx); - } - setState(767); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT - 40)) | (1L << (IMPORT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (BY - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (WHERE - 40)) | (1L << (CATCH - 40)) | (1L << (FINALLY - 40)) | (1L << (OUT - 40)) | (1L << (GETTER - 40)) | (1L << (SETTER - 40)) | (1L << (DYNAMIC - 40)) | (1L << (AT_FIELD - 40)) | (1L << (AT_PROPERTY - 40)) | (1L << (AT_GET - 40)) | (1L << (AT_SET - 40)) | (1L << (AT_RECEIVER - 40)))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (AT_PARAM - 104)) | (1L << (AT_SETPARAM - 104)) | (1L << (AT_DELEGATE - 104)) | (1L << (PUBLIC - 104)) | (1L << (PRIVATE - 104)) | (1L << (PROTECTED - 104)) | (1L << (INTERNAL - 104)) | (1L << (ENUM - 104)) | (1L << (SEALED - 104)) | (1L << (ANNOTATION - 104)) | (1L << (DATA - 104)) | (1L << (INNER - 104)) | (1L << (TAILREC - 104)) | (1L << (OPERATOR - 104)) | (1L << (INLINE - 104)) | (1L << (INFIX - 104)) | (1L << (EXTERNAL - 104)) | (1L << (SUSPEND - 104)) | (1L << (OVERRIDE - 104)) | (1L << (ABSTRACT - 104)) | (1L << (FINAL - 104)) | (1L << (OPEN - 104)) | (1L << (CONST - 104)) | (1L << (LATEINIT - 104)) | (1L << (VARARG - 104)) | (1L << (NOINLINE - 104)) | (1L << (CROSSINLINE - 104)) | (1L << (REIFIED - 104)) | (1L << (EXPECT - 104)) | (1L << (ACTUAL - 104)) | (1L << (Identifier - 104)))) != 0)) { - { - setState(766); - enumEntries(); - } - } - - setState(783); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { - case 1: - { - setState(772); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(769); - match(NL); - } - } - setState(774); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(775); - match(SEMICOLON); - setState(779); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,77,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(776); - match(NL); - } - } - } - setState(781); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,77,_ctx); - } - setState(782); - classMemberDeclarations(); - } - break; - } - setState(788); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(785); - match(NL); - } - } - setState(790); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(791); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumEntriesContext extends ParserRuleContext { - public List enumEntry() { - return getRuleContexts(EnumEntryContext.class); - } - public EnumEntryContext enumEntry(int i) { - return getRuleContext(EnumEntryContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntriesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumEntries; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterEnumEntries(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitEnumEntries(this); - } - } - - public final EnumEntriesContext enumEntries() throws RecognitionException { - EnumEntriesContext _localctx = new EnumEntriesContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_enumEntries); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(793); - enumEntry(); - setState(810); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,82,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(797); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(794); - match(NL); - } - } - setState(799); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(800); - match(COMMA); - setState(804); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(801); - match(NL); - } - } - setState(806); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(807); - enumEntry(); - } - } - } - setState(812); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,82,_ctx); - } - setState(816); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,83,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(813); - match(NL); - } - } - } - setState(818); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,83,_ctx); - } - setState(820); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(819); - match(COMMA); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumEntryContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumEntry; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterEnumEntry(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitEnumEntry(this); - } - } - - public final EnumEntryContext enumEntry() throws RecognitionException { - EnumEntryContext _localctx = new EnumEntryContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_enumEntry); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(829); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { - case 1: - { - setState(822); - modifiers(); - setState(826); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(823); - match(NL); - } - } - setState(828); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - setState(831); - simpleIdentifier(); - setState(839); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { - case 1: - { - setState(835); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(832); - match(NL); - } - } - setState(837); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(838); - valueArguments(); - } - break; - } - setState(848); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { - case 1: - { - setState(844); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(841); - match(NL); - } - } - setState(846); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(847); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionDeclarationContext extends ParserRuleContext { - public TerminalNode FUN() { return getToken(KotlinParser.FUN, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public FunctionValueParametersContext functionValueParameters() { - return getRuleContext(FunctionValueParametersContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionDeclaration(this); - } - } - - public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { - FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_functionDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(851); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(850); - modifiers(); - } - } - - setState(853); - match(FUN); - setState(861); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { - case 1: - { - setState(857); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(854); - match(NL); - } - } - setState(859); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(860); - typeParameters(); - } - break; - } - setState(878); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { - case 1: - { - setState(866); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(863); - match(NL); - } - } - setState(868); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(869); - receiverType(); - setState(873); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(870); - match(NL); - } - } - setState(875); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(876); - match(DOT); - } - break; - } - setState(883); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(880); - match(NL); - } - } - setState(885); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(886); - simpleIdentifier(); - setState(890); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(887); - match(NL); - } - } - setState(892); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(893); - functionValueParameters(); - setState(908); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { - case 1: - { - setState(897); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(894); - match(NL); - } - } - setState(899); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(900); - match(COLON); - setState(904); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(901); - match(NL); - } - } - setState(906); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(907); - type(); - } - break; - } - setState(917); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { - case 1: - { - setState(913); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(910); - match(NL); - } - } - setState(915); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(916); - typeConstraints(); - } - break; - } - setState(926); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { - case 1: - { - setState(922); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(919); - match(NL); - } - } - setState(924); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(925); - functionBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionValueParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List functionValueParameter() { - return getRuleContexts(FunctionValueParameterContext.class); - } - public FunctionValueParameterContext functionValueParameter(int i) { - return getRuleContext(FunctionValueParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public FunctionValueParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionValueParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionValueParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionValueParameters(this); - } - } - - public final FunctionValueParametersContext functionValueParameters() throws RecognitionException { - FunctionValueParametersContext _localctx = new FunctionValueParametersContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_functionValueParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(928); - match(LPAREN); - setState(932); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,106,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(929); - match(NL); - } - } - } - setState(934); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,106,_ctx); - } - setState(955); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT - 40)) | (1L << (IMPORT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (BY - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (WHERE - 40)) | (1L << (CATCH - 40)) | (1L << (FINALLY - 40)) | (1L << (OUT - 40)) | (1L << (GETTER - 40)) | (1L << (SETTER - 40)) | (1L << (DYNAMIC - 40)) | (1L << (AT_FIELD - 40)) | (1L << (AT_PROPERTY - 40)) | (1L << (AT_GET - 40)) | (1L << (AT_SET - 40)) | (1L << (AT_RECEIVER - 40)))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (AT_PARAM - 104)) | (1L << (AT_SETPARAM - 104)) | (1L << (AT_DELEGATE - 104)) | (1L << (PUBLIC - 104)) | (1L << (PRIVATE - 104)) | (1L << (PROTECTED - 104)) | (1L << (INTERNAL - 104)) | (1L << (ENUM - 104)) | (1L << (SEALED - 104)) | (1L << (ANNOTATION - 104)) | (1L << (DATA - 104)) | (1L << (INNER - 104)) | (1L << (TAILREC - 104)) | (1L << (OPERATOR - 104)) | (1L << (INLINE - 104)) | (1L << (INFIX - 104)) | (1L << (EXTERNAL - 104)) | (1L << (SUSPEND - 104)) | (1L << (OVERRIDE - 104)) | (1L << (ABSTRACT - 104)) | (1L << (FINAL - 104)) | (1L << (OPEN - 104)) | (1L << (CONST - 104)) | (1L << (LATEINIT - 104)) | (1L << (VARARG - 104)) | (1L << (NOINLINE - 104)) | (1L << (CROSSINLINE - 104)) | (1L << (REIFIED - 104)) | (1L << (EXPECT - 104)) | (1L << (ACTUAL - 104)) | (1L << (Identifier - 104)))) != 0)) { - { - setState(935); - functionValueParameter(); - setState(952); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,109,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(939); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(936); - match(NL); - } - } - setState(941); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(942); - match(COMMA); - setState(946); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(943); - match(NL); - } - } - setState(948); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(949); - functionValueParameter(); - } - } - } - setState(954); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,109,_ctx); - } - } - } - - setState(960); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(957); - match(NL); - } - } - setState(962); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(963); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionValueParameterContext extends ParserRuleContext { - public ParameterContext parameter() { - return getRuleContext(ParameterContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionValueParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionValueParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionValueParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionValueParameter(this); - } - } - - public final FunctionValueParameterContext functionValueParameter() throws RecognitionException { - FunctionValueParameterContext _localctx = new FunctionValueParameterContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_functionValueParameter); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(966); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { - case 1: - { - setState(965); - modifiers(); - } - break; - } - setState(968); - parameter(); - setState(983); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { - case 1: - { - setState(972); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(969); - match(NL); - } - } - setState(974); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(975); - match(ASSIGNMENT); - setState(979); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,114,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(976); - match(NL); - } - } - } - setState(981); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,114,_ctx); - } - setState(982); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitParameter(this); - } - } - - public final ParameterContext parameter() throws RecognitionException { - ParameterContext _localctx = new ParameterContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_parameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(985); - simpleIdentifier(); - setState(989); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(986); - match(NL); - } - } - setState(991); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(992); - match(COLON); - setState(996); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(993); - match(NL); - } - } - setState(998); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(999); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SetterParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public SetterParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_setterParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSetterParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSetterParameter(this); - } - } - - public final SetterParameterContext setterParameter() throws RecognitionException { - SetterParameterContext _localctx = new SetterParameterContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_setterParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1001); - simpleIdentifier(); - setState(1005); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1002); - match(NL); - } - } - setState(1007); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1016); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(1008); - match(COLON); - setState(1012); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1009); - match(NL); - } - } - setState(1014); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1015); - type(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionBody(this); - } - } - - public final FunctionBodyContext functionBody() throws RecognitionException { - FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_functionBody); - try { - int _alt; - setState(1027); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LCURL: - enterOuterAlt(_localctx, 1); - { - setState(1018); - block(); - } - break; - case ASSIGNMENT: - enterOuterAlt(_localctx, 2); - { - setState(1019); - match(ASSIGNMENT); - setState(1023); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,121,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1020); - match(NL); - } - } - } - setState(1025); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,121,_ctx); - } - setState(1026); - expression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ObjectDeclarationContext extends ParserRuleContext { - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public ObjectDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_objectDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterObjectDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitObjectDeclaration(this); - } - } - - public final ObjectDeclarationContext objectDeclaration() throws RecognitionException { - ObjectDeclarationContext _localctx = new ObjectDeclarationContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_objectDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1030); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1029); - modifiers(); - } - } - - setState(1032); - match(OBJECT); - setState(1036); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1033); - match(NL); - } - } - setState(1038); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1039); - simpleIdentifier(); - setState(1054); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { - case 1: - { - setState(1043); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1040); - match(NL); - } - } - setState(1045); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1046); - match(COLON); - setState(1050); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,126,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1047); - match(NL); - } - } - } - setState(1052); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,126,_ctx); - } - setState(1053); - delegationSpecifiers(); - } - break; - } - setState(1063); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { - case 1: - { - setState(1059); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1056); - match(NL); - } - } - setState(1061); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1062); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CompanionObjectContext extends ParserRuleContext { - public TerminalNode COMPANION() { return getToken(KotlinParser.COMPANION, 0); } - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public CompanionObjectContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_companionObject; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterCompanionObject(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitCompanionObject(this); - } - } - - public final CompanionObjectContext companionObject() throws RecognitionException { - CompanionObjectContext _localctx = new CompanionObjectContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_companionObject); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1066); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1065); - modifiers(); - } - } - - setState(1068); - match(COMPANION); - setState(1072); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1069); - match(NL); - } - } - setState(1074); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1075); - match(OBJECT); - setState(1083); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) { - case 1: - { - setState(1079); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1076); - match(NL); - } - } - setState(1081); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1082); - simpleIdentifier(); - } - break; - } - setState(1099); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { - case 1: - { - setState(1088); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1085); - match(NL); - } - } - setState(1090); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1091); - match(COLON); - setState(1095); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,135,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1092); - match(NL); - } - } - } - setState(1097); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,135,_ctx); - } - setState(1098); - delegationSpecifiers(); - } - break; - } - setState(1108); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { - case 1: - { - setState(1104); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1101); - match(NL); - } - } - setState(1106); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1107); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PropertyDeclarationContext extends ParserRuleContext { - public TerminalNode VAL() { return getToken(KotlinParser.VAL, 0); } - public TerminalNode VAR() { return getToken(KotlinParser.VAR, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public PropertyDelegateContext propertyDelegate() { - return getRuleContext(PropertyDelegateContext.class,0); - } - public GetterContext getter() { - return getRuleContext(GetterContext.class,0); - } - public SetterContext setter() { - return getRuleContext(SetterContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public PropertyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPropertyDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPropertyDeclaration(this); - } - } - - public final PropertyDeclarationContext propertyDeclaration() throws RecognitionException { - PropertyDeclarationContext _localctx = new PropertyDeclarationContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_propertyDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1111); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1110); - modifiers(); - } - } - - setState(1113); - _la = _input.LA(1); - if ( !(_la==VAL || _la==VAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1121); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { - case 1: - { - setState(1117); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1114); - match(NL); - } - } - setState(1119); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1120); - typeParameters(); - } - break; - } - setState(1138); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { - case 1: - { - setState(1126); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1123); - match(NL); - } - } - setState(1128); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1129); - receiverType(); - setState(1133); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1130); - match(NL); - } - } - setState(1135); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1136); - match(DOT); - } - break; - } - { - setState(1143); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,145,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1140); - match(NL); - } - } - } - setState(1145); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,145,_ctx); - } - setState(1148); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - { - setState(1146); - multiVariableDeclaration(); - } - break; - case NL: - case AT: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1147); - variableDeclaration(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(1157); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { - case 1: - { - setState(1153); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1150); - match(NL); - } - } - setState(1155); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1156); - typeConstraints(); - } - break; - } - setState(1176); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { - case 1: - { - setState(1162); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1159); - match(NL); - } - } - setState(1164); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1174); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ASSIGNMENT: - { - setState(1165); - match(ASSIGNMENT); - setState(1169); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,150,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1166); - match(NL); - } - } - } - setState(1171); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,150,_ctx); - } - setState(1172); - expression(); - } - break; - case BY: - { - setState(1173); - propertyDelegate(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - } - setState(1184); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { - case 1: - { - setState(1179); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1178); - match(NL); - } - } - setState(1181); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==NL ); - setState(1183); - match(SEMICOLON); - } - break; - } - setState(1189); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,155,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1186); - match(NL); - } - } - } - setState(1191); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,155,_ctx); - } - setState(1222); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) { - case 1: - { - setState(1193); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { - case 1: - { - setState(1192); - getter(); - } - break; - } - setState(1205); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { - case 1: - { - setState(1198); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,157,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1195); - match(NL); - } - } - } - setState(1200); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,157,_ctx); - } - setState(1202); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & ((1L << (EOF - -1)) | (1L << (NL - -1)) | (1L << (SEMICOLON - -1)))) != 0)) { - { - setState(1201); - semi(); - } - } - - setState(1204); - setter(); - } - break; - } - } - break; - case 2: - { - setState(1208); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { - case 1: - { - setState(1207); - setter(); - } - break; - } - setState(1220); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { - case 1: - { - setState(1213); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,161,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1210); - match(NL); - } - } - } - setState(1215); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,161,_ctx); - } - setState(1217); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & ((1L << (EOF - -1)) | (1L << (NL - -1)) | (1L << (SEMICOLON - -1)))) != 0)) { - { - setState(1216); - semi(); - } - } - - setState(1219); - getter(); - } - break; - } - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiVariableDeclarationContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public List variableDeclaration() { - return getRuleContexts(VariableDeclarationContext.class); - } - public VariableDeclarationContext variableDeclaration(int i) { - return getRuleContext(VariableDeclarationContext.class,i); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public MultiVariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiVariableDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiVariableDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiVariableDeclaration(this); - } - } - - public final MultiVariableDeclarationContext multiVariableDeclaration() throws RecognitionException { - MultiVariableDeclarationContext _localctx = new MultiVariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_multiVariableDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1224); - match(LPAREN); - setState(1228); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,165,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1225); - match(NL); - } - } - } - setState(1230); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,165,_ctx); - } - setState(1231); - variableDeclaration(); - setState(1248); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,168,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1235); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1232); - match(NL); - } - } - setState(1237); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1238); - match(COMMA); - setState(1242); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,167,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1239); - match(NL); - } - } - } - setState(1244); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,167,_ctx); - } - setState(1245); - variableDeclaration(); - } - } - } - setState(1250); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,168,_ctx); - } - setState(1254); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1251); - match(NL); - } - } - setState(1256); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1257); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclarationContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterVariableDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitVariableDeclaration(this); - } - } - - public final VariableDeclarationContext variableDeclaration() throws RecognitionException { - VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_variableDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1262); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)))) != 0)) { - { - { - setState(1259); - annotation(); - } - } - setState(1264); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1268); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1265); - match(NL); - } - } - setState(1270); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1271); - simpleIdentifier(); - setState(1286); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { - case 1: - { - setState(1275); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1272); - match(NL); - } - } - setState(1277); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1278); - match(COLON); - setState(1282); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1279); - match(NL); - } - } - setState(1284); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1285); - type(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PropertyDelegateContext extends ParserRuleContext { - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public PropertyDelegateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyDelegate; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPropertyDelegate(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPropertyDelegate(this); - } - } - - public final PropertyDelegateContext propertyDelegate() throws RecognitionException { - PropertyDelegateContext _localctx = new PropertyDelegateContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_propertyDelegate); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1288); - match(BY); - setState(1292); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,175,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1289); - match(NL); - } - } - } - setState(1294); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,175,_ctx); - } - setState(1295); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GetterContext extends ParserRuleContext { - public TerminalNode GETTER() { return getToken(KotlinParser.GETTER, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public GetterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_getter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterGetter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitGetter(this); - } - } - - public final GetterContext getter() throws RecognitionException { - GetterContext _localctx = new GetterContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_getter); - int _la; - try { - setState(1342); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1298); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1297); - modifiers(); - } - } - - setState(1300); - match(GETTER); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1302); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1301); - modifiers(); - } - } - - setState(1304); - match(GETTER); - setState(1308); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1305); - match(NL); - } - } - setState(1310); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1311); - match(LPAREN); - setState(1315); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1312); - match(NL); - } - } - setState(1317); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1318); - match(RPAREN); - setState(1333); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { - case 1: - { - setState(1322); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1319); - match(NL); - } - } - setState(1324); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1325); - match(COLON); - setState(1329); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1326); - match(NL); - } - } - setState(1331); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1332); - type(); - } - break; - } - setState(1338); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1335); - match(NL); - } - } - setState(1340); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1341); - functionBody(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SetterContext extends ParserRuleContext { - public TerminalNode SETTER() { return getToken(KotlinParser.SETTER, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public SetterParameterContext setterParameter() { - return getRuleContext(SetterParameterContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List parameterModifier() { - return getRuleContexts(ParameterModifierContext.class); - } - public ParameterModifierContext parameterModifier(int i) { - return getRuleContext(ParameterModifierContext.class,i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public SetterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_setter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSetter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSetter(this); - } - } - - public final SetterContext setter() throws RecognitionException { - SetterContext _localctx = new SetterContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_setter); - int _la; - try { - int _alt; - setState(1392); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1345); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1344); - modifiers(); - } - } - - setState(1347); - match(SETTER); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1349); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1348); - modifiers(); - } - } - - setState(1351); - match(SETTER); - setState(1355); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1352); - match(NL); - } - } - setState(1357); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1358); - match(LPAREN); - setState(1363); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,189,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(1361); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - { - setState(1359); - annotation(); - } - break; - case VARARG: - case NOINLINE: - case CROSSINLINE: - { - setState(1360); - parameterModifier(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(1365); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,189,_ctx); - } - setState(1366); - setterParameter(); - setState(1367); - match(RPAREN); - setState(1382); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { - case 1: - { - setState(1371); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1368); - match(NL); - } - } - setState(1373); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1374); - match(COLON); - setState(1378); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1375); - match(NL); - } - } - setState(1380); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1381); - type(); - } - break; - } - setState(1387); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1384); - match(NL); - } - } - setState(1389); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1390); - functionBody(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeAliasContext extends ParserRuleContext { - public TerminalNode TYPE_ALIAS() { return getToken(KotlinParser.TYPE_ALIAS, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public TypeAliasContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeAlias; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeAlias(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeAlias(this); - } - } - - public final TypeAliasContext typeAlias() throws RecognitionException { - TypeAliasContext _localctx = new TypeAliasContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_typeAlias); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1395); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)) | (1L << (PUBLIC - 99)) | (1L << (PRIVATE - 99)) | (1L << (PROTECTED - 99)) | (1L << (INTERNAL - 99)) | (1L << (ENUM - 99)) | (1L << (SEALED - 99)) | (1L << (ANNOTATION - 99)) | (1L << (DATA - 99)) | (1L << (INNER - 99)) | (1L << (TAILREC - 99)) | (1L << (OPERATOR - 99)) | (1L << (INLINE - 99)) | (1L << (INFIX - 99)) | (1L << (EXTERNAL - 99)) | (1L << (SUSPEND - 99)) | (1L << (OVERRIDE - 99)) | (1L << (ABSTRACT - 99)) | (1L << (FINAL - 99)) | (1L << (OPEN - 99)) | (1L << (CONST - 99)) | (1L << (LATEINIT - 99)) | (1L << (VARARG - 99)) | (1L << (NOINLINE - 99)) | (1L << (CROSSINLINE - 99)) | (1L << (EXPECT - 99)) | (1L << (ACTUAL - 99)))) != 0)) { - { - setState(1394); - modifiers(); - } - } - - setState(1397); - match(TYPE_ALIAS); - setState(1401); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1398); - match(NL); - } - } - setState(1403); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1404); - simpleIdentifier(); - setState(1412); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { - case 1: - { - setState(1408); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1405); - match(NL); - } - } - setState(1410); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1411); - typeParameters(); - } - break; - } - setState(1417); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1414); - match(NL); - } - } - setState(1419); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1420); - match(ASSIGNMENT); - setState(1424); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1421); - match(NL); - } - } - setState(1426); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1427); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParametersContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public List typeParameter() { - return getRuleContexts(TypeParameterContext.class); - } - public TypeParameterContext typeParameter(int i) { - return getRuleContext(TypeParameterContext.class,i); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeParameters(this); - } - } - - public final TypeParametersContext typeParameters() throws RecognitionException { - TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_typeParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1429); - match(LANGLE); - setState(1433); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,201,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1430); - match(NL); - } - } - } - setState(1435); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,201,_ctx); - } - setState(1436); - typeParameter(); - setState(1453); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,204,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1440); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1437); - match(NL); - } - } - setState(1442); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1443); - match(COMMA); - setState(1447); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,203,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1444); - match(NL); - } - } - } - setState(1449); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,203,_ctx); - } - setState(1450); - typeParameter(); - } - } - } - setState(1455); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,204,_ctx); - } - setState(1459); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1456); - match(NL); - } - } - setState(1461); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1462); - match(RANGLE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TypeParameterModifiersContext typeParameterModifiers() { - return getRuleContext(TypeParameterModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeParameter(this); - } - } - - public final TypeParameterContext typeParameter() throws RecognitionException { - TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_typeParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1465); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { - case 1: - { - setState(1464); - typeParameterModifiers(); - } - break; - } - setState(1470); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1467); - match(NL); - } - } - setState(1472); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1473); - simpleIdentifier(); - setState(1488); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) { - case 1: - { - setState(1477); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1474); - match(NL); - } - } - setState(1479); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1480); - match(COLON); - setState(1484); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1481); - match(NL); - } - } - setState(1486); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1487); - type(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterModifiersContext extends ParserRuleContext { - public List typeParameterModifier() { - return getRuleContexts(TypeParameterModifierContext.class); - } - public TypeParameterModifierContext typeParameterModifier(int i) { - return getRuleContext(TypeParameterModifierContext.class,i); - } - public TypeParameterModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameterModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeParameterModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeParameterModifiers(this); - } - } - - public final TypeParameterModifiersContext typeParameterModifiers() throws RecognitionException { - TypeParameterModifiersContext _localctx = new TypeParameterModifiersContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_typeParameterModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1491); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1490); - typeParameterModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1493); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,211,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterModifierContext extends ParserRuleContext { - public ReificationModifierContext reificationModifier() { - return getRuleContext(ReificationModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public VarianceModifierContext varianceModifier() { - return getRuleContext(VarianceModifierContext.class,0); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameterModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeParameterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeParameterModifier(this); - } - } - - public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { - TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_typeParameterModifier); - try { - int _alt; - setState(1510); - _errHandler.sync(this); - switch (_input.LA(1)) { - case REIFIED: - enterOuterAlt(_localctx, 1); - { - setState(1495); - reificationModifier(); - setState(1499); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,212,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1496); - match(NL); - } - } - } - setState(1501); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,212,_ctx); - } - } - break; - case IN: - case OUT: - enterOuterAlt(_localctx, 2); - { - setState(1502); - varianceModifier(); - setState(1506); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,213,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1503); - match(NL); - } - } - } - setState(1508); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,213,_ctx); - } - } - break; - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 3); - { - setState(1509); - annotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeContext extends ParserRuleContext { - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public NullableTypeContext nullableType() { - return getRuleContext(NullableTypeContext.class,0); - } - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public TypeModifiersContext typeModifiers() { - return getRuleContext(TypeModifiersContext.class,0); - } - public TypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitType(this); - } - } - - public final TypeContext type() throws RecognitionException { - TypeContext _localctx = new TypeContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_type); - try { - enterOuterAlt(_localctx, 1); - { - setState(1513); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { - case 1: - { - setState(1512); - typeModifiers(); - } - break; - } - setState(1519); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) { - case 1: - { - setState(1515); - parenthesizedType(); - } - break; - case 2: - { - setState(1516); - nullableType(); - } - break; - case 3: - { - setState(1517); - typeReference(); - } - break; - case 4: - { - setState(1518); - functionType(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeModifiersContext extends ParserRuleContext { - public List typeModifier() { - return getRuleContexts(TypeModifierContext.class); - } - public TypeModifierContext typeModifier(int i) { - return getRuleContext(TypeModifierContext.class,i); - } - public TypeModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeModifiers(this); - } - } - - public final TypeModifiersContext typeModifiers() throws RecognitionException { - TypeModifiersContext _localctx = new TypeModifiersContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_typeModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1522); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1521); - typeModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1524); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,217,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeModifier(this); - } - } - - public final TypeModifierContext typeModifier() throws RecognitionException { - TypeModifierContext _localctx = new TypeModifierContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_typeModifier); - int _la; - try { - setState(1534); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 1); - { - setState(1526); - annotation(); - } - break; - case SUSPEND: - enterOuterAlt(_localctx, 2); - { - setState(1527); - match(SUSPEND); - setState(1531); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1528); - match(NL); - } - } - setState(1533); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedTypeContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterParenthesizedType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitParenthesizedType(this); - } - } - - public final ParenthesizedTypeContext parenthesizedType() throws RecognitionException { - ParenthesizedTypeContext _localctx = new ParenthesizedTypeContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_parenthesizedType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1536); - match(LPAREN); - setState(1540); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1537); - match(NL); - } - } - setState(1542); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1543); - type(); - setState(1547); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1544); - match(NL); - } - } - setState(1549); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1550); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NullableTypeContext extends ParserRuleContext { - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List quest() { - return getRuleContexts(QuestContext.class); - } - public QuestContext quest(int i) { - return getRuleContext(QuestContext.class,i); - } - public NullableTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nullableType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterNullableType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitNullableType(this); - } - } - - public final NullableTypeContext nullableType() throws RecognitionException { - NullableTypeContext _localctx = new NullableTypeContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_nullableType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1554); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1552); - typeReference(); - } - break; - case LPAREN: - { - setState(1553); - parenthesizedType(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1559); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1556); - match(NL); - } - } - setState(1561); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1563); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1562); - quest(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1565); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,224,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeReferenceContext extends ParserRuleContext { - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public TerminalNode DYNAMIC() { return getToken(KotlinParser.DYNAMIC, 0); } - public TypeReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeReference; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeReference(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeReference(this); - } - } - - public final TypeReferenceContext typeReference() throws RecognitionException { - TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_typeReference); - try { - setState(1569); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1567); - userType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1568); - match(DYNAMIC); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionTypeContext extends ParserRuleContext { - public FunctionTypeParametersContext functionTypeParameters() { - return getRuleContext(FunctionTypeParametersContext.class,0); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionType(this); - } - } - - public final FunctionTypeContext functionType() throws RecognitionException { - FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_functionType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1585); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) { - case 1: - { - setState(1571); - receiverType(); - setState(1575); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1572); - match(NL); - } - } - setState(1577); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1578); - match(DOT); - setState(1582); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1579); - match(NL); - } - } - setState(1584); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - setState(1587); - functionTypeParameters(); - setState(1591); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1588); - match(NL); - } - } - setState(1593); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1594); - match(ARROW); - setState(1598); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1595); - match(NL); - } - } - setState(1600); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1601); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ReceiverTypeContext extends ParserRuleContext { - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public NullableTypeContext nullableType() { - return getRuleContext(NullableTypeContext.class,0); - } - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public TypeModifiersContext typeModifiers() { - return getRuleContext(TypeModifiersContext.class,0); - } - public ReceiverTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_receiverType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterReceiverType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitReceiverType(this); - } - } - - public final ReceiverTypeContext receiverType() throws RecognitionException { - ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_receiverType); - try { - enterOuterAlt(_localctx, 1); - { - setState(1604); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) { - case 1: - { - setState(1603); - typeModifiers(); - } - break; - } - setState(1609); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) { - case 1: - { - setState(1606); - parenthesizedType(); - } - break; - case 2: - { - setState(1607); - nullableType(); - } - break; - case 3: - { - setState(1608); - typeReference(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class UserTypeContext extends ParserRuleContext { - public List simpleUserType() { - return getRuleContexts(SimpleUserTypeContext.class); - } - public SimpleUserTypeContext simpleUserType(int i) { - return getRuleContext(SimpleUserTypeContext.class,i); - } - public List DOT() { return getTokens(KotlinParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(KotlinParser.DOT, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public UserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_userType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitUserType(this); - } - } - - public final UserTypeContext userType() throws RecognitionException { - UserTypeContext _localctx = new UserTypeContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_userType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1611); - simpleUserType(); - setState(1628); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,235,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1615); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1612); - match(NL); - } - } - setState(1617); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1618); - match(DOT); - setState(1622); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1619); - match(NL); - } - } - setState(1624); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1625); - simpleUserType(); - } - } - } - setState(1630); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,235,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedUserTypeContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedUserTypeContext parenthesizedUserType() { - return getRuleContext(ParenthesizedUserTypeContext.class,0); - } - public ParenthesizedUserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedUserType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterParenthesizedUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitParenthesizedUserType(this); - } - } - - public final ParenthesizedUserTypeContext parenthesizedUserType() throws RecognitionException { - ParenthesizedUserTypeContext _localctx = new ParenthesizedUserTypeContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_parenthesizedUserType); - int _la; - try { - setState(1663); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1631); - match(LPAREN); - setState(1635); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1632); - match(NL); - } - } - setState(1637); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1638); - userType(); - setState(1642); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1639); - match(NL); - } - } - setState(1644); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1645); - match(RPAREN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1647); - match(LPAREN); - setState(1651); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1648); - match(NL); - } - } - setState(1653); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1654); - parenthesizedUserType(); - setState(1658); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1655); - match(NL); - } - } - setState(1660); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1661); - match(RPAREN); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SimpleUserTypeContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleUserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simpleUserType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSimpleUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSimpleUserType(this); - } - } - - public final SimpleUserTypeContext simpleUserType() throws RecognitionException { - SimpleUserTypeContext _localctx = new SimpleUserTypeContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_simpleUserType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1665); - simpleIdentifier(); - setState(1673); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) { - case 1: - { - setState(1669); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1666); - match(NL); - } - } - setState(1671); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1672); - typeArguments(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionTypeParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List parameter() { - return getRuleContexts(ParameterContext.class); - } - public ParameterContext parameter(int i) { - return getRuleContext(ParameterContext.class,i); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public FunctionTypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionTypeParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionTypeParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionTypeParameters(this); - } - } - - public final FunctionTypeParametersContext functionTypeParameters() throws RecognitionException { - FunctionTypeParametersContext _localctx = new FunctionTypeParametersContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_functionTypeParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1675); - match(LPAREN); - setState(1679); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,243,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1676); - match(NL); - } - } - } - setState(1681); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,243,_ctx); - } - setState(1684); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) { - case 1: - { - setState(1682); - parameter(); - } - break; - case 2: - { - setState(1683); - type(); - } - break; - } - setState(1705); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,248,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1689); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1686); - match(NL); - } - } - setState(1691); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1692); - match(COMMA); - setState(1696); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1693); - match(NL); - } - } - setState(1698); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1701); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) { - case 1: - { - setState(1699); - parameter(); - } - break; - case 2: - { - setState(1700); - type(); - } - break; - } - } - } - } - setState(1707); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,248,_ctx); - } - setState(1711); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1708); - match(NL); - } - } - setState(1713); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1714); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeConstraintsContext extends ParserRuleContext { - public TerminalNode WHERE() { return getToken(KotlinParser.WHERE, 0); } - public List typeConstraint() { - return getRuleContexts(TypeConstraintContext.class); - } - public TypeConstraintContext typeConstraint(int i) { - return getRuleContext(TypeConstraintContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeConstraintsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeConstraints; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeConstraints(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeConstraints(this); - } - } - - public final TypeConstraintsContext typeConstraints() throws RecognitionException { - TypeConstraintsContext _localctx = new TypeConstraintsContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_typeConstraints); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1716); - match(WHERE); - setState(1720); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1717); - match(NL); - } - } - setState(1722); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1723); - typeConstraint(); - setState(1740); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,253,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1727); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1724); - match(NL); - } - } - setState(1729); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1730); - match(COMMA); - setState(1734); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1731); - match(NL); - } - } - setState(1736); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1737); - typeConstraint(); - } - } - } - setState(1742); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,253,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeConstraintContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeConstraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeConstraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeConstraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeConstraint(this); - } - } - - public final TypeConstraintContext typeConstraint() throws RecognitionException { - TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_typeConstraint); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1746); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)))) != 0)) { - { - { - setState(1743); - annotation(); - } - } - setState(1748); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1749); - simpleIdentifier(); - setState(1753); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1750); - match(NL); - } - } - setState(1755); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1756); - match(COLON); - setState(1760); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1757); - match(NL); - } - } - setState(1762); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1763); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BlockContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public StatementsContext statements() { - return getRuleContext(StatementsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public BlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_block; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitBlock(this); - } - } - - public final BlockContext block() throws RecognitionException { - BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_block); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1765); - match(LCURL); - setState(1769); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,257,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1766); - match(NL); - } - } - } - setState(1771); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,257,_ctx); - } - setState(1772); - statements(); - setState(1776); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1773); - match(NL); - } - } - setState(1778); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1779); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementsContext extends ParserRuleContext { - public List statement() { - return getRuleContexts(StatementContext.class); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public List semis() { - return getRuleContexts(SemisContext.class); - } - public SemisContext semis(int i) { - return getRuleContext(SemisContext.class,i); - } - public StatementsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statements; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterStatements(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitStatements(this); - } - } - - public final StatementsContext statements() throws RecognitionException { - StatementsContext _localctx = new StatementsContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_statements); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1793); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) { - case 1: - { - setState(1781); - statement(); - setState(1787); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,259,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1782); - semis(); - setState(1783); - statement(); - } - } - } - setState(1789); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,259,_ctx); - } - setState(1791); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,260,_ctx) ) { - case 1: - { - setState(1790); - semis(); - } - break; - } - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementContext extends ParserRuleContext { - public DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public AssignmentContext assignment() { - return getRuleContext(AssignmentContext.class,0); - } - public LoopStatementContext loopStatement() { - return getRuleContext(LoopStatementContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List label() { - return getRuleContexts(LabelContext.class); - } - public LabelContext label(int i) { - return getRuleContext(LabelContext.class,i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitStatement(this); - } - } - - public final StatementContext statement() throws RecognitionException { - StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_statement); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1799); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,263,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(1797); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IdentifierAt: - { - setState(1795); - label(); - } - break; - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - { - setState(1796); - annotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(1801); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,263,_ctx); - } - setState(1806); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,264,_ctx) ) { - case 1: - { - setState(1802); - declaration(); - } - break; - case 2: - { - setState(1803); - assignment(); - } - break; - case 3: - { - setState(1804); - loopStatement(); - } - break; - case 4: - { - setState(1805); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DeclarationContext extends ParserRuleContext { - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class,0); - } - public ObjectDeclarationContext objectDeclaration() { - return getRuleContext(ObjectDeclarationContext.class,0); - } - public FunctionDeclarationContext functionDeclaration() { - return getRuleContext(FunctionDeclarationContext.class,0); - } - public PropertyDeclarationContext propertyDeclaration() { - return getRuleContext(PropertyDeclarationContext.class,0); - } - public TypeAliasContext typeAlias() { - return getRuleContext(TypeAliasContext.class,0); - } - public DeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDeclaration(this); - } - } - - public final DeclarationContext declaration() throws RecognitionException { - DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_declaration); - try { - setState(1813); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,265,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1808); - classDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1809); - objectDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1810); - functionDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1811); - propertyDeclaration(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1812); - typeAlias(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentContext extends ParserRuleContext { - public DirectlyAssignableExpressionContext directlyAssignableExpression() { - return getRuleContext(DirectlyAssignableExpressionContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AssignableExpressionContext assignableExpression() { - return getRuleContext(AssignableExpressionContext.class,0); - } - public AssignmentAndOperatorContext assignmentAndOperator() { - return getRuleContext(AssignmentAndOperatorContext.class,0); - } - public AssignmentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignment; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAssignment(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAssignment(this); - } - } - - public final AssignmentContext assignment() throws RecognitionException { - AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_assignment); - try { - int _alt; - setState(1835); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,268,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1815); - directlyAssignableExpression(); - setState(1816); - match(ASSIGNMENT); - setState(1820); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,266,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1817); - match(NL); - } - } - } - setState(1822); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,266,_ctx); - } - setState(1823); - expression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1825); - assignableExpression(); - setState(1826); - assignmentAndOperator(); - setState(1830); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,267,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1827); - match(NL); - } - } - } - setState(1832); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,267,_ctx); - } - setState(1833); - expression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionContext extends ParserRuleContext { - public DisjunctionContext disjunction() { - return getRuleContext(DisjunctionContext.class,0); - } - public ExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitExpression(this); - } - } - - public final ExpressionContext expression() throws RecognitionException { - ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1837); - disjunction(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DisjunctionContext extends ParserRuleContext { - public List conjunction() { - return getRuleContexts(ConjunctionContext.class); - } - public ConjunctionContext conjunction(int i) { - return getRuleContext(ConjunctionContext.class,i); - } - public List DISJ() { return getTokens(KotlinParser.DISJ); } - public TerminalNode DISJ(int i) { - return getToken(KotlinParser.DISJ, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public DisjunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_disjunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDisjunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDisjunction(this); - } - } - - public final DisjunctionContext disjunction() throws RecognitionException { - DisjunctionContext _localctx = new DisjunctionContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_disjunction); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1839); - conjunction(); - setState(1856); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,271,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1843); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1840); - match(NL); - } - } - setState(1845); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1846); - match(DISJ); - setState(1850); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,270,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1847); - match(NL); - } - } - } - setState(1852); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,270,_ctx); - } - setState(1853); - conjunction(); - } - } - } - setState(1858); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,271,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConjunctionContext extends ParserRuleContext { - public List equality() { - return getRuleContexts(EqualityContext.class); - } - public EqualityContext equality(int i) { - return getRuleContext(EqualityContext.class,i); - } - public List CONJ() { return getTokens(KotlinParser.CONJ); } - public TerminalNode CONJ(int i) { - return getToken(KotlinParser.CONJ, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ConjunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conjunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterConjunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitConjunction(this); - } - } - - public final ConjunctionContext conjunction() throws RecognitionException { - ConjunctionContext _localctx = new ConjunctionContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_conjunction); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1859); - equality(); - setState(1876); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,274,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1863); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1860); - match(NL); - } - } - setState(1865); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1866); - match(CONJ); - setState(1870); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,273,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1867); - match(NL); - } - } - } - setState(1872); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,273,_ctx); - } - setState(1873); - equality(); - } - } - } - setState(1878); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,274,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EqualityContext extends ParserRuleContext { - public List comparison() { - return getRuleContexts(ComparisonContext.class); - } - public ComparisonContext comparison(int i) { - return getRuleContext(ComparisonContext.class,i); - } - public List equalityOperator() { - return getRuleContexts(EqualityOperatorContext.class); - } - public EqualityOperatorContext equalityOperator(int i) { - return getRuleContext(EqualityOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EqualityContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_equality; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterEquality(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitEquality(this); - } - } - - public final EqualityContext equality() throws RecognitionException { - EqualityContext _localctx = new EqualityContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_equality); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1879); - comparison(); - setState(1891); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,276,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1880); - equalityOperator(); - setState(1884); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,275,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1881); - match(NL); - } - } - } - setState(1886); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,275,_ctx); - } - setState(1887); - comparison(); - } - } - } - setState(1893); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,276,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ComparisonContext extends ParserRuleContext { - public List infixOperation() { - return getRuleContexts(InfixOperationContext.class); - } - public InfixOperationContext infixOperation(int i) { - return getRuleContext(InfixOperationContext.class,i); - } - public ComparisonOperatorContext comparisonOperator() { - return getRuleContext(ComparisonOperatorContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ComparisonContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_comparison; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterComparison(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitComparison(this); - } - } - - public final ComparisonContext comparison() throws RecognitionException { - ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_comparison); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1894); - infixOperation(); - setState(1904); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) { - case 1: - { - setState(1895); - comparisonOperator(); - setState(1899); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,277,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1896); - match(NL); - } - } - } - setState(1901); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,277,_ctx); - } - setState(1902); - infixOperation(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InfixOperationContext extends ParserRuleContext { - public List elvisExpression() { - return getRuleContexts(ElvisExpressionContext.class); - } - public ElvisExpressionContext elvisExpression(int i) { - return getRuleContext(ElvisExpressionContext.class,i); - } - public List inOperator() { - return getRuleContexts(InOperatorContext.class); - } - public InOperatorContext inOperator(int i) { - return getRuleContext(InOperatorContext.class,i); - } - public List isOperator() { - return getRuleContexts(IsOperatorContext.class); - } - public IsOperatorContext isOperator(int i) { - return getRuleContext(IsOperatorContext.class,i); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public InfixOperationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_infixOperation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterInfixOperation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitInfixOperation(this); - } - } - - public final InfixOperationContext infixOperation() throws RecognitionException { - InfixOperationContext _localctx = new InfixOperationContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_infixOperation); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1906); - elvisExpression(); - setState(1927); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,282,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(1925); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IN: - case NOT_IN: - { - setState(1907); - inOperator(); - setState(1911); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,279,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1908); - match(NL); - } - } - } - setState(1913); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,279,_ctx); - } - setState(1914); - elvisExpression(); - } - break; - case IS: - case NOT_IS: - { - setState(1916); - isOperator(); - setState(1920); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1917); - match(NL); - } - } - setState(1922); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1923); - type(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(1929); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,282,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElvisExpressionContext extends ParserRuleContext { - public List infixFunctionCall() { - return getRuleContexts(InfixFunctionCallContext.class); - } - public InfixFunctionCallContext infixFunctionCall(int i) { - return getRuleContext(InfixFunctionCallContext.class,i); - } - public List elvis() { - return getRuleContexts(ElvisContext.class); - } - public ElvisContext elvis(int i) { - return getRuleContext(ElvisContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ElvisExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_elvisExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterElvisExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitElvisExpression(this); - } - } - - public final ElvisExpressionContext elvisExpression() throws RecognitionException { - ElvisExpressionContext _localctx = new ElvisExpressionContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_elvisExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1930); - infixFunctionCall(); - setState(1948); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,285,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1934); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1931); - match(NL); - } - } - setState(1936); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1937); - elvis(); - setState(1941); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,284,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1938); - match(NL); - } - } - } - setState(1943); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,284,_ctx); - } - setState(1944); - infixFunctionCall(); - } - } - } - setState(1950); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,285,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InfixFunctionCallContext extends ParserRuleContext { - public List rangeExpression() { - return getRuleContexts(RangeExpressionContext.class); - } - public RangeExpressionContext rangeExpression(int i) { - return getRuleContext(RangeExpressionContext.class,i); - } - public List simpleIdentifier() { - return getRuleContexts(SimpleIdentifierContext.class); - } - public SimpleIdentifierContext simpleIdentifier(int i) { - return getRuleContext(SimpleIdentifierContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public InfixFunctionCallContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_infixFunctionCall; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterInfixFunctionCall(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitInfixFunctionCall(this); - } - } - - public final InfixFunctionCallContext infixFunctionCall() throws RecognitionException { - InfixFunctionCallContext _localctx = new InfixFunctionCallContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_infixFunctionCall); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1951); - rangeExpression(); - setState(1963); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,287,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1952); - simpleIdentifier(); - setState(1956); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,286,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1953); - match(NL); - } - } - } - setState(1958); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,286,_ctx); - } - setState(1959); - rangeExpression(); - } - } - } - setState(1965); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,287,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class RangeExpressionContext extends ParserRuleContext { - public List additiveExpression() { - return getRuleContexts(AdditiveExpressionContext.class); - } - public AdditiveExpressionContext additiveExpression(int i) { - return getRuleContext(AdditiveExpressionContext.class,i); - } - public List RANGE() { return getTokens(KotlinParser.RANGE); } - public TerminalNode RANGE(int i) { - return getToken(KotlinParser.RANGE, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public RangeExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rangeExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterRangeExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitRangeExpression(this); - } - } - - public final RangeExpressionContext rangeExpression() throws RecognitionException { - RangeExpressionContext _localctx = new RangeExpressionContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_rangeExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1966); - additiveExpression(); - setState(1977); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,289,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1967); - match(RANGE); - setState(1971); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,288,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1968); - match(NL); - } - } - } - setState(1973); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,288,_ctx); - } - setState(1974); - additiveExpression(); - } - } - } - setState(1979); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,289,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AdditiveExpressionContext extends ParserRuleContext { - public List multiplicativeExpression() { - return getRuleContexts(MultiplicativeExpressionContext.class); - } - public MultiplicativeExpressionContext multiplicativeExpression(int i) { - return getRuleContext(MultiplicativeExpressionContext.class,i); - } - public List additiveOperator() { - return getRuleContexts(AdditiveOperatorContext.class); - } - public AdditiveOperatorContext additiveOperator(int i) { - return getRuleContext(AdditiveOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_additiveExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAdditiveExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAdditiveExpression(this); - } - } - - public final AdditiveExpressionContext additiveExpression() throws RecognitionException { - AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_additiveExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1980); - multiplicativeExpression(); - setState(1992); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,291,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1981); - additiveOperator(); - setState(1985); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,290,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1982); - match(NL); - } - } - } - setState(1987); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,290,_ctx); - } - setState(1988); - multiplicativeExpression(); - } - } - } - setState(1994); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,291,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiplicativeExpressionContext extends ParserRuleContext { - public List asExpression() { - return getRuleContexts(AsExpressionContext.class); - } - public AsExpressionContext asExpression(int i) { - return getRuleContext(AsExpressionContext.class,i); - } - public List multiplicativeOperator() { - return getRuleContexts(MultiplicativeOperatorContext.class); - } - public MultiplicativeOperatorContext multiplicativeOperator(int i) { - return getRuleContext(MultiplicativeOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiplicativeExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiplicativeExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiplicativeExpression(this); - } - } - - public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { - MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_multiplicativeExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1995); - asExpression(); - setState(2007); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,293,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1996); - multiplicativeOperator(); - setState(2000); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,292,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1997); - match(NL); - } - } - } - setState(2002); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,292,_ctx); - } - setState(2003); - asExpression(); - } - } - } - setState(2009); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,293,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AsExpressionContext extends ParserRuleContext { - public PrefixUnaryExpressionContext prefixUnaryExpression() { - return getRuleContext(PrefixUnaryExpressionContext.class,0); - } - public AsOperatorContext asOperator() { - return getRuleContext(AsOperatorContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AsExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_asExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAsExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAsExpression(this); - } - } - - public final AsExpressionContext asExpression() throws RecognitionException { - AsExpressionContext _localctx = new AsExpressionContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_asExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2010); - prefixUnaryExpression(); - setState(2026); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) { - case 1: - { - setState(2014); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2011); - match(NL); - } - } - setState(2016); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2017); - asOperator(); - setState(2021); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2018); - match(NL); - } - } - setState(2023); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2024); - type(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrefixUnaryExpressionContext extends ParserRuleContext { - public PostfixUnaryExpressionContext postfixUnaryExpression() { - return getRuleContext(PostfixUnaryExpressionContext.class,0); - } - public List unaryPrefix() { - return getRuleContexts(UnaryPrefixContext.class); - } - public UnaryPrefixContext unaryPrefix(int i) { - return getRuleContext(UnaryPrefixContext.class,i); - } - public PrefixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prefixUnaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPrefixUnaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPrefixUnaryExpression(this); - } - } - - public final PrefixUnaryExpressionContext prefixUnaryExpression() throws RecognitionException { - PrefixUnaryExpressionContext _localctx = new PrefixUnaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_prefixUnaryExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2031); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,297,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2028); - unaryPrefix(); - } - } - } - setState(2033); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,297,_ctx); - } - setState(2034); - postfixUnaryExpression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class UnaryPrefixContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public LabelContext label() { - return getRuleContext(LabelContext.class,0); - } - public PrefixUnaryOperatorContext prefixUnaryOperator() { - return getRuleContext(PrefixUnaryOperatorContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public UnaryPrefixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unaryPrefix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterUnaryPrefix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitUnaryPrefix(this); - } - } - - public final UnaryPrefixContext unaryPrefix() throws RecognitionException { - UnaryPrefixContext _localctx = new UnaryPrefixContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_unaryPrefix); - try { - int _alt; - setState(2045); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 1); - { - setState(2036); - annotation(); - } - break; - case IdentifierAt: - enterOuterAlt(_localctx, 2); - { - setState(2037); - label(); - } - break; - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(2038); - prefixUnaryOperator(); - setState(2042); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,298,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2039); - match(NL); - } - } - } - setState(2044); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,298,_ctx); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixUnaryExpressionContext extends ParserRuleContext { - public PrimaryExpressionContext primaryExpression() { - return getRuleContext(PrimaryExpressionContext.class,0); - } - public List postfixUnarySuffix() { - return getRuleContexts(PostfixUnarySuffixContext.class); - } - public PostfixUnarySuffixContext postfixUnarySuffix(int i) { - return getRuleContext(PostfixUnarySuffixContext.class,i); - } - public PostfixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPostfixUnaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPostfixUnaryExpression(this); - } - } - - public final PostfixUnaryExpressionContext postfixUnaryExpression() throws RecognitionException { - PostfixUnaryExpressionContext _localctx = new PostfixUnaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_postfixUnaryExpression); - try { - int _alt; - setState(2054); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,301,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2047); - primaryExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2048); - primaryExpression(); - setState(2050); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(2049); - postfixUnarySuffix(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(2052); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,300,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixUnarySuffixContext extends ParserRuleContext { - public PostfixUnaryOperatorContext postfixUnaryOperator() { - return getRuleContext(PostfixUnaryOperatorContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public CallSuffixContext callSuffix() { - return getRuleContext(CallSuffixContext.class,0); - } - public IndexingSuffixContext indexingSuffix() { - return getRuleContext(IndexingSuffixContext.class,0); - } - public NavigationSuffixContext navigationSuffix() { - return getRuleContext(NavigationSuffixContext.class,0); - } - public PostfixUnarySuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnarySuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPostfixUnarySuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPostfixUnarySuffix(this); - } - } - - public final PostfixUnarySuffixContext postfixUnarySuffix() throws RecognitionException { - PostfixUnarySuffixContext _localctx = new PostfixUnarySuffixContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_postfixUnarySuffix); - try { - setState(2061); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,302,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2056); - postfixUnaryOperator(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2057); - typeArguments(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2058); - callSuffix(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2059); - indexingSuffix(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2060); - navigationSuffix(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DirectlyAssignableExpressionContext extends ParserRuleContext { - public PostfixUnaryExpressionContext postfixUnaryExpression() { - return getRuleContext(PostfixUnaryExpressionContext.class,0); - } - public AssignableSuffixContext assignableSuffix() { - return getRuleContext(AssignableSuffixContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public DirectlyAssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_directlyAssignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDirectlyAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDirectlyAssignableExpression(this); - } - } - - public final DirectlyAssignableExpressionContext directlyAssignableExpression() throws RecognitionException { - DirectlyAssignableExpressionContext _localctx = new DirectlyAssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_directlyAssignableExpression); - try { - setState(2067); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2063); - postfixUnaryExpression(); - setState(2064); - assignableSuffix(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2066); - simpleIdentifier(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignableExpressionContext extends ParserRuleContext { - public PrefixUnaryExpressionContext prefixUnaryExpression() { - return getRuleContext(PrefixUnaryExpressionContext.class,0); - } - public AssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAssignableExpression(this); - } - } - - public final AssignableExpressionContext assignableExpression() throws RecognitionException { - AssignableExpressionContext _localctx = new AssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_assignableExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2069); - prefixUnaryExpression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignableSuffixContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public IndexingSuffixContext indexingSuffix() { - return getRuleContext(IndexingSuffixContext.class,0); - } - public NavigationSuffixContext navigationSuffix() { - return getRuleContext(NavigationSuffixContext.class,0); - } - public AssignableSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignableSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAssignableSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAssignableSuffix(this); - } - } - - public final AssignableSuffixContext assignableSuffix() throws RecognitionException { - AssignableSuffixContext _localctx = new AssignableSuffixContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_assignableSuffix); - try { - setState(2074); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LANGLE: - enterOuterAlt(_localctx, 1); - { - setState(2071); - typeArguments(); - } - break; - case LSQUARE: - enterOuterAlt(_localctx, 2); - { - setState(2072); - indexingSuffix(); - } - break; - case NL: - case DOT: - case COLONCOLON: - case QUEST_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(2073); - navigationSuffix(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IndexingSuffixContext extends ParserRuleContext { - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public IndexingSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_indexingSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterIndexingSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitIndexingSuffix(this); - } - } - - public final IndexingSuffixContext indexingSuffix() throws RecognitionException { - IndexingSuffixContext _localctx = new IndexingSuffixContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_indexingSuffix); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2076); - match(LSQUARE); - setState(2080); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,305,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2077); - match(NL); - } - } - } - setState(2082); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,305,_ctx); - } - setState(2083); - expression(); - setState(2100); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,308,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2087); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2084); - match(NL); - } - } - setState(2089); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2090); - match(COMMA); - setState(2094); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,307,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2091); - match(NL); - } - } - } - setState(2096); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,307,_ctx); - } - setState(2097); - expression(); - } - } - } - setState(2102); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,308,_ctx); - } - setState(2106); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2103); - match(NL); - } - } - setState(2108); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2109); - match(RSQUARE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NavigationSuffixContext extends ParserRuleContext { - public MemberAccessOperatorContext memberAccessOperator() { - return getRuleContext(MemberAccessOperatorContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ParenthesizedExpressionContext parenthesizedExpression() { - return getRuleContext(ParenthesizedExpressionContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public NavigationSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_navigationSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterNavigationSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitNavigationSuffix(this); - } - } - - public final NavigationSuffixContext navigationSuffix() throws RecognitionException { - NavigationSuffixContext _localctx = new NavigationSuffixContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_navigationSuffix); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2114); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2111); - match(NL); - } - } - setState(2116); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2117); - memberAccessOperator(); - setState(2121); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2118); - match(NL); - } - } - setState(2123); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2127); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(2124); - simpleIdentifier(); - } - break; - case LPAREN: - { - setState(2125); - parenthesizedExpression(); - } - break; - case CLASS: - { - setState(2126); - match(CLASS); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CallSuffixContext extends ParserRuleContext { - public AnnotatedLambdaContext annotatedLambda() { - return getRuleContext(AnnotatedLambdaContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public CallSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_callSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterCallSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitCallSuffix(this); - } - } - - public final CallSuffixContext callSuffix() throws RecognitionException { - CallSuffixContext _localctx = new CallSuffixContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_callSuffix); - int _la; - try { - setState(2140); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,316,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2130); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LANGLE) { - { - setState(2129); - typeArguments(); - } - } - - setState(2133); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(2132); - valueArguments(); - } - } - - setState(2135); - annotatedLambda(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2137); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LANGLE) { - { - setState(2136); - typeArguments(); - } - } - - setState(2139); - valueArguments(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotatedLambdaContext extends ParserRuleContext { - public LambdaLiteralContext lambdaLiteral() { - return getRuleContext(LambdaLiteralContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public LabelContext label() { - return getRuleContext(LabelContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotatedLambdaContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotatedLambda; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnnotatedLambda(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnnotatedLambda(this); - } - } - - public final AnnotatedLambdaContext annotatedLambda() throws RecognitionException { - AnnotatedLambdaContext _localctx = new AnnotatedLambdaContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_annotatedLambda); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2145); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)))) != 0)) { - { - { - setState(2142); - annotation(); - } - } - setState(2147); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2149); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IdentifierAt) { - { - setState(2148); - label(); - } - } - - setState(2154); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2151); - match(NL); - } - } - setState(2156); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2157); - lambdaLiteral(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ValueArgumentsContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List valueArgument() { - return getRuleContexts(ValueArgumentContext.class); - } - public ValueArgumentContext valueArgument(int i) { - return getRuleContext(ValueArgumentContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public ValueArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_valueArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterValueArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitValueArguments(this); - } - } - - public final ValueArgumentsContext valueArguments() throws RecognitionException { - ValueArgumentsContext _localctx = new ValueArgumentsContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_valueArguments); - int _la; - try { - int _alt; - setState(2202); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2159); - match(LPAREN); - setState(2163); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2160); - match(NL); - } - } - setState(2165); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2166); - match(RPAREN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2167); - match(LPAREN); - setState(2171); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,321,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2168); - match(NL); - } - } - } - setState(2173); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,321,_ctx); - } - setState(2174); - valueArgument(); - setState(2191); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,324,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2178); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2175); - match(NL); - } - } - setState(2180); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2181); - match(COMMA); - setState(2185); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,323,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2182); - match(NL); - } - } - } - setState(2187); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,323,_ctx); - } - setState(2188); - valueArgument(); - } - } - } - setState(2193); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,324,_ctx); - } - setState(2197); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2194); - match(NL); - } - } - setState(2199); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2200); - match(RPAREN); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public List typeProjection() { - return getRuleContexts(TypeProjectionContext.class); - } - public TypeProjectionContext typeProjection(int i) { - return getRuleContext(TypeProjectionContext.class,i); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeArguments(this); - } - } - - public final TypeArgumentsContext typeArguments() throws RecognitionException { - TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_typeArguments); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2204); - match(LANGLE); - setState(2208); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2205); - match(NL); - } - } - setState(2210); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2211); - typeProjection(); - setState(2228); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,330,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2215); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2212); - match(NL); - } - } - setState(2217); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2218); - match(COMMA); - setState(2222); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2219); - match(NL); - } - } - setState(2224); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2225); - typeProjection(); - } - } - } - setState(2230); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,330,_ctx); - } - setState(2234); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2231); - match(NL); - } - } - setState(2236); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2237); - match(RANGLE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeProjectionContext extends ParserRuleContext { - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeProjectionModifiersContext typeProjectionModifiers() { - return getRuleContext(TypeProjectionModifiersContext.class,0); - } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public TypeProjectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjection; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeProjection(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeProjection(this); - } - } - - public final TypeProjectionContext typeProjection() throws RecognitionException { - TypeProjectionContext _localctx = new TypeProjectionContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_typeProjection); - try { - setState(2244); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case AT: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case IN: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(2240); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,332,_ctx) ) { - case 1: - { - setState(2239); - typeProjectionModifiers(); - } - break; - } - setState(2242); - type(); - } - break; - case MULT: - enterOuterAlt(_localctx, 2); - { - setState(2243); - match(MULT); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeProjectionModifiersContext extends ParserRuleContext { - public List typeProjectionModifier() { - return getRuleContexts(TypeProjectionModifierContext.class); - } - public TypeProjectionModifierContext typeProjectionModifier(int i) { - return getRuleContext(TypeProjectionModifierContext.class,i); - } - public TypeProjectionModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjectionModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeProjectionModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeProjectionModifiers(this); - } - } - - public final TypeProjectionModifiersContext typeProjectionModifiers() throws RecognitionException { - TypeProjectionModifiersContext _localctx = new TypeProjectionModifiersContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_typeProjectionModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2247); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(2246); - typeProjectionModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(2249); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,334,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeProjectionModifierContext extends ParserRuleContext { - public VarianceModifierContext varianceModifier() { - return getRuleContext(VarianceModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TypeProjectionModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjectionModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeProjectionModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeProjectionModifier(this); - } - } - - public final TypeProjectionModifierContext typeProjectionModifier() throws RecognitionException { - TypeProjectionModifierContext _localctx = new TypeProjectionModifierContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_typeProjectionModifier); - int _la; - try { - setState(2259); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IN: - case OUT: - enterOuterAlt(_localctx, 1); - { - setState(2251); - varianceModifier(); - setState(2255); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2252); - match(NL); - } - } - setState(2257); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 2); - { - setState(2258); - annotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ValueArgumentContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public ValueArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_valueArgument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterValueArgument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitValueArgument(this); - } - } - - public final ValueArgumentContext valueArgument() throws RecognitionException { - ValueArgumentContext _localctx = new ValueArgumentContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_valueArgument); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2262); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,337,_ctx) ) { - case 1: - { - setState(2261); - annotation(); - } - break; - } - setState(2267); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,338,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2264); - match(NL); - } - } - } - setState(2269); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,338,_ctx); - } - setState(2284); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,341,_ctx) ) { - case 1: - { - setState(2270); - simpleIdentifier(); - setState(2274); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2271); - match(NL); - } - } - setState(2276); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2277); - match(ASSIGNMENT); - setState(2281); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,340,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2278); - match(NL); - } - } - } - setState(2283); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,340,_ctx); - } - } - break; - } - setState(2287); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==MULT) { - { - setState(2286); - match(MULT); - } - } - - setState(2292); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,343,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2289); - match(NL); - } - } - } - setState(2294); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,343,_ctx); - } - setState(2295); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryExpressionContext extends ParserRuleContext { - public ParenthesizedExpressionContext parenthesizedExpression() { - return getRuleContext(ParenthesizedExpressionContext.class,0); - } - public LiteralConstantContext literalConstant() { - return getRuleContext(LiteralConstantContext.class,0); - } - public StringLiteralContext stringLiteral() { - return getRuleContext(StringLiteralContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public CallableReferenceContext callableReference() { - return getRuleContext(CallableReferenceContext.class,0); - } - public FunctionLiteralContext functionLiteral() { - return getRuleContext(FunctionLiteralContext.class,0); - } - public ObjectLiteralContext objectLiteral() { - return getRuleContext(ObjectLiteralContext.class,0); - } - public CollectionLiteralContext collectionLiteral() { - return getRuleContext(CollectionLiteralContext.class,0); - } - public ThisExpressionContext thisExpression() { - return getRuleContext(ThisExpressionContext.class,0); - } - public SuperExpressionContext superExpression() { - return getRuleContext(SuperExpressionContext.class,0); - } - public IfExpressionContext ifExpression() { - return getRuleContext(IfExpressionContext.class,0); - } - public WhenExpressionContext whenExpression() { - return getRuleContext(WhenExpressionContext.class,0); - } - public TryExpressionContext tryExpression() { - return getRuleContext(TryExpressionContext.class,0); - } - public JumpExpressionContext jumpExpression() { - return getRuleContext(JumpExpressionContext.class,0); - } - public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPrimaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPrimaryExpression(this); - } - } - - public final PrimaryExpressionContext primaryExpression() throws RecognitionException { - PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_primaryExpression); - try { - setState(2311); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,344,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2297); - parenthesizedExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2298); - literalConstant(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2299); - stringLiteral(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2300); - simpleIdentifier(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2301); - callableReference(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2302); - functionLiteral(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(2303); - objectLiteral(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(2304); - collectionLiteral(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(2305); - thisExpression(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(2306); - superExpression(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(2307); - ifExpression(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(2308); - whenExpression(); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(2309); - tryExpression(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(2310); - jumpExpression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedExpressionContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterParenthesizedExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitParenthesizedExpression(this); - } - } - - public final ParenthesizedExpressionContext parenthesizedExpression() throws RecognitionException { - ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_parenthesizedExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2313); - match(LPAREN); - setState(2317); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,345,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2314); - match(NL); - } - } - } - setState(2319); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,345,_ctx); - } - setState(2320); - expression(); - setState(2324); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2321); - match(NL); - } - } - setState(2326); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2327); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CollectionLiteralContext extends ParserRuleContext { - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public CollectionLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_collectionLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterCollectionLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitCollectionLiteral(this); - } - } - - public final CollectionLiteralContext collectionLiteral() throws RecognitionException { - CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_collectionLiteral); - int _la; - try { - int _alt; - setState(2372); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,353,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2329); - match(LSQUARE); - setState(2333); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,347,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2330); - match(NL); - } - } - } - setState(2335); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,347,_ctx); - } - setState(2336); - expression(); - setState(2353); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,350,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2340); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2337); - match(NL); - } - } - setState(2342); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2343); - match(COMMA); - setState(2347); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,349,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2344); - match(NL); - } - } - } - setState(2349); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,349,_ctx); - } - setState(2350); - expression(); - } - } - } - setState(2355); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,350,_ctx); - } - setState(2359); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2356); - match(NL); - } - } - setState(2361); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2362); - match(RSQUARE); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2364); - match(LSQUARE); - setState(2368); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2365); - match(NL); - } - } - setState(2370); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2371); - match(RSQUARE); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LiteralConstantContext extends ParserRuleContext { - public TerminalNode BooleanLiteral() { return getToken(KotlinParser.BooleanLiteral, 0); } - public TerminalNode IntegerLiteral() { return getToken(KotlinParser.IntegerLiteral, 0); } - public TerminalNode HexLiteral() { return getToken(KotlinParser.HexLiteral, 0); } - public TerminalNode BinLiteral() { return getToken(KotlinParser.BinLiteral, 0); } - public TerminalNode CharacterLiteral() { return getToken(KotlinParser.CharacterLiteral, 0); } - public TerminalNode RealLiteral() { return getToken(KotlinParser.RealLiteral, 0); } - public TerminalNode NullLiteral() { return getToken(KotlinParser.NullLiteral, 0); } - public TerminalNode LongLiteral() { return getToken(KotlinParser.LongLiteral, 0); } - public LiteralConstantContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_literalConstant; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLiteralConstant(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLiteralConstant(this); - } - } - - public final LiteralConstantContext literalConstant() throws RecognitionException { - LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_literalConstant); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2374); - _la = _input.LA(1); - if ( !(((((_la - 136)) & ~0x3f) == 0 && ((1L << (_la - 136)) & ((1L << (RealLiteral - 136)) | (1L << (LongLiteral - 136)) | (1L << (IntegerLiteral - 136)) | (1L << (HexLiteral - 136)) | (1L << (BinLiteral - 136)) | (1L << (BooleanLiteral - 136)) | (1L << (NullLiteral - 136)) | (1L << (CharacterLiteral - 136)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StringLiteralContext extends ParserRuleContext { - public LineStringLiteralContext lineStringLiteral() { - return getRuleContext(LineStringLiteralContext.class,0); - } - public MultiLineStringLiteralContext multiLineStringLiteral() { - return getRuleContext(MultiLineStringLiteralContext.class,0); - } - public StringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_stringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitStringLiteral(this); - } - } - - public final StringLiteralContext stringLiteral() throws RecognitionException { - StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_stringLiteral); - try { - setState(2378); - _errHandler.sync(this); - switch (_input.LA(1)) { - case QUOTE_OPEN: - enterOuterAlt(_localctx, 1); - { - setState(2376); - lineStringLiteral(); - } - break; - case TRIPLE_QUOTE_OPEN: - enterOuterAlt(_localctx, 2); - { - setState(2377); - multiLineStringLiteral(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LineStringLiteralContext extends ParserRuleContext { - public TerminalNode QUOTE_OPEN() { return getToken(KotlinParser.QUOTE_OPEN, 0); } - public TerminalNode QUOTE_CLOSE() { return getToken(KotlinParser.QUOTE_CLOSE, 0); } - public List lineStringContent() { - return getRuleContexts(LineStringContentContext.class); - } - public LineStringContentContext lineStringContent(int i) { - return getRuleContext(LineStringContentContext.class,i); - } - public List lineStringExpression() { - return getRuleContexts(LineStringExpressionContext.class); - } - public LineStringExpressionContext lineStringExpression(int i) { - return getRuleContext(LineStringExpressionContext.class,i); - } - public LineStringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLineStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLineStringLiteral(this); - } - } - - public final LineStringLiteralContext lineStringLiteral() throws RecognitionException { - LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_lineStringLiteral); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2380); - match(QUOTE_OPEN); - setState(2385); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 161)) & ~0x3f) == 0 && ((1L << (_la - 161)) & ((1L << (LineStrRef - 161)) | (1L << (LineStrText - 161)) | (1L << (LineStrEscapedChar - 161)) | (1L << (LineStrExprStart - 161)))) != 0)) { - { - setState(2383); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LineStrRef: - case LineStrText: - case LineStrEscapedChar: - { - setState(2381); - lineStringContent(); - } - break; - case LineStrExprStart: - { - setState(2382); - lineStringExpression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(2387); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2388); - match(QUOTE_CLOSE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiLineStringLiteralContext extends ParserRuleContext { - public TerminalNode TRIPLE_QUOTE_OPEN() { return getToken(KotlinParser.TRIPLE_QUOTE_OPEN, 0); } - public TerminalNode TRIPLE_QUOTE_CLOSE() { return getToken(KotlinParser.TRIPLE_QUOTE_CLOSE, 0); } - public List multiLineStringContent() { - return getRuleContexts(MultiLineStringContentContext.class); - } - public MultiLineStringContentContext multiLineStringContent(int i) { - return getRuleContext(MultiLineStringContentContext.class,i); - } - public List multiLineStringExpression() { - return getRuleContexts(MultiLineStringExpressionContext.class); - } - public MultiLineStringExpressionContext multiLineStringExpression(int i) { - return getRuleContext(MultiLineStringExpressionContext.class,i); - } - public List MultiLineStringQuote() { return getTokens(KotlinParser.MultiLineStringQuote); } - public TerminalNode MultiLineStringQuote(int i) { - return getToken(KotlinParser.MultiLineStringQuote, i); - } - public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiLineStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiLineStringLiteral(this); - } - } - - public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException { - MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_multiLineStringLiteral); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2390); - match(TRIPLE_QUOTE_OPEN); - setState(2396); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 166)) & ~0x3f) == 0 && ((1L << (_la - 166)) & ((1L << (MultiLineStringQuote - 166)) | (1L << (MultiLineStrRef - 166)) | (1L << (MultiLineStrText - 166)) | (1L << (MultiLineStrExprStart - 166)))) != 0)) { - { - setState(2394); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,357,_ctx) ) { - case 1: - { - setState(2391); - multiLineStringContent(); - } - break; - case 2: - { - setState(2392); - multiLineStringExpression(); - } - break; - case 3: - { - setState(2393); - match(MultiLineStringQuote); - } - break; - } - } - setState(2398); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2399); - match(TRIPLE_QUOTE_CLOSE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LineStringContentContext extends ParserRuleContext { - public TerminalNode LineStrText() { return getToken(KotlinParser.LineStrText, 0); } - public TerminalNode LineStrEscapedChar() { return getToken(KotlinParser.LineStrEscapedChar, 0); } - public TerminalNode LineStrRef() { return getToken(KotlinParser.LineStrRef, 0); } - public LineStringContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringContent; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLineStringContent(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLineStringContent(this); - } - } - - public final LineStringContentContext lineStringContent() throws RecognitionException { - LineStringContentContext _localctx = new LineStringContentContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_lineStringContent); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2401); - _la = _input.LA(1); - if ( !(((((_la - 161)) & ~0x3f) == 0 && ((1L << (_la - 161)) & ((1L << (LineStrRef - 161)) | (1L << (LineStrText - 161)) | (1L << (LineStrEscapedChar - 161)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LineStringExpressionContext extends ParserRuleContext { - public TerminalNode LineStrExprStart() { return getToken(KotlinParser.LineStrExprStart, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public LineStringExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLineStringExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLineStringExpression(this); - } - } - - public final LineStringExpressionContext lineStringExpression() throws RecognitionException { - LineStringExpressionContext _localctx = new LineStringExpressionContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_lineStringExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2403); - match(LineStrExprStart); - setState(2404); - expression(); - setState(2405); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiLineStringContentContext extends ParserRuleContext { - public TerminalNode MultiLineStrText() { return getToken(KotlinParser.MultiLineStrText, 0); } - public TerminalNode MultiLineStringQuote() { return getToken(KotlinParser.MultiLineStringQuote, 0); } - public TerminalNode MultiLineStrRef() { return getToken(KotlinParser.MultiLineStrRef, 0); } - public MultiLineStringContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringContent; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiLineStringContent(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiLineStringContent(this); - } - } - - public final MultiLineStringContentContext multiLineStringContent() throws RecognitionException { - MultiLineStringContentContext _localctx = new MultiLineStringContentContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_multiLineStringContent); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2407); - _la = _input.LA(1); - if ( !(((((_la - 166)) & ~0x3f) == 0 && ((1L << (_la - 166)) & ((1L << (MultiLineStringQuote - 166)) | (1L << (MultiLineStrRef - 166)) | (1L << (MultiLineStrText - 166)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiLineStringExpressionContext extends ParserRuleContext { - public TerminalNode MultiLineStrExprStart() { return getToken(KotlinParser.MultiLineStrExprStart, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiLineStringExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiLineStringExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiLineStringExpression(this); - } - } - - public final MultiLineStringExpressionContext multiLineStringExpression() throws RecognitionException { - MultiLineStringExpressionContext _localctx = new MultiLineStringExpressionContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_multiLineStringExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2409); - match(MultiLineStrExprStart); - setState(2413); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,359,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2410); - match(NL); - } - } - } - setState(2415); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,359,_ctx); - } - setState(2416); - expression(); - setState(2420); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2417); - match(NL); - } - } - setState(2422); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2423); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaLiteralContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public StatementsContext statements() { - return getRuleContext(StatementsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public LambdaParametersContext lambdaParameters() { - return getRuleContext(LambdaParametersContext.class,0); - } - public LambdaLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLambdaLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLambdaLiteral(this); - } - } - - public final LambdaLiteralContext lambdaLiteral() throws RecognitionException { - LambdaLiteralContext _localctx = new LambdaLiteralContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_lambdaLiteral); - int _la; - try { - int _alt; - setState(2473); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,368,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2425); - match(LCURL); - setState(2429); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,361,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2426); - match(NL); - } - } - } - setState(2431); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,361,_ctx); - } - setState(2432); - statements(); - setState(2436); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2433); - match(NL); - } - } - setState(2438); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2439); - match(RCURL); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2441); - match(LCURL); - setState(2445); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,363,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2442); - match(NL); - } - } - } - setState(2447); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,363,_ctx); - } - setState(2449); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,364,_ctx) ) { - case 1: - { - setState(2448); - lambdaParameters(); - } - break; - } - setState(2454); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2451); - match(NL); - } - } - setState(2456); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2457); - match(ARROW); - setState(2461); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,366,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2458); - match(NL); - } - } - } - setState(2463); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,366,_ctx); - } - setState(2464); - statements(); - setState(2468); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2465); - match(NL); - } - } - setState(2470); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2471); - match(RCURL); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaParametersContext extends ParserRuleContext { - public List lambdaParameter() { - return getRuleContexts(LambdaParameterContext.class); - } - public LambdaParameterContext lambdaParameter(int i) { - return getRuleContext(LambdaParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LambdaParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLambdaParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLambdaParameters(this); - } - } - - public final LambdaParametersContext lambdaParameters() throws RecognitionException { - LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_lambdaParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2475); - lambdaParameter(); - setState(2492); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,371,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2479); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2476); - match(NL); - } - } - setState(2481); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2482); - match(COMMA); - setState(2486); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,370,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2483); - match(NL); - } - } - } - setState(2488); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,370,_ctx); - } - setState(2489); - lambdaParameter(); - } - } - } - setState(2494); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,371,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaParameterContext extends ParserRuleContext { - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LambdaParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLambdaParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLambdaParameter(this); - } - } - - public final LambdaParameterContext lambdaParameter() throws RecognitionException { - LambdaParameterContext _localctx = new LambdaParameterContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_lambdaParameter); - int _la; - try { - setState(2513); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case AT: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(2495); - variableDeclaration(); - } - break; - case LPAREN: - enterOuterAlt(_localctx, 2); - { - setState(2496); - multiVariableDeclaration(); - setState(2511); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,374,_ctx) ) { - case 1: - { - setState(2500); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2497); - match(NL); - } - } - setState(2502); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2503); - match(COLON); - setState(2507); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2504); - match(NL); - } - } - setState(2509); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2510); - type(); - } - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnonymousFunctionContext extends ParserRuleContext { - public TerminalNode FUN() { return getToken(KotlinParser.FUN, 0); } - public FunctionValueParametersContext functionValueParameters() { - return getRuleContext(FunctionValueParametersContext.class,0); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public AnonymousFunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymousFunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnonymousFunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnonymousFunction(this); - } - } - - public final AnonymousFunctionContext anonymousFunction() throws RecognitionException { - AnonymousFunctionContext _localctx = new AnonymousFunctionContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_anonymousFunction); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2515); - match(FUN); - setState(2531); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,378,_ctx) ) { - case 1: - { - setState(2519); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2516); - match(NL); - } - } - setState(2521); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2522); - type(); - setState(2526); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2523); - match(NL); - } - } - setState(2528); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2529); - match(DOT); - } - break; - } - setState(2536); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2533); - match(NL); - } - } - setState(2538); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2539); - functionValueParameters(); - setState(2554); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,382,_ctx) ) { - case 1: - { - setState(2543); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2540); - match(NL); - } - } - setState(2545); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2546); - match(COLON); - setState(2550); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2547); - match(NL); - } - } - setState(2552); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2553); - type(); - } - break; - } - setState(2563); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,384,_ctx) ) { - case 1: - { - setState(2559); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2556); - match(NL); - } - } - setState(2561); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2562); - typeConstraints(); - } - break; - } - setState(2572); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,386,_ctx) ) { - case 1: - { - setState(2568); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2565); - match(NL); - } - } - setState(2570); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2571); - functionBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionLiteralContext extends ParserRuleContext { - public LambdaLiteralContext lambdaLiteral() { - return getRuleContext(LambdaLiteralContext.class,0); - } - public AnonymousFunctionContext anonymousFunction() { - return getRuleContext(AnonymousFunctionContext.class,0); - } - public FunctionLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionLiteral(this); - } - } - - public final FunctionLiteralContext functionLiteral() throws RecognitionException { - FunctionLiteralContext _localctx = new FunctionLiteralContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_functionLiteral); - try { - setState(2576); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LCURL: - enterOuterAlt(_localctx, 1); - { - setState(2574); - lambdaLiteral(); - } - break; - case FUN: - enterOuterAlt(_localctx, 2); - { - setState(2575); - anonymousFunction(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ObjectLiteralContext extends ParserRuleContext { - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public ObjectLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_objectLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterObjectLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitObjectLiteral(this); - } - } - - public final ObjectLiteralContext objectLiteral() throws RecognitionException { - ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_objectLiteral); - int _la; - try { - int _alt; - setState(2610); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2578); - match(OBJECT); - setState(2582); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2579); - match(NL); - } - } - setState(2584); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2585); - match(COLON); - setState(2589); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,389,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2586); - match(NL); - } - } - } - setState(2591); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,389,_ctx); - } - setState(2592); - delegationSpecifiers(); - setState(2600); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,391,_ctx) ) { - case 1: - { - setState(2596); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2593); - match(NL); - } - } - setState(2598); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2599); - classBody(); - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2602); - match(OBJECT); - setState(2606); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2603); - match(NL); - } - } - setState(2608); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2609); - classBody(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ThisExpressionContext extends ParserRuleContext { - public TerminalNode THIS() { return getToken(KotlinParser.THIS, 0); } - public TerminalNode THIS_AT() { return getToken(KotlinParser.THIS_AT, 0); } - public ThisExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_thisExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterThisExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitThisExpression(this); - } - } - - public final ThisExpressionContext thisExpression() throws RecognitionException { - ThisExpressionContext _localctx = new ThisExpressionContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_thisExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2612); - _la = _input.LA(1); - if ( !(_la==THIS_AT || _la==THIS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SuperExpressionContext extends ParserRuleContext { - public TerminalNode SUPER() { return getToken(KotlinParser.SUPER, 0); } - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public TerminalNode AT() { return getToken(KotlinParser.AT, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode SUPER_AT() { return getToken(KotlinParser.SUPER_AT, 0); } - public SuperExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_superExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSuperExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSuperExpression(this); - } - } - - public final SuperExpressionContext superExpression() throws RecognitionException { - SuperExpressionContext _localctx = new SuperExpressionContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_superExpression); - int _la; - try { - setState(2638); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SUPER: - enterOuterAlt(_localctx, 1); - { - setState(2614); - match(SUPER); - setState(2631); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,396,_ctx) ) { - case 1: - { - setState(2615); - match(LANGLE); - setState(2619); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2616); - match(NL); - } - } - setState(2621); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2622); - type(); - setState(2626); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2623); - match(NL); - } - } - setState(2628); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2629); - match(RANGLE); - } - break; - } - setState(2635); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,397,_ctx) ) { - case 1: - { - setState(2633); - match(AT); - setState(2634); - simpleIdentifier(); - } - break; - } - } - break; - case SUPER_AT: - enterOuterAlt(_localctx, 2); - { - setState(2637); - match(SUPER_AT); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ControlStructureBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public StatementContext statement() { - return getRuleContext(StatementContext.class,0); - } - public ControlStructureBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_controlStructureBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterControlStructureBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitControlStructureBody(this); - } - } - - public final ControlStructureBodyContext controlStructureBody() throws RecognitionException { - ControlStructureBodyContext _localctx = new ControlStructureBodyContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_controlStructureBody); - try { - setState(2642); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2640); - block(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2641); - statement(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IfExpressionContext extends ParserRuleContext { - public TerminalNode IF() { return getToken(KotlinParser.IF, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List controlStructureBody() { - return getRuleContexts(ControlStructureBodyContext.class); - } - public ControlStructureBodyContext controlStructureBody(int i) { - return getRuleContext(ControlStructureBodyContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode ELSE() { return getToken(KotlinParser.ELSE, 0); } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public IfExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_ifExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterIfExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitIfExpression(this); - } - } - - public final IfExpressionContext ifExpression() throws RecognitionException { - IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_ifExpression); - int _la; - try { - int _alt; - setState(2738); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2644); - match(IF); - setState(2648); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2645); - match(NL); - } - } - setState(2650); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2651); - match(LPAREN); - setState(2655); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,401,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2652); - match(NL); - } - } - } - setState(2657); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,401,_ctx); - } - setState(2658); - expression(); - setState(2662); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2659); - match(NL); - } - } - setState(2664); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2665); - match(RPAREN); - setState(2669); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,403,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2666); - match(NL); - } - } - } - setState(2671); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,403,_ctx); - } - setState(2672); - controlStructureBody(); - setState(2690); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,407,_ctx) ) { - case 1: - { - setState(2674); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2673); - match(SEMICOLON); - } - } - - setState(2679); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2676); - match(NL); - } - } - setState(2681); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2682); - match(ELSE); - setState(2686); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,406,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2683); - match(NL); - } - } - } - setState(2688); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,406,_ctx); - } - setState(2689); - controlStructureBody(); - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2692); - match(IF); - setState(2696); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2693); - match(NL); - } - } - setState(2698); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2699); - match(LPAREN); - setState(2703); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,409,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2700); - match(NL); - } - } - } - setState(2705); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,409,_ctx); - } - setState(2706); - expression(); - setState(2710); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2707); - match(NL); - } - } - setState(2712); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2713); - match(RPAREN); - setState(2717); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2714); - match(NL); - } - } - setState(2719); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2727); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2720); - match(SEMICOLON); - setState(2724); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2721); - match(NL); - } - } - setState(2726); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(2729); - match(ELSE); - setState(2733); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,414,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2730); - match(NL); - } - } - } - setState(2735); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,414,_ctx); - } - setState(2736); - controlStructureBody(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenExpressionContext extends ParserRuleContext { - public TerminalNode WHEN() { return getToken(KotlinParser.WHEN, 0); } - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List whenEntry() { - return getRuleContexts(WhenEntryContext.class); - } - public WhenEntryContext whenEntry(int i) { - return getRuleContext(WhenEntryContext.class,i); - } - public WhenExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterWhenExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitWhenExpression(this); - } - } - - public final WhenExpressionContext whenExpression() throws RecognitionException { - WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_whenExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2740); - match(WHEN); - setState(2744); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,416,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2741); - match(NL); - } - } - } - setState(2746); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,416,_ctx); - } - setState(2751); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(2747); - match(LPAREN); - setState(2748); - expression(); - setState(2749); - match(RPAREN); - } - } - - setState(2756); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2753); - match(NL); - } - } - setState(2758); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2759); - match(LCURL); - setState(2763); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,419,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2760); - match(NL); - } - } - } - setState(2765); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,419,_ctx); - } - setState(2775); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,421,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2766); - whenEntry(); - setState(2770); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,420,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2767); - match(NL); - } - } - } - setState(2772); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,420,_ctx); - } - } - } - } - setState(2777); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,421,_ctx); - } - setState(2781); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2778); - match(NL); - } - } - setState(2783); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2784); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenEntryContext extends ParserRuleContext { - public List whenCondition() { - return getRuleContexts(WhenConditionContext.class); - } - public WhenConditionContext whenCondition(int i) { - return getRuleContext(WhenConditionContext.class,i); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public TerminalNode ELSE() { return getToken(KotlinParser.ELSE, 0); } - public WhenEntryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenEntry; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterWhenEntry(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitWhenEntry(this); - } - } - - public final WhenEntryContext whenEntry() throws RecognitionException { - WhenEntryContext _localctx = new WhenEntryContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_whenEntry); - int _la; - try { - int _alt; - setState(2841); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case IMPORT: - case FUN: - case OBJECT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case IS: - case IN: - case NOT_IS: - case NOT_IN: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - case RealLiteral: - case LongLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case BooleanLiteral: - case NullLiteral: - case Identifier: - case IdentifierAt: - case CharacterLiteral: - enterOuterAlt(_localctx, 1); - { - setState(2786); - whenCondition(); - setState(2803); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,425,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2790); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2787); - match(NL); - } - } - setState(2792); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2793); - match(COMMA); - setState(2797); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,424,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2794); - match(NL); - } - } - } - setState(2799); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,424,_ctx); - } - setState(2800); - whenCondition(); - } - } - } - setState(2805); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,425,_ctx); - } - setState(2809); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2806); - match(NL); - } - } - setState(2811); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2812); - match(ARROW); - setState(2816); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,427,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2813); - match(NL); - } - } - } - setState(2818); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,427,_ctx); - } - setState(2819); - controlStructureBody(); - setState(2821); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) { - case 1: - { - setState(2820); - semi(); - } - break; - } - } - break; - case ELSE: - enterOuterAlt(_localctx, 2); - { - setState(2823); - match(ELSE); - setState(2827); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2824); - match(NL); - } - } - setState(2829); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2830); - match(ARROW); - setState(2834); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,430,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2831); - match(NL); - } - } - } - setState(2836); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,430,_ctx); - } - setState(2837); - controlStructureBody(); - setState(2839); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,431,_ctx) ) { - case 1: - { - setState(2838); - semi(); - } - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenConditionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public RangeTestContext rangeTest() { - return getRuleContext(RangeTestContext.class,0); - } - public TypeTestContext typeTest() { - return getRuleContext(TypeTestContext.class,0); - } - public WhenConditionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenCondition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterWhenCondition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitWhenCondition(this); - } - } - - public final WhenConditionContext whenCondition() throws RecognitionException { - WhenConditionContext _localctx = new WhenConditionContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_whenCondition); - try { - setState(2846); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case IMPORT: - case FUN: - case OBJECT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - case RealLiteral: - case LongLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case BooleanLiteral: - case NullLiteral: - case Identifier: - case IdentifierAt: - case CharacterLiteral: - enterOuterAlt(_localctx, 1); - { - setState(2843); - expression(); - } - break; - case IN: - case NOT_IN: - enterOuterAlt(_localctx, 2); - { - setState(2844); - rangeTest(); - } - break; - case IS: - case NOT_IS: - enterOuterAlt(_localctx, 3); - { - setState(2845); - typeTest(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class RangeTestContext extends ParserRuleContext { - public InOperatorContext inOperator() { - return getRuleContext(InOperatorContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public RangeTestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rangeTest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterRangeTest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitRangeTest(this); - } - } - - public final RangeTestContext rangeTest() throws RecognitionException { - RangeTestContext _localctx = new RangeTestContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_rangeTest); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2848); - inOperator(); - setState(2852); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,434,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2849); - match(NL); - } - } - } - setState(2854); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,434,_ctx); - } - setState(2855); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeTestContext extends ParserRuleContext { - public IsOperatorContext isOperator() { - return getRuleContext(IsOperatorContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeTestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeTest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTypeTest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTypeTest(this); - } - } - - public final TypeTestContext typeTest() throws RecognitionException { - TypeTestContext _localctx = new TypeTestContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_typeTest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2857); - isOperator(); - setState(2861); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2858); - match(NL); - } - } - setState(2863); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2864); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TryExpressionContext extends ParserRuleContext { - public TerminalNode TRY() { return getToken(KotlinParser.TRY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public FinallyBlockContext finallyBlock() { - return getRuleContext(FinallyBlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List catchBlock() { - return getRuleContexts(CatchBlockContext.class); - } - public CatchBlockContext catchBlock(int i) { - return getRuleContext(CatchBlockContext.class,i); - } - public TryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_tryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterTryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitTryExpression(this); - } - } - - public final TryExpressionContext tryExpression() throws RecognitionException { - TryExpressionContext _localctx = new TryExpressionContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_tryExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2866); - match(TRY); - setState(2870); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2867); - match(NL); - } - } - setState(2872); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2873); - block(); - setState(2901); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) { - case 1: - { - setState(2881); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(2877); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2874); - match(NL); - } - } - setState(2879); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2880); - catchBlock(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(2883); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,438,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - setState(2892); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,440,_ctx) ) { - case 1: - { - setState(2888); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2885); - match(NL); - } - } - setState(2890); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2891); - finallyBlock(); - } - break; - } - } - break; - case 2: - { - setState(2897); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2894); - match(NL); - } - } - setState(2899); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2900); - finallyBlock(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CatchBlockContext extends ParserRuleContext { - public TerminalNode CATCH() { return getToken(KotlinParser.CATCH, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public CatchBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_catchBlock; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterCatchBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitCatchBlock(this); - } - } - - public final CatchBlockContext catchBlock() throws RecognitionException { - CatchBlockContext _localctx = new CatchBlockContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_catchBlock); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2903); - match(CATCH); - setState(2907); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2904); - match(NL); - } - } - setState(2909); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2910); - match(LPAREN); - setState(2914); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT || ((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)))) != 0)) { - { - { - setState(2911); - annotation(); - } - } - setState(2916); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2917); - simpleIdentifier(); - setState(2918); - match(COLON); - setState(2919); - userType(); - setState(2920); - match(RPAREN); - setState(2924); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2921); - match(NL); - } - } - setState(2926); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2927); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FinallyBlockContext extends ParserRuleContext { - public TerminalNode FINALLY() { return getToken(KotlinParser.FINALLY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FinallyBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_finallyBlock; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFinallyBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFinallyBlock(this); - } - } - - public final FinallyBlockContext finallyBlock() throws RecognitionException { - FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_finallyBlock); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2929); - match(FINALLY); - setState(2933); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2930); - match(NL); - } - } - setState(2935); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2936); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LoopStatementContext extends ParserRuleContext { - public ForStatementContext forStatement() { - return getRuleContext(ForStatementContext.class,0); - } - public WhileStatementContext whileStatement() { - return getRuleContext(WhileStatementContext.class,0); - } - public DoWhileStatementContext doWhileStatement() { - return getRuleContext(DoWhileStatementContext.class,0); - } - public LoopStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_loopStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLoopStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLoopStatement(this); - } - } - - public final LoopStatementContext loopStatement() throws RecognitionException { - LoopStatementContext _localctx = new LoopStatementContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_loopStatement); - try { - setState(2941); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - enterOuterAlt(_localctx, 1); - { - setState(2938); - forStatement(); - } - break; - case WHILE: - enterOuterAlt(_localctx, 2); - { - setState(2939); - whileStatement(); - } - break; - case DO: - enterOuterAlt(_localctx, 3); - { - setState(2940); - doWhileStatement(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ForStatementContext extends ParserRuleContext { - public TerminalNode FOR() { return getToken(KotlinParser.FOR, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public ForStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_forStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterForStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitForStatement(this); - } - } - - public final ForStatementContext forStatement() throws RecognitionException { - ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_forStatement); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2943); - match(FOR); - setState(2947); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2944); - match(NL); - } - } - setState(2949); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2950); - match(LPAREN); - setState(2954); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,449,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2951); - annotation(); - } - } - } - setState(2956); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,449,_ctx); - } - setState(2959); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case AT: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(2957); - variableDeclaration(); - } - break; - case LPAREN: - { - setState(2958); - multiVariableDeclaration(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(2961); - match(IN); - setState(2962); - expression(); - setState(2963); - match(RPAREN); - setState(2967); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,451,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2964); - match(NL); - } - } - } - setState(2969); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,451,_ctx); - } - setState(2971); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,452,_ctx) ) { - case 1: - { - setState(2970); - controlStructureBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhileStatementContext extends ParserRuleContext { - public TerminalNode WHILE() { return getToken(KotlinParser.WHILE, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public WhileStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whileStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterWhileStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitWhileStatement(this); - } - } - - public final WhileStatementContext whileStatement() throws RecognitionException { - WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_whileStatement); - int _la; - try { - int _alt; - setState(3009); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,457,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2973); - match(WHILE); - setState(2977); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2974); - match(NL); - } - } - setState(2979); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2980); - match(LPAREN); - setState(2981); - expression(); - setState(2982); - match(RPAREN); - setState(2986); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,454,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2983); - match(NL); - } - } - } - setState(2988); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,454,_ctx); - } - setState(2989); - controlStructureBody(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2991); - match(WHILE); - setState(2995); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2992); - match(NL); - } - } - setState(2997); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2998); - match(LPAREN); - setState(2999); - expression(); - setState(3000); - match(RPAREN); - setState(3004); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3001); - match(NL); - } - } - setState(3006); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3007); - match(SEMICOLON); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DoWhileStatementContext extends ParserRuleContext { - public TerminalNode DO() { return getToken(KotlinParser.DO, 0); } - public TerminalNode WHILE() { return getToken(KotlinParser.WHILE, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_doWhileStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterDoWhileStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitDoWhileStatement(this); - } - } - - public final DoWhileStatementContext doWhileStatement() throws RecognitionException { - DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_doWhileStatement); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3011); - match(DO); - setState(3015); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,458,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3012); - match(NL); - } - } - } - setState(3017); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,458,_ctx); - } - setState(3019); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,459,_ctx) ) { - case 1: - { - setState(3018); - controlStructureBody(); - } - break; - } - setState(3024); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3021); - match(NL); - } - } - setState(3026); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3027); - match(WHILE); - setState(3031); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3028); - match(NL); - } - } - setState(3033); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3034); - match(LPAREN); - setState(3035); - expression(); - setState(3036); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class JumpExpressionContext extends ParserRuleContext { - public TerminalNode THROW() { return getToken(KotlinParser.THROW, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode RETURN() { return getToken(KotlinParser.RETURN, 0); } - public TerminalNode RETURN_AT() { return getToken(KotlinParser.RETURN_AT, 0); } - public TerminalNode CONTINUE() { return getToken(KotlinParser.CONTINUE, 0); } - public TerminalNode CONTINUE_AT() { return getToken(KotlinParser.CONTINUE_AT, 0); } - public TerminalNode BREAK() { return getToken(KotlinParser.BREAK, 0); } - public TerminalNode BREAK_AT() { return getToken(KotlinParser.BREAK_AT, 0); } - public JumpExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_jumpExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterJumpExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitJumpExpression(this); - } - } - - public final JumpExpressionContext jumpExpression() throws RecognitionException { - JumpExpressionContext _localctx = new JumpExpressionContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_jumpExpression); - int _la; - try { - int _alt; - setState(3054); - _errHandler.sync(this); - switch (_input.LA(1)) { - case THROW: - enterOuterAlt(_localctx, 1); - { - setState(3038); - match(THROW); - setState(3042); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,462,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3039); - match(NL); - } - } - } - setState(3044); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,462,_ctx); - } - setState(3045); - expression(); - } - break; - case RETURN_AT: - case RETURN: - enterOuterAlt(_localctx, 2); - { - setState(3046); - _la = _input.LA(1); - if ( !(_la==RETURN_AT || _la==RETURN) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3048); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,463,_ctx) ) { - case 1: - { - setState(3047); - expression(); - } - break; - } - } - break; - case CONTINUE: - enterOuterAlt(_localctx, 3); - { - setState(3050); - match(CONTINUE); - } - break; - case CONTINUE_AT: - enterOuterAlt(_localctx, 4); - { - setState(3051); - match(CONTINUE_AT); - } - break; - case BREAK: - enterOuterAlt(_localctx, 5); - { - setState(3052); - match(BREAK); - } - break; - case BREAK_AT: - enterOuterAlt(_localctx, 6); - { - setState(3053); - match(BREAK_AT); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CallableReferenceContext extends ParserRuleContext { - public TerminalNode COLONCOLON() { return getToken(KotlinParser.COLONCOLON, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public CallableReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_callableReference; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterCallableReference(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitCallableReference(this); - } - } - - public final CallableReferenceContext callableReference() throws RecognitionException { - CallableReferenceContext _localctx = new CallableReferenceContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_callableReference); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - { - setState(3057); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << AT) | (1L << IMPORT))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (CONSTRUCTOR - 68)) | (1L << (BY - 68)) | (1L << (COMPANION - 68)) | (1L << (INIT - 68)) | (1L << (WHERE - 68)) | (1L << (CATCH - 68)) | (1L << (FINALLY - 68)) | (1L << (OUT - 68)) | (1L << (GETTER - 68)) | (1L << (SETTER - 68)) | (1L << (DYNAMIC - 68)) | (1L << (AT_FIELD - 68)) | (1L << (AT_PROPERTY - 68)) | (1L << (AT_GET - 68)) | (1L << (AT_SET - 68)) | (1L << (AT_RECEIVER - 68)) | (1L << (AT_PARAM - 68)) | (1L << (AT_SETPARAM - 68)) | (1L << (AT_DELEGATE - 68)) | (1L << (PUBLIC - 68)) | (1L << (PRIVATE - 68)) | (1L << (PROTECTED - 68)) | (1L << (INTERNAL - 68)) | (1L << (ENUM - 68)) | (1L << (SEALED - 68)) | (1L << (ANNOTATION - 68)) | (1L << (DATA - 68)) | (1L << (INNER - 68)) | (1L << (TAILREC - 68)) | (1L << (OPERATOR - 68)) | (1L << (INLINE - 68)) | (1L << (INFIX - 68)) | (1L << (EXTERNAL - 68)) | (1L << (SUSPEND - 68)) | (1L << (OVERRIDE - 68)) | (1L << (ABSTRACT - 68)) | (1L << (FINAL - 68)) | (1L << (OPEN - 68)) | (1L << (CONST - 68)) | (1L << (LATEINIT - 68)) | (1L << (VARARG - 68)) | (1L << (NOINLINE - 68)) | (1L << (CROSSINLINE - 68)) | (1L << (REIFIED - 68)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (EXPECT - 132)) | (1L << (ACTUAL - 132)) | (1L << (Identifier - 132)))) != 0)) { - { - setState(3056); - receiverType(); - } - } - - setState(3062); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3059); - match(NL); - } - } - setState(3064); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3065); - match(COLONCOLON); - setState(3069); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3066); - match(NL); - } - } - setState(3071); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3074); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case GETTER: - case SETTER: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(3072); - simpleIdentifier(); - } - break; - case CLASS: - { - setState(3073); - match(CLASS); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentAndOperatorContext extends ParserRuleContext { - public TerminalNode ADD_ASSIGNMENT() { return getToken(KotlinParser.ADD_ASSIGNMENT, 0); } - public TerminalNode SUB_ASSIGNMENT() { return getToken(KotlinParser.SUB_ASSIGNMENT, 0); } - public TerminalNode MULT_ASSIGNMENT() { return getToken(KotlinParser.MULT_ASSIGNMENT, 0); } - public TerminalNode DIV_ASSIGNMENT() { return getToken(KotlinParser.DIV_ASSIGNMENT, 0); } - public TerminalNode MOD_ASSIGNMENT() { return getToken(KotlinParser.MOD_ASSIGNMENT, 0); } - public AssignmentAndOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignmentAndOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAssignmentAndOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAssignmentAndOperator(this); - } - } - - public final AssignmentAndOperatorContext assignmentAndOperator() throws RecognitionException { - AssignmentAndOperatorContext _localctx = new AssignmentAndOperatorContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_assignmentAndOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3076); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD_ASSIGNMENT) | (1L << SUB_ASSIGNMENT) | (1L << MULT_ASSIGNMENT) | (1L << DIV_ASSIGNMENT) | (1L << MOD_ASSIGNMENT))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EqualityOperatorContext extends ParserRuleContext { - public TerminalNode EXCL_EQ() { return getToken(KotlinParser.EXCL_EQ, 0); } - public TerminalNode EXCL_EQEQ() { return getToken(KotlinParser.EXCL_EQEQ, 0); } - public TerminalNode EQEQ() { return getToken(KotlinParser.EQEQ, 0); } - public TerminalNode EQEQEQ() { return getToken(KotlinParser.EQEQEQ, 0); } - public EqualityOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_equalityOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterEqualityOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitEqualityOperator(this); - } - } - - public final EqualityOperatorContext equalityOperator() throws RecognitionException { - EqualityOperatorContext _localctx = new EqualityOperatorContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_equalityOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3078); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXCL_EQ) | (1L << EXCL_EQEQ) | (1L << EQEQ) | (1L << EQEQEQ))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ComparisonOperatorContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public TerminalNode LE() { return getToken(KotlinParser.LE, 0); } - public TerminalNode GE() { return getToken(KotlinParser.GE, 0); } - public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_comparisonOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterComparisonOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitComparisonOperator(this); - } - } - - public final ComparisonOperatorContext comparisonOperator() throws RecognitionException { - ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_comparisonOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3080); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LANGLE) | (1L << RANGLE) | (1L << LE) | (1L << GE))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InOperatorContext extends ParserRuleContext { - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public TerminalNode NOT_IN() { return getToken(KotlinParser.NOT_IN, 0); } - public InOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_inOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterInOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitInOperator(this); - } - } - - public final InOperatorContext inOperator() throws RecognitionException { - InOperatorContext _localctx = new InOperatorContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_inOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3082); - _la = _input.LA(1); - if ( !(_la==IN || _la==NOT_IN) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IsOperatorContext extends ParserRuleContext { - public TerminalNode IS() { return getToken(KotlinParser.IS, 0); } - public TerminalNode NOT_IS() { return getToken(KotlinParser.NOT_IS, 0); } - public IsOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_isOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterIsOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitIsOperator(this); - } - } - - public final IsOperatorContext isOperator() throws RecognitionException { - IsOperatorContext _localctx = new IsOperatorContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_isOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3084); - _la = _input.LA(1); - if ( !(_la==IS || _la==NOT_IS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AdditiveOperatorContext extends ParserRuleContext { - public TerminalNode ADD() { return getToken(KotlinParser.ADD, 0); } - public TerminalNode SUB() { return getToken(KotlinParser.SUB, 0); } - public AdditiveOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_additiveOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAdditiveOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAdditiveOperator(this); - } - } - - public final AdditiveOperatorContext additiveOperator() throws RecognitionException { - AdditiveOperatorContext _localctx = new AdditiveOperatorContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_additiveOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3086); - _la = _input.LA(1); - if ( !(_la==ADD || _la==SUB) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiplicativeOperatorContext extends ParserRuleContext { - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public TerminalNode DIV() { return getToken(KotlinParser.DIV, 0); } - public TerminalNode MOD() { return getToken(KotlinParser.MOD, 0); } - public MultiplicativeOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiplicativeOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiplicativeOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiplicativeOperator(this); - } - } - - public final MultiplicativeOperatorContext multiplicativeOperator() throws RecognitionException { - MultiplicativeOperatorContext _localctx = new MultiplicativeOperatorContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_multiplicativeOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3088); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MULT) | (1L << MOD) | (1L << DIV))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AsOperatorContext extends ParserRuleContext { - public TerminalNode AS() { return getToken(KotlinParser.AS, 0); } - public TerminalNode AS_SAFE() { return getToken(KotlinParser.AS_SAFE, 0); } - public AsOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_asOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAsOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAsOperator(this); - } - } - - public final AsOperatorContext asOperator() throws RecognitionException { - AsOperatorContext _localctx = new AsOperatorContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_asOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3090); - _la = _input.LA(1); - if ( !(_la==AS_SAFE || _la==AS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrefixUnaryOperatorContext extends ParserRuleContext { - public TerminalNode INCR() { return getToken(KotlinParser.INCR, 0); } - public TerminalNode DECR() { return getToken(KotlinParser.DECR, 0); } - public TerminalNode SUB() { return getToken(KotlinParser.SUB, 0); } - public TerminalNode ADD() { return getToken(KotlinParser.ADD, 0); } - public ExclContext excl() { - return getRuleContext(ExclContext.class,0); - } - public PrefixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prefixUnaryOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPrefixUnaryOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPrefixUnaryOperator(this); - } - } - - public final PrefixUnaryOperatorContext prefixUnaryOperator() throws RecognitionException { - PrefixUnaryOperatorContext _localctx = new PrefixUnaryOperatorContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_prefixUnaryOperator); - try { - setState(3097); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INCR: - enterOuterAlt(_localctx, 1); - { - setState(3092); - match(INCR); - } - break; - case DECR: - enterOuterAlt(_localctx, 2); - { - setState(3093); - match(DECR); - } - break; - case SUB: - enterOuterAlt(_localctx, 3); - { - setState(3094); - match(SUB); - } - break; - case ADD: - enterOuterAlt(_localctx, 4); - { - setState(3095); - match(ADD); - } - break; - case EXCL_WS: - case EXCL_NO_WS: - enterOuterAlt(_localctx, 5); - { - setState(3096); - excl(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixUnaryOperatorContext extends ParserRuleContext { - public TerminalNode INCR() { return getToken(KotlinParser.INCR, 0); } - public TerminalNode DECR() { return getToken(KotlinParser.DECR, 0); } - public TerminalNode EXCL_NO_WS() { return getToken(KotlinParser.EXCL_NO_WS, 0); } - public ExclContext excl() { - return getRuleContext(ExclContext.class,0); - } - public PostfixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnaryOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPostfixUnaryOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPostfixUnaryOperator(this); - } - } - - public final PostfixUnaryOperatorContext postfixUnaryOperator() throws RecognitionException { - PostfixUnaryOperatorContext _localctx = new PostfixUnaryOperatorContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_postfixUnaryOperator); - try { - setState(3103); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INCR: - enterOuterAlt(_localctx, 1); - { - setState(3099); - match(INCR); - } - break; - case DECR: - enterOuterAlt(_localctx, 2); - { - setState(3100); - match(DECR); - } - break; - case EXCL_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(3101); - match(EXCL_NO_WS); - setState(3102); - excl(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MemberAccessOperatorContext extends ParserRuleContext { - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public SafeNavContext safeNav() { - return getRuleContext(SafeNavContext.class,0); - } - public TerminalNode COLONCOLON() { return getToken(KotlinParser.COLONCOLON, 0); } - public MemberAccessOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_memberAccessOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMemberAccessOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMemberAccessOperator(this); - } - } - - public final MemberAccessOperatorContext memberAccessOperator() throws RecognitionException { - MemberAccessOperatorContext _localctx = new MemberAccessOperatorContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_memberAccessOperator); - try { - setState(3108); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DOT: - enterOuterAlt(_localctx, 1); - { - setState(3105); - match(DOT); - } - break; - case QUEST_NO_WS: - enterOuterAlt(_localctx, 2); - { - setState(3106); - safeNav(); - } - break; - case COLONCOLON: - enterOuterAlt(_localctx, 3); - { - setState(3107); - match(COLONCOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ModifiersContext extends ParserRuleContext { - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List modifier() { - return getRuleContexts(ModifierContext.class); - } - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class,i); - } - public ModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_modifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitModifiers(this); - } - } - - public final ModifiersContext modifiers() throws RecognitionException { - ModifiersContext _localctx = new ModifiersContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_modifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3112); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - setState(3112); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT: - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - { - setState(3110); - annotation(); - } - break; - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case EXPECT: - case ACTUAL: - { - setState(3111); - modifier(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3114); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,473,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ModifierContext extends ParserRuleContext { - public ClassModifierContext classModifier() { - return getRuleContext(ClassModifierContext.class,0); - } - public MemberModifierContext memberModifier() { - return getRuleContext(MemberModifierContext.class,0); - } - public VisibilityModifierContext visibilityModifier() { - return getRuleContext(VisibilityModifierContext.class,0); - } - public FunctionModifierContext functionModifier() { - return getRuleContext(FunctionModifierContext.class,0); - } - public PropertyModifierContext propertyModifier() { - return getRuleContext(PropertyModifierContext.class,0); - } - public InheritanceModifierContext inheritanceModifier() { - return getRuleContext(InheritanceModifierContext.class,0); - } - public ParameterModifierContext parameterModifier() { - return getRuleContext(ParameterModifierContext.class,0); - } - public PlatformModifierContext platformModifier() { - return getRuleContext(PlatformModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitModifier(this); - } - } - - public final ModifierContext modifier() throws RecognitionException { - ModifierContext _localctx = new ModifierContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_modifier); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3124); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - { - setState(3116); - classModifier(); - } - break; - case OVERRIDE: - case LATEINIT: - { - setState(3117); - memberModifier(); - } - break; - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - { - setState(3118); - visibilityModifier(); - } - break; - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - { - setState(3119); - functionModifier(); - } - break; - case CONST: - { - setState(3120); - propertyModifier(); - } - break; - case ABSTRACT: - case FINAL: - case OPEN: - { - setState(3121); - inheritanceModifier(); - } - break; - case VARARG: - case NOINLINE: - case CROSSINLINE: - { - setState(3122); - parameterModifier(); - } - break; - case EXPECT: - case ACTUAL: - { - setState(3123); - platformModifier(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(3129); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,475,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3126); - match(NL); - } - } - } - setState(3131); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,475,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassModifierContext extends ParserRuleContext { - public TerminalNode ENUM() { return getToken(KotlinParser.ENUM, 0); } - public TerminalNode SEALED() { return getToken(KotlinParser.SEALED, 0); } - public TerminalNode ANNOTATION() { return getToken(KotlinParser.ANNOTATION, 0); } - public TerminalNode DATA() { return getToken(KotlinParser.DATA, 0); } - public TerminalNode INNER() { return getToken(KotlinParser.INNER, 0); } - public ClassModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterClassModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitClassModifier(this); - } - } - - public final ClassModifierContext classModifier() throws RecognitionException { - ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_classModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3132); - _la = _input.LA(1); - if ( !(((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (ENUM - 111)) | (1L << (SEALED - 111)) | (1L << (ANNOTATION - 111)) | (1L << (DATA - 111)) | (1L << (INNER - 111)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MemberModifierContext extends ParserRuleContext { - public TerminalNode OVERRIDE() { return getToken(KotlinParser.OVERRIDE, 0); } - public TerminalNode LATEINIT() { return getToken(KotlinParser.LATEINIT, 0); } - public MemberModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_memberModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMemberModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMemberModifier(this); - } - } - - public final MemberModifierContext memberModifier() throws RecognitionException { - MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_memberModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3134); - _la = _input.LA(1); - if ( !(_la==OVERRIDE || _la==LATEINIT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VisibilityModifierContext extends ParserRuleContext { - public TerminalNode PUBLIC() { return getToken(KotlinParser.PUBLIC, 0); } - public TerminalNode PRIVATE() { return getToken(KotlinParser.PRIVATE, 0); } - public TerminalNode INTERNAL() { return getToken(KotlinParser.INTERNAL, 0); } - public TerminalNode PROTECTED() { return getToken(KotlinParser.PROTECTED, 0); } - public VisibilityModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_visibilityModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterVisibilityModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitVisibilityModifier(this); - } - } - - public final VisibilityModifierContext visibilityModifier() throws RecognitionException { - VisibilityModifierContext _localctx = new VisibilityModifierContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_visibilityModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3136); - _la = _input.LA(1); - if ( !(((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VarianceModifierContext extends ParserRuleContext { - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public TerminalNode OUT() { return getToken(KotlinParser.OUT, 0); } - public VarianceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_varianceModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterVarianceModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitVarianceModifier(this); - } - } - - public final VarianceModifierContext varianceModifier() throws RecognitionException { - VarianceModifierContext _localctx = new VarianceModifierContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_varianceModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3138); - _la = _input.LA(1); - if ( !(_la==IN || _la==OUT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionModifierContext extends ParserRuleContext { - public TerminalNode TAILREC() { return getToken(KotlinParser.TAILREC, 0); } - public TerminalNode OPERATOR() { return getToken(KotlinParser.OPERATOR, 0); } - public TerminalNode INFIX() { return getToken(KotlinParser.INFIX, 0); } - public TerminalNode INLINE() { return getToken(KotlinParser.INLINE, 0); } - public TerminalNode EXTERNAL() { return getToken(KotlinParser.EXTERNAL, 0); } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public FunctionModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterFunctionModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitFunctionModifier(this); - } - } - - public final FunctionModifierContext functionModifier() throws RecognitionException { - FunctionModifierContext _localctx = new FunctionModifierContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_functionModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3140); - _la = _input.LA(1); - if ( !(((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (TAILREC - 116)) | (1L << (OPERATOR - 116)) | (1L << (INLINE - 116)) | (1L << (INFIX - 116)) | (1L << (EXTERNAL - 116)) | (1L << (SUSPEND - 116)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PropertyModifierContext extends ParserRuleContext { - public TerminalNode CONST() { return getToken(KotlinParser.CONST, 0); } - public PropertyModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPropertyModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPropertyModifier(this); - } - } - - public final PropertyModifierContext propertyModifier() throws RecognitionException { - PropertyModifierContext _localctx = new PropertyModifierContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_propertyModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(3142); - match(CONST); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InheritanceModifierContext extends ParserRuleContext { - public TerminalNode ABSTRACT() { return getToken(KotlinParser.ABSTRACT, 0); } - public TerminalNode FINAL() { return getToken(KotlinParser.FINAL, 0); } - public TerminalNode OPEN() { return getToken(KotlinParser.OPEN, 0); } - public InheritanceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_inheritanceModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterInheritanceModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitInheritanceModifier(this); - } - } - - public final InheritanceModifierContext inheritanceModifier() throws RecognitionException { - InheritanceModifierContext _localctx = new InheritanceModifierContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_inheritanceModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3144); - _la = _input.LA(1); - if ( !(((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & ((1L << (ABSTRACT - 123)) | (1L << (FINAL - 123)) | (1L << (OPEN - 123)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParameterModifierContext extends ParserRuleContext { - public TerminalNode VARARG() { return getToken(KotlinParser.VARARG, 0); } - public TerminalNode NOINLINE() { return getToken(KotlinParser.NOINLINE, 0); } - public TerminalNode CROSSINLINE() { return getToken(KotlinParser.CROSSINLINE, 0); } - public ParameterModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterParameterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitParameterModifier(this); - } - } - - public final ParameterModifierContext parameterModifier() throws RecognitionException { - ParameterModifierContext _localctx = new ParameterModifierContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_parameterModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3146); - _la = _input.LA(1); - if ( !(((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ReificationModifierContext extends ParserRuleContext { - public TerminalNode REIFIED() { return getToken(KotlinParser.REIFIED, 0); } - public ReificationModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_reificationModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterReificationModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitReificationModifier(this); - } - } - - public final ReificationModifierContext reificationModifier() throws RecognitionException { - ReificationModifierContext _localctx = new ReificationModifierContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_reificationModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(3148); - match(REIFIED); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PlatformModifierContext extends ParserRuleContext { - public TerminalNode EXPECT() { return getToken(KotlinParser.EXPECT, 0); } - public TerminalNode ACTUAL() { return getToken(KotlinParser.ACTUAL, 0); } - public PlatformModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_platformModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterPlatformModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitPlatformModifier(this); - } - } - - public final PlatformModifierContext platformModifier() throws RecognitionException { - PlatformModifierContext _localctx = new PlatformModifierContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_platformModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3150); - _la = _input.LA(1); - if ( !(_la==EXPECT || _la==ACTUAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LabelContext extends ParserRuleContext { - public TerminalNode IdentifierAt() { return getToken(KotlinParser.IdentifierAt, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LabelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_label; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterLabel(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitLabel(this); - } - } - - public final LabelContext label() throws RecognitionException { - LabelContext _localctx = new LabelContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_label); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3152); - match(IdentifierAt); - setState(3156); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,476,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3153); - match(NL); - } - } - } - setState(3158); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,476,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationContext extends ParserRuleContext { - public SingleAnnotationContext singleAnnotation() { - return getRuleContext(SingleAnnotationContext.class,0); - } - public MultiAnnotationContext multiAnnotation() { - return getRuleContext(MultiAnnotationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnnotation(this); - } - } - - public final AnnotationContext annotation() throws RecognitionException { - AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_annotation); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3161); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,477,_ctx) ) { - case 1: - { - setState(3159); - singleAnnotation(); - } - break; - case 2: - { - setState(3160); - multiAnnotation(); - } - break; - } - setState(3166); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,478,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3163); - match(NL); - } - } - } - setState(3168); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,478,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SingleAnnotationContext extends ParserRuleContext { - public AnnotationUseSiteTargetContext annotationUseSiteTarget() { - return getRuleContext(AnnotationUseSiteTargetContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public UnescapedAnnotationContext unescapedAnnotation() { - return getRuleContext(UnescapedAnnotationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode AT() { return getToken(KotlinParser.AT, 0); } - public SingleAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_singleAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSingleAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSingleAnnotation(this); - } - } - - public final SingleAnnotationContext singleAnnotation() throws RecognitionException { - SingleAnnotationContext _localctx = new SingleAnnotationContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_singleAnnotation); - int _la; - try { - setState(3187); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 1); - { - setState(3169); - annotationUseSiteTarget(); - setState(3173); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3170); - match(NL); - } - } - setState(3175); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3176); - match(COLON); - setState(3180); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3177); - match(NL); - } - } - setState(3182); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3183); - unescapedAnnotation(); - } - break; - case AT: - enterOuterAlt(_localctx, 2); - { - setState(3185); - match(AT); - setState(3186); - unescapedAnnotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiAnnotationContext extends ParserRuleContext { - public AnnotationUseSiteTargetContext annotationUseSiteTarget() { - return getRuleContext(AnnotationUseSiteTargetContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List unescapedAnnotation() { - return getRuleContexts(UnescapedAnnotationContext.class); - } - public UnescapedAnnotationContext unescapedAnnotation(int i) { - return getRuleContext(UnescapedAnnotationContext.class,i); - } - public TerminalNode AT() { return getToken(KotlinParser.AT, 0); } - public MultiAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterMultiAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitMultiAnnotation(this); - } - } - - public final MultiAnnotationContext multiAnnotation() throws RecognitionException { - MultiAnnotationContext _localctx = new MultiAnnotationContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_multiAnnotation); - int _la; - try { - setState(3220); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_FIELD: - case AT_PROPERTY: - case AT_GET: - case AT_SET: - case AT_RECEIVER: - case AT_PARAM: - case AT_SETPARAM: - case AT_DELEGATE: - enterOuterAlt(_localctx, 1); - { - setState(3189); - annotationUseSiteTarget(); - setState(3193); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3190); - match(NL); - } - } - setState(3195); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3196); - match(COLON); - setState(3200); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3197); - match(NL); - } - } - setState(3202); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3203); - match(LSQUARE); - setState(3205); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(3204); - unescapedAnnotation(); - } - } - setState(3207); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (IMPORT - 60)) | (1L << (CONSTRUCTOR - 60)) | (1L << (BY - 60)) | (1L << (COMPANION - 60)) | (1L << (INIT - 60)) | (1L << (WHERE - 60)) | (1L << (CATCH - 60)) | (1L << (FINALLY - 60)) | (1L << (OUT - 60)) | (1L << (GETTER - 60)) | (1L << (SETTER - 60)) | (1L << (DYNAMIC - 60)) | (1L << (PUBLIC - 60)) | (1L << (PRIVATE - 60)) | (1L << (PROTECTED - 60)) | (1L << (INTERNAL - 60)) | (1L << (ENUM - 60)) | (1L << (SEALED - 60)) | (1L << (ANNOTATION - 60)) | (1L << (DATA - 60)) | (1L << (INNER - 60)) | (1L << (TAILREC - 60)) | (1L << (OPERATOR - 60)) | (1L << (INLINE - 60)) | (1L << (INFIX - 60)) | (1L << (EXTERNAL - 60)) | (1L << (SUSPEND - 60)) | (1L << (OVERRIDE - 60)) | (1L << (ABSTRACT - 60)))) != 0) || ((((_la - 124)) & ~0x3f) == 0 && ((1L << (_la - 124)) & ((1L << (FINAL - 124)) | (1L << (OPEN - 124)) | (1L << (CONST - 124)) | (1L << (LATEINIT - 124)) | (1L << (VARARG - 124)) | (1L << (NOINLINE - 124)) | (1L << (CROSSINLINE - 124)) | (1L << (REIFIED - 124)) | (1L << (EXPECT - 124)) | (1L << (ACTUAL - 124)) | (1L << (Identifier - 124)))) != 0) ); - setState(3209); - match(RSQUARE); - } - break; - case AT: - enterOuterAlt(_localctx, 2); - { - setState(3211); - match(AT); - setState(3212); - match(LSQUARE); - setState(3214); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(3213); - unescapedAnnotation(); - } - } - setState(3216); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (IMPORT - 60)) | (1L << (CONSTRUCTOR - 60)) | (1L << (BY - 60)) | (1L << (COMPANION - 60)) | (1L << (INIT - 60)) | (1L << (WHERE - 60)) | (1L << (CATCH - 60)) | (1L << (FINALLY - 60)) | (1L << (OUT - 60)) | (1L << (GETTER - 60)) | (1L << (SETTER - 60)) | (1L << (DYNAMIC - 60)) | (1L << (PUBLIC - 60)) | (1L << (PRIVATE - 60)) | (1L << (PROTECTED - 60)) | (1L << (INTERNAL - 60)) | (1L << (ENUM - 60)) | (1L << (SEALED - 60)) | (1L << (ANNOTATION - 60)) | (1L << (DATA - 60)) | (1L << (INNER - 60)) | (1L << (TAILREC - 60)) | (1L << (OPERATOR - 60)) | (1L << (INLINE - 60)) | (1L << (INFIX - 60)) | (1L << (EXTERNAL - 60)) | (1L << (SUSPEND - 60)) | (1L << (OVERRIDE - 60)) | (1L << (ABSTRACT - 60)))) != 0) || ((((_la - 124)) & ~0x3f) == 0 && ((1L << (_la - 124)) & ((1L << (FINAL - 124)) | (1L << (OPEN - 124)) | (1L << (CONST - 124)) | (1L << (LATEINIT - 124)) | (1L << (VARARG - 124)) | (1L << (NOINLINE - 124)) | (1L << (CROSSINLINE - 124)) | (1L << (REIFIED - 124)) | (1L << (EXPECT - 124)) | (1L << (ACTUAL - 124)) | (1L << (Identifier - 124)))) != 0) ); - setState(3218); - match(RSQUARE); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationUseSiteTargetContext extends ParserRuleContext { - public TerminalNode AT_FIELD() { return getToken(KotlinParser.AT_FIELD, 0); } - public TerminalNode AT_PROPERTY() { return getToken(KotlinParser.AT_PROPERTY, 0); } - public TerminalNode AT_GET() { return getToken(KotlinParser.AT_GET, 0); } - public TerminalNode AT_SET() { return getToken(KotlinParser.AT_SET, 0); } - public TerminalNode AT_RECEIVER() { return getToken(KotlinParser.AT_RECEIVER, 0); } - public TerminalNode AT_PARAM() { return getToken(KotlinParser.AT_PARAM, 0); } - public TerminalNode AT_SETPARAM() { return getToken(KotlinParser.AT_SETPARAM, 0); } - public TerminalNode AT_DELEGATE() { return getToken(KotlinParser.AT_DELEGATE, 0); } - public AnnotationUseSiteTargetContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotationUseSiteTarget; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterAnnotationUseSiteTarget(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitAnnotationUseSiteTarget(this); - } - } - - public final AnnotationUseSiteTargetContext annotationUseSiteTarget() throws RecognitionException { - AnnotationUseSiteTargetContext _localctx = new AnnotationUseSiteTargetContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_annotationUseSiteTarget); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3222); - _la = _input.LA(1); - if ( !(((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (AT_FIELD - 99)) | (1L << (AT_PROPERTY - 99)) | (1L << (AT_GET - 99)) | (1L << (AT_SET - 99)) | (1L << (AT_RECEIVER - 99)) | (1L << (AT_PARAM - 99)) | (1L << (AT_SETPARAM - 99)) | (1L << (AT_DELEGATE - 99)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class UnescapedAnnotationContext extends ParserRuleContext { - public ConstructorInvocationContext constructorInvocation() { - return getRuleContext(ConstructorInvocationContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public UnescapedAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unescapedAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterUnescapedAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitUnescapedAnnotation(this); - } - } - - public final UnescapedAnnotationContext unescapedAnnotation() throws RecognitionException { - UnescapedAnnotationContext _localctx = new UnescapedAnnotationContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_unescapedAnnotation); - try { - setState(3226); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,487,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(3224); - constructorInvocation(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(3225); - userType(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SimpleIdentifierContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(KotlinParser.Identifier, 0); } - public TerminalNode ABSTRACT() { return getToken(KotlinParser.ABSTRACT, 0); } - public TerminalNode ANNOTATION() { return getToken(KotlinParser.ANNOTATION, 0); } - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public TerminalNode CATCH() { return getToken(KotlinParser.CATCH, 0); } - public TerminalNode COMPANION() { return getToken(KotlinParser.COMPANION, 0); } - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public TerminalNode CROSSINLINE() { return getToken(KotlinParser.CROSSINLINE, 0); } - public TerminalNode DATA() { return getToken(KotlinParser.DATA, 0); } - public TerminalNode DYNAMIC() { return getToken(KotlinParser.DYNAMIC, 0); } - public TerminalNode ENUM() { return getToken(KotlinParser.ENUM, 0); } - public TerminalNode EXTERNAL() { return getToken(KotlinParser.EXTERNAL, 0); } - public TerminalNode FINAL() { return getToken(KotlinParser.FINAL, 0); } - public TerminalNode FINALLY() { return getToken(KotlinParser.FINALLY, 0); } - public TerminalNode GETTER() { return getToken(KotlinParser.GETTER, 0); } - public TerminalNode IMPORT() { return getToken(KotlinParser.IMPORT, 0); } - public TerminalNode INFIX() { return getToken(KotlinParser.INFIX, 0); } - public TerminalNode INIT() { return getToken(KotlinParser.INIT, 0); } - public TerminalNode INLINE() { return getToken(KotlinParser.INLINE, 0); } - public TerminalNode INNER() { return getToken(KotlinParser.INNER, 0); } - public TerminalNode INTERNAL() { return getToken(KotlinParser.INTERNAL, 0); } - public TerminalNode LATEINIT() { return getToken(KotlinParser.LATEINIT, 0); } - public TerminalNode NOINLINE() { return getToken(KotlinParser.NOINLINE, 0); } - public TerminalNode OPEN() { return getToken(KotlinParser.OPEN, 0); } - public TerminalNode OPERATOR() { return getToken(KotlinParser.OPERATOR, 0); } - public TerminalNode OUT() { return getToken(KotlinParser.OUT, 0); } - public TerminalNode OVERRIDE() { return getToken(KotlinParser.OVERRIDE, 0); } - public TerminalNode PRIVATE() { return getToken(KotlinParser.PRIVATE, 0); } - public TerminalNode PROTECTED() { return getToken(KotlinParser.PROTECTED, 0); } - public TerminalNode PUBLIC() { return getToken(KotlinParser.PUBLIC, 0); } - public TerminalNode REIFIED() { return getToken(KotlinParser.REIFIED, 0); } - public TerminalNode SEALED() { return getToken(KotlinParser.SEALED, 0); } - public TerminalNode TAILREC() { return getToken(KotlinParser.TAILREC, 0); } - public TerminalNode SETTER() { return getToken(KotlinParser.SETTER, 0); } - public TerminalNode VARARG() { return getToken(KotlinParser.VARARG, 0); } - public TerminalNode WHERE() { return getToken(KotlinParser.WHERE, 0); } - public TerminalNode EXPECT() { return getToken(KotlinParser.EXPECT, 0); } - public TerminalNode ACTUAL() { return getToken(KotlinParser.ACTUAL, 0); } - public TerminalNode CONST() { return getToken(KotlinParser.CONST, 0); } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public SimpleIdentifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simpleIdentifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSimpleIdentifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSimpleIdentifier(this); - } - } - - public final SimpleIdentifierContext simpleIdentifier() throws RecognitionException { - SimpleIdentifierContext _localctx = new SimpleIdentifierContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_simpleIdentifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3228); - _la = _input.LA(1); - if ( !(((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (IMPORT - 60)) | (1L << (CONSTRUCTOR - 60)) | (1L << (BY - 60)) | (1L << (COMPANION - 60)) | (1L << (INIT - 60)) | (1L << (WHERE - 60)) | (1L << (CATCH - 60)) | (1L << (FINALLY - 60)) | (1L << (OUT - 60)) | (1L << (GETTER - 60)) | (1L << (SETTER - 60)) | (1L << (DYNAMIC - 60)) | (1L << (PUBLIC - 60)) | (1L << (PRIVATE - 60)) | (1L << (PROTECTED - 60)) | (1L << (INTERNAL - 60)) | (1L << (ENUM - 60)) | (1L << (SEALED - 60)) | (1L << (ANNOTATION - 60)) | (1L << (DATA - 60)) | (1L << (INNER - 60)) | (1L << (TAILREC - 60)) | (1L << (OPERATOR - 60)) | (1L << (INLINE - 60)) | (1L << (INFIX - 60)) | (1L << (EXTERNAL - 60)) | (1L << (SUSPEND - 60)) | (1L << (OVERRIDE - 60)) | (1L << (ABSTRACT - 60)))) != 0) || ((((_la - 124)) & ~0x3f) == 0 && ((1L << (_la - 124)) & ((1L << (FINAL - 124)) | (1L << (OPEN - 124)) | (1L << (CONST - 124)) | (1L << (LATEINIT - 124)) | (1L << (VARARG - 124)) | (1L << (NOINLINE - 124)) | (1L << (CROSSINLINE - 124)) | (1L << (REIFIED - 124)) | (1L << (EXPECT - 124)) | (1L << (ACTUAL - 124)) | (1L << (Identifier - 124)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class IdentifierContext extends ParserRuleContext { - public List simpleIdentifier() { - return getRuleContexts(SimpleIdentifierContext.class); - } - public SimpleIdentifierContext simpleIdentifier(int i) { - return getRuleContext(SimpleIdentifierContext.class,i); - } - public List DOT() { return getTokens(KotlinParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(KotlinParser.DOT, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public IdentifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_identifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterIdentifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitIdentifier(this); - } - } - - public final IdentifierContext identifier() throws RecognitionException { - IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_identifier); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3230); - simpleIdentifier(); - setState(3241); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,489,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3234); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3231); - match(NL); - } - } - setState(3236); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3237); - match(DOT); - setState(3238); - simpleIdentifier(); - } - } - } - setState(3243); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,489,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ShebangLineContext extends ParserRuleContext { - public TerminalNode ShebangLine() { return getToken(KotlinParser.ShebangLine, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ShebangLineContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_shebangLine; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterShebangLine(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitShebangLine(this); - } - } - - public final ShebangLineContext shebangLine() throws RecognitionException { - ShebangLineContext _localctx = new ShebangLineContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_shebangLine); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3244); - match(ShebangLine); - setState(3246); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3245); - match(NL); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3248); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,490,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class QuestContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode QUEST_WS() { return getToken(KotlinParser.QUEST_WS, 0); } - public QuestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_quest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterQuest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitQuest(this); - } - } - - public final QuestContext quest() throws RecognitionException { - QuestContext _localctx = new QuestContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_quest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3250); - _la = _input.LA(1); - if ( !(_la==QUEST_WS || _la==QUEST_NO_WS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElvisContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public ElvisContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_elvis; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterElvis(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitElvis(this); - } - } - - public final ElvisContext elvis() throws RecognitionException { - ElvisContext _localctx = new ElvisContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_elvis); - try { - enterOuterAlt(_localctx, 1); - { - setState(3252); - match(QUEST_NO_WS); - setState(3253); - match(COLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SafeNavContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public SafeNavContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_safeNav; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSafeNav(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSafeNav(this); - } - } - - public final SafeNavContext safeNav() throws RecognitionException { - SafeNavContext _localctx = new SafeNavContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_safeNav); - try { - enterOuterAlt(_localctx, 1); - { - setState(3255); - match(QUEST_NO_WS); - setState(3256); - match(DOT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExclContext extends ParserRuleContext { - public TerminalNode EXCL_NO_WS() { return getToken(KotlinParser.EXCL_NO_WS, 0); } - public TerminalNode EXCL_WS() { return getToken(KotlinParser.EXCL_WS, 0); } - public ExclContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_excl; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterExcl(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitExcl(this); - } - } - - public final ExclContext excl() throws RecognitionException { - ExclContext _localctx = new ExclContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_excl); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3258); - _la = _input.LA(1); - if ( !(_la==EXCL_WS || _la==EXCL_NO_WS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SemiContext extends ParserRuleContext { - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public SemiContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_semi; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSemi(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSemi(this); - } - } - - public final SemiContext semi() throws RecognitionException { - SemiContext _localctx = new SemiContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_semi); - int _la; - try { - int _alt; - setState(3268); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case SEMICOLON: - enterOuterAlt(_localctx, 1); - { - setState(3260); - _la = _input.LA(1); - if ( !(_la==NL || _la==SEMICOLON) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3264); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,491,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3261); - match(NL); - } - } - } - setState(3266); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,491,_ctx); - } - } - break; - case EOF: - enterOuterAlt(_localctx, 2); - { - setState(3267); - match(EOF); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SemisContext extends ParserRuleContext { - public List SEMICOLON() { return getTokens(KotlinParser.SEMICOLON); } - public TerminalNode SEMICOLON(int i) { - return getToken(KotlinParser.SEMICOLON, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public SemisContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_semis; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).enterSemis(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener) ((KotlinParserListener)listener).exitSemis(this); - } - } - - public final SemisContext semis() throws RecognitionException { - SemisContext _localctx = new SemisContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_semis); - int _la; - try { - int _alt; - setState(3276); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case SEMICOLON: - enterOuterAlt(_localctx, 1); - { - setState(3271); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3270); - _la = _input.LA(1); - if ( !(_la==NL || _la==SEMICOLON) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3273); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,493,_ctx); - } while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ); - } - break; - case EOF: - enterOuterAlt(_localctx, 2); - { - setState(3275); - match(EOF); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00ab\u0cd1\4\2\t"+ - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ - "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ - "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ - "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\3\2\5\2\u0150\n\2\3\2"+ - "\7\2\u0153\n\2\f\2\16\2\u0156\13\2\3\2\7\2\u0159\n\2\f\2\16\2\u015c\13"+ - "\2\3\2\3\2\3\2\7\2\u0161\n\2\f\2\16\2\u0164\13\2\3\2\3\2\3\3\5\3\u0169"+ - "\n\3\3\3\7\3\u016c\n\3\f\3\16\3\u016f\13\3\3\3\7\3\u0172\n\3\f\3\16\3"+ - "\u0175\13\3\3\3\3\3\3\3\3\3\3\3\7\3\u017c\n\3\f\3\16\3\u017f\13\3\3\3"+ - "\3\3\3\4\3\4\7\4\u0185\n\4\f\4\16\4\u0188\13\4\3\4\3\4\7\4\u018c\n\4\f"+ - "\4\16\4\u018f\13\4\3\4\3\4\6\4\u0193\n\4\r\4\16\4\u0194\3\4\3\4\3\4\5"+ - "\4\u019a\n\4\3\4\7\4\u019d\n\4\f\4\16\4\u01a0\13\4\3\5\3\5\3\5\5\5\u01a5"+ - "\n\5\5\5\u01a7\n\5\3\6\7\6\u01aa\n\6\f\6\16\6\u01ad\13\6\3\7\3\7\3\7\3"+ - "\7\3\7\5\7\u01b4\n\7\3\7\5\7\u01b7\n\7\3\b\3\b\3\b\3\t\3\t\5\t\u01be\n"+ - "\t\3\n\5\n\u01c1\n\n\3\n\3\n\7\n\u01c5\n\n\f\n\16\n\u01c8\13\n\3\n\3\n"+ - "\7\n\u01cc\n\n\f\n\16\n\u01cf\13\n\3\n\5\n\u01d2\n\n\3\n\7\n\u01d5\n\n"+ - "\f\n\16\n\u01d8\13\n\3\n\5\n\u01db\n\n\3\n\7\n\u01de\n\n\f\n\16\n\u01e1"+ - "\13\n\3\n\3\n\7\n\u01e5\n\n\f\n\16\n\u01e8\13\n\3\n\5\n\u01eb\n\n\3\n"+ - "\7\n\u01ee\n\n\f\n\16\n\u01f1\13\n\3\n\5\n\u01f4\n\n\3\n\7\n\u01f7\n\n"+ - "\f\n\16\n\u01fa\13\n\3\n\3\n\7\n\u01fe\n\n\f\n\16\n\u0201\13\n\3\n\5\n"+ - "\u0204\n\n\3\13\5\13\u0207\n\13\3\13\3\13\7\13\u020b\n\13\f\13\16\13\u020e"+ - "\13\13\5\13\u0210\n\13\3\13\3\13\3\f\3\f\7\f\u0216\n\f\f\f\16\f\u0219"+ - "\13\f\3\f\3\f\7\f\u021d\n\f\f\f\16\f\u0220\13\f\3\f\3\f\7\f\u0224\n\f"+ - "\f\f\16\f\u0227\13\f\3\f\7\f\u022a\n\f\f\f\16\f\u022d\13\f\5\f\u022f\n"+ - "\f\3\f\7\f\u0232\n\f\f\f\16\f\u0235\13\f\3\f\3\f\3\r\5\r\u023a\n\r\3\r"+ - "\5\r\u023d\n\r\3\r\7\r\u0240\n\r\f\r\16\r\u0243\13\r\3\r\3\r\3\r\7\r\u0248"+ - "\n\r\f\r\16\r\u024b\13\r\3\r\3\r\7\r\u024f\n\r\f\r\16\r\u0252\13\r\3\r"+ - "\3\r\7\r\u0256\n\r\f\r\16\r\u0259\13\r\3\r\5\r\u025c\n\r\3\16\3\16\7\16"+ - "\u0260\n\16\f\16\16\16\u0263\13\16\3\16\3\16\7\16\u0267\n\16\f\16\16\16"+ - "\u026a\13\16\3\16\7\16\u026d\n\16\f\16\16\16\u0270\13\16\3\17\7\17\u0273"+ - "\n\17\f\17\16\17\u0276\13\17\3\17\7\17\u0279\n\17\f\17\16\17\u027c\13"+ - "\17\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u0284\n\20\3\21\3\21\3\21\3\22"+ - "\3\22\5\22\u028b\n\22\3\22\7\22\u028e\n\22\f\22\16\22\u0291\13\22\3\22"+ - "\3\22\7\22\u0295\n\22\f\22\16\22\u0298\13\22\3\22\3\22\3\23\3\23\7\23"+ - "\u029e\n\23\f\23\16\23\u02a1\13\23\3\23\3\23\7\23\u02a5\n\23\f\23\16\23"+ - "\u02a8\13\23\3\23\3\23\3\24\3\24\5\24\u02ae\n\24\7\24\u02b0\n\24\f\24"+ - "\16\24\u02b3\13\24\3\25\3\25\3\25\3\25\5\25\u02b9\n\25\3\26\3\26\7\26"+ - "\u02bd\n\26\f\26\16\26\u02c0\13\26\3\26\3\26\3\27\5\27\u02c5\n\27\3\27"+ - "\3\27\7\27\u02c9\n\27\f\27\16\27\u02cc\13\27\3\27\3\27\7\27\u02d0\n\27"+ - "\f\27\16\27\u02d3\13\27\3\27\3\27\7\27\u02d7\n\27\f\27\16\27\u02da\13"+ - "\27\3\27\5\27\u02dd\n\27\3\27\7\27\u02e0\n\27\f\27\16\27\u02e3\13\27\3"+ - "\27\5\27\u02e6\n\27\3\30\3\30\7\30\u02ea\n\30\f\30\16\30\u02ed\13\30\3"+ - "\30\3\30\3\30\7\30\u02f2\n\30\f\30\16\30\u02f5\13\30\3\30\5\30\u02f8\n"+ - "\30\3\31\3\31\7\31\u02fc\n\31\f\31\16\31\u02ff\13\31\3\31\5\31\u0302\n"+ - "\31\3\31\7\31\u0305\n\31\f\31\16\31\u0308\13\31\3\31\3\31\7\31\u030c\n"+ - "\31\f\31\16\31\u030f\13\31\3\31\5\31\u0312\n\31\3\31\7\31\u0315\n\31\f"+ - "\31\16\31\u0318\13\31\3\31\3\31\3\32\3\32\7\32\u031e\n\32\f\32\16\32\u0321"+ - "\13\32\3\32\3\32\7\32\u0325\n\32\f\32\16\32\u0328\13\32\3\32\7\32\u032b"+ - "\n\32\f\32\16\32\u032e\13\32\3\32\7\32\u0331\n\32\f\32\16\32\u0334\13"+ - "\32\3\32\5\32\u0337\n\32\3\33\3\33\7\33\u033b\n\33\f\33\16\33\u033e\13"+ - "\33\5\33\u0340\n\33\3\33\3\33\7\33\u0344\n\33\f\33\16\33\u0347\13\33\3"+ - "\33\5\33\u034a\n\33\3\33\7\33\u034d\n\33\f\33\16\33\u0350\13\33\3\33\5"+ - "\33\u0353\n\33\3\34\5\34\u0356\n\34\3\34\3\34\7\34\u035a\n\34\f\34\16"+ - "\34\u035d\13\34\3\34\5\34\u0360\n\34\3\34\7\34\u0363\n\34\f\34\16\34\u0366"+ - "\13\34\3\34\3\34\7\34\u036a\n\34\f\34\16\34\u036d\13\34\3\34\3\34\5\34"+ - "\u0371\n\34\3\34\7\34\u0374\n\34\f\34\16\34\u0377\13\34\3\34\3\34\7\34"+ - "\u037b\n\34\f\34\16\34\u037e\13\34\3\34\3\34\7\34\u0382\n\34\f\34\16\34"+ - "\u0385\13\34\3\34\3\34\7\34\u0389\n\34\f\34\16\34\u038c\13\34\3\34\5\34"+ - "\u038f\n\34\3\34\7\34\u0392\n\34\f\34\16\34\u0395\13\34\3\34\5\34\u0398"+ - "\n\34\3\34\7\34\u039b\n\34\f\34\16\34\u039e\13\34\3\34\5\34\u03a1\n\34"+ - "\3\35\3\35\7\35\u03a5\n\35\f\35\16\35\u03a8\13\35\3\35\3\35\7\35\u03ac"+ - "\n\35\f\35\16\35\u03af\13\35\3\35\3\35\7\35\u03b3\n\35\f\35\16\35\u03b6"+ - "\13\35\3\35\7\35\u03b9\n\35\f\35\16\35\u03bc\13\35\5\35\u03be\n\35\3\35"+ - "\7\35\u03c1\n\35\f\35\16\35\u03c4\13\35\3\35\3\35\3\36\5\36\u03c9\n\36"+ - "\3\36\3\36\7\36\u03cd\n\36\f\36\16\36\u03d0\13\36\3\36\3\36\7\36\u03d4"+ - "\n\36\f\36\16\36\u03d7\13\36\3\36\5\36\u03da\n\36\3\37\3\37\7\37\u03de"+ - "\n\37\f\37\16\37\u03e1\13\37\3\37\3\37\7\37\u03e5\n\37\f\37\16\37\u03e8"+ - "\13\37\3\37\3\37\3 \3 \7 \u03ee\n \f \16 \u03f1\13 \3 \3 \7 \u03f5\n "+ - "\f \16 \u03f8\13 \3 \5 \u03fb\n \3!\3!\3!\7!\u0400\n!\f!\16!\u0403\13"+ - "!\3!\5!\u0406\n!\3\"\5\"\u0409\n\"\3\"\3\"\7\"\u040d\n\"\f\"\16\"\u0410"+ - "\13\"\3\"\3\"\7\"\u0414\n\"\f\"\16\"\u0417\13\"\3\"\3\"\7\"\u041b\n\""+ - "\f\"\16\"\u041e\13\"\3\"\5\"\u0421\n\"\3\"\7\"\u0424\n\"\f\"\16\"\u0427"+ - "\13\"\3\"\5\"\u042a\n\"\3#\5#\u042d\n#\3#\3#\7#\u0431\n#\f#\16#\u0434"+ - "\13#\3#\3#\7#\u0438\n#\f#\16#\u043b\13#\3#\5#\u043e\n#\3#\7#\u0441\n#"+ - "\f#\16#\u0444\13#\3#\3#\7#\u0448\n#\f#\16#\u044b\13#\3#\5#\u044e\n#\3"+ - "#\7#\u0451\n#\f#\16#\u0454\13#\3#\5#\u0457\n#\3$\5$\u045a\n$\3$\3$\7$"+ - "\u045e\n$\f$\16$\u0461\13$\3$\5$\u0464\n$\3$\7$\u0467\n$\f$\16$\u046a"+ - "\13$\3$\3$\7$\u046e\n$\f$\16$\u0471\13$\3$\3$\5$\u0475\n$\3$\7$\u0478"+ - "\n$\f$\16$\u047b\13$\3$\3$\5$\u047f\n$\3$\7$\u0482\n$\f$\16$\u0485\13"+ - "$\3$\5$\u0488\n$\3$\7$\u048b\n$\f$\16$\u048e\13$\3$\3$\7$\u0492\n$\f$"+ - "\16$\u0495\13$\3$\3$\5$\u0499\n$\5$\u049b\n$\3$\6$\u049e\n$\r$\16$\u049f"+ - "\3$\5$\u04a3\n$\3$\7$\u04a6\n$\f$\16$\u04a9\13$\3$\5$\u04ac\n$\3$\7$\u04af"+ - "\n$\f$\16$\u04b2\13$\3$\5$\u04b5\n$\3$\5$\u04b8\n$\3$\5$\u04bb\n$\3$\7"+ - "$\u04be\n$\f$\16$\u04c1\13$\3$\5$\u04c4\n$\3$\5$\u04c7\n$\5$\u04c9\n$"+ - "\3%\3%\7%\u04cd\n%\f%\16%\u04d0\13%\3%\3%\7%\u04d4\n%\f%\16%\u04d7\13"+ - "%\3%\3%\7%\u04db\n%\f%\16%\u04de\13%\3%\7%\u04e1\n%\f%\16%\u04e4\13%\3"+ - "%\7%\u04e7\n%\f%\16%\u04ea\13%\3%\3%\3&\7&\u04ef\n&\f&\16&\u04f2\13&\3"+ - "&\7&\u04f5\n&\f&\16&\u04f8\13&\3&\3&\7&\u04fc\n&\f&\16&\u04ff\13&\3&\3"+ - "&\7&\u0503\n&\f&\16&\u0506\13&\3&\5&\u0509\n&\3\'\3\'\7\'\u050d\n\'\f"+ - "\'\16\'\u0510\13\'\3\'\3\'\3(\5(\u0515\n(\3(\3(\5(\u0519\n(\3(\3(\7(\u051d"+ - "\n(\f(\16(\u0520\13(\3(\3(\7(\u0524\n(\f(\16(\u0527\13(\3(\3(\7(\u052b"+ - "\n(\f(\16(\u052e\13(\3(\3(\7(\u0532\n(\f(\16(\u0535\13(\3(\5(\u0538\n"+ - "(\3(\7(\u053b\n(\f(\16(\u053e\13(\3(\5(\u0541\n(\3)\5)\u0544\n)\3)\3)"+ - "\5)\u0548\n)\3)\3)\7)\u054c\n)\f)\16)\u054f\13)\3)\3)\3)\7)\u0554\n)\f"+ - ")\16)\u0557\13)\3)\3)\3)\7)\u055c\n)\f)\16)\u055f\13)\3)\3)\7)\u0563\n"+ - ")\f)\16)\u0566\13)\3)\5)\u0569\n)\3)\7)\u056c\n)\f)\16)\u056f\13)\3)\3"+ - ")\5)\u0573\n)\3*\5*\u0576\n*\3*\3*\7*\u057a\n*\f*\16*\u057d\13*\3*\3*"+ - "\7*\u0581\n*\f*\16*\u0584\13*\3*\5*\u0587\n*\3*\7*\u058a\n*\f*\16*\u058d"+ - "\13*\3*\3*\7*\u0591\n*\f*\16*\u0594\13*\3*\3*\3+\3+\7+\u059a\n+\f+\16"+ - "+\u059d\13+\3+\3+\7+\u05a1\n+\f+\16+\u05a4\13+\3+\3+\7+\u05a8\n+\f+\16"+ - "+\u05ab\13+\3+\7+\u05ae\n+\f+\16+\u05b1\13+\3+\7+\u05b4\n+\f+\16+\u05b7"+ - "\13+\3+\3+\3,\5,\u05bc\n,\3,\7,\u05bf\n,\f,\16,\u05c2\13,\3,\3,\7,\u05c6"+ - "\n,\f,\16,\u05c9\13,\3,\3,\7,\u05cd\n,\f,\16,\u05d0\13,\3,\5,\u05d3\n"+ - ",\3-\6-\u05d6\n-\r-\16-\u05d7\3.\3.\7.\u05dc\n.\f.\16.\u05df\13.\3.\3"+ - ".\7.\u05e3\n.\f.\16.\u05e6\13.\3.\5.\u05e9\n.\3/\5/\u05ec\n/\3/\3/\3/"+ - "\3/\5/\u05f2\n/\3\60\6\60\u05f5\n\60\r\60\16\60\u05f6\3\61\3\61\3\61\7"+ - "\61\u05fc\n\61\f\61\16\61\u05ff\13\61\5\61\u0601\n\61\3\62\3\62\7\62\u0605"+ - "\n\62\f\62\16\62\u0608\13\62\3\62\3\62\7\62\u060c\n\62\f\62\16\62\u060f"+ - "\13\62\3\62\3\62\3\63\3\63\5\63\u0615\n\63\3\63\7\63\u0618\n\63\f\63\16"+ - "\63\u061b\13\63\3\63\6\63\u061e\n\63\r\63\16\63\u061f\3\64\3\64\5\64\u0624"+ - "\n\64\3\65\3\65\7\65\u0628\n\65\f\65\16\65\u062b\13\65\3\65\3\65\7\65"+ - "\u062f\n\65\f\65\16\65\u0632\13\65\5\65\u0634\n\65\3\65\3\65\7\65\u0638"+ - "\n\65\f\65\16\65\u063b\13\65\3\65\3\65\7\65\u063f\n\65\f\65\16\65\u0642"+ - "\13\65\3\65\3\65\3\66\5\66\u0647\n\66\3\66\3\66\3\66\5\66\u064c\n\66\3"+ - "\67\3\67\7\67\u0650\n\67\f\67\16\67\u0653\13\67\3\67\3\67\7\67\u0657\n"+ - "\67\f\67\16\67\u065a\13\67\3\67\7\67\u065d\n\67\f\67\16\67\u0660\13\67"+ - "\38\38\78\u0664\n8\f8\168\u0667\138\38\38\78\u066b\n8\f8\168\u066e\13"+ - "8\38\38\38\38\78\u0674\n8\f8\168\u0677\138\38\38\78\u067b\n8\f8\168\u067e"+ - "\138\38\38\58\u0682\n8\39\39\79\u0686\n9\f9\169\u0689\139\39\59\u068c"+ - "\n9\3:\3:\7:\u0690\n:\f:\16:\u0693\13:\3:\3:\5:\u0697\n:\3:\7:\u069a\n"+ - ":\f:\16:\u069d\13:\3:\3:\7:\u06a1\n:\f:\16:\u06a4\13:\3:\3:\5:\u06a8\n"+ - ":\7:\u06aa\n:\f:\16:\u06ad\13:\3:\7:\u06b0\n:\f:\16:\u06b3\13:\3:\3:\3"+ - ";\3;\7;\u06b9\n;\f;\16;\u06bc\13;\3;\3;\7;\u06c0\n;\f;\16;\u06c3\13;\3"+ - ";\3;\7;\u06c7\n;\f;\16;\u06ca\13;\3;\7;\u06cd\n;\f;\16;\u06d0\13;\3<\7"+ - "<\u06d3\n<\f<\16<\u06d6\13<\3<\3<\7<\u06da\n<\f<\16<\u06dd\13<\3<\3<\7"+ - "<\u06e1\n<\f<\16<\u06e4\13<\3<\3<\3=\3=\7=\u06ea\n=\f=\16=\u06ed\13=\3"+ - "=\3=\7=\u06f1\n=\f=\16=\u06f4\13=\3=\3=\3>\3>\3>\3>\7>\u06fc\n>\f>\16"+ - ">\u06ff\13>\3>\5>\u0702\n>\5>\u0704\n>\3?\3?\7?\u0708\n?\f?\16?\u070b"+ - "\13?\3?\3?\3?\3?\5?\u0711\n?\3@\3@\3@\3@\3@\5@\u0718\n@\3A\3A\3A\7A\u071d"+ - "\nA\fA\16A\u0720\13A\3A\3A\3A\3A\3A\7A\u0727\nA\fA\16A\u072a\13A\3A\3"+ - "A\5A\u072e\nA\3B\3B\3C\3C\7C\u0734\nC\fC\16C\u0737\13C\3C\3C\7C\u073b"+ - "\nC\fC\16C\u073e\13C\3C\7C\u0741\nC\fC\16C\u0744\13C\3D\3D\7D\u0748\n"+ - "D\fD\16D\u074b\13D\3D\3D\7D\u074f\nD\fD\16D\u0752\13D\3D\7D\u0755\nD\f"+ - "D\16D\u0758\13D\3E\3E\3E\7E\u075d\nE\fE\16E\u0760\13E\3E\3E\7E\u0764\n"+ - "E\fE\16E\u0767\13E\3F\3F\3F\7F\u076c\nF\fF\16F\u076f\13F\3F\3F\5F\u0773"+ - "\nF\3G\3G\3G\7G\u0778\nG\fG\16G\u077b\13G\3G\3G\3G\3G\7G\u0781\nG\fG\16"+ - "G\u0784\13G\3G\3G\7G\u0788\nG\fG\16G\u078b\13G\3H\3H\7H\u078f\nH\fH\16"+ - "H\u0792\13H\3H\3H\7H\u0796\nH\fH\16H\u0799\13H\3H\3H\7H\u079d\nH\fH\16"+ - "H\u07a0\13H\3I\3I\3I\7I\u07a5\nI\fI\16I\u07a8\13I\3I\3I\7I\u07ac\nI\f"+ - "I\16I\u07af\13I\3J\3J\3J\7J\u07b4\nJ\fJ\16J\u07b7\13J\3J\7J\u07ba\nJ\f"+ - "J\16J\u07bd\13J\3K\3K\3K\7K\u07c2\nK\fK\16K\u07c5\13K\3K\3K\7K\u07c9\n"+ - "K\fK\16K\u07cc\13K\3L\3L\3L\7L\u07d1\nL\fL\16L\u07d4\13L\3L\3L\7L\u07d8"+ - "\nL\fL\16L\u07db\13L\3M\3M\7M\u07df\nM\fM\16M\u07e2\13M\3M\3M\7M\u07e6"+ - "\nM\fM\16M\u07e9\13M\3M\3M\5M\u07ed\nM\3N\7N\u07f0\nN\fN\16N\u07f3\13"+ - "N\3N\3N\3O\3O\3O\3O\7O\u07fb\nO\fO\16O\u07fe\13O\5O\u0800\nO\3P\3P\3P"+ - "\6P\u0805\nP\rP\16P\u0806\5P\u0809\nP\3Q\3Q\3Q\3Q\3Q\5Q\u0810\nQ\3R\3"+ - "R\3R\3R\5R\u0816\nR\3S\3S\3T\3T\3T\5T\u081d\nT\3U\3U\7U\u0821\nU\fU\16"+ - "U\u0824\13U\3U\3U\7U\u0828\nU\fU\16U\u082b\13U\3U\3U\7U\u082f\nU\fU\16"+ - "U\u0832\13U\3U\7U\u0835\nU\fU\16U\u0838\13U\3U\7U\u083b\nU\fU\16U\u083e"+ - "\13U\3U\3U\3V\7V\u0843\nV\fV\16V\u0846\13V\3V\3V\7V\u084a\nV\fV\16V\u084d"+ - "\13V\3V\3V\3V\5V\u0852\nV\3W\5W\u0855\nW\3W\5W\u0858\nW\3W\3W\5W\u085c"+ - "\nW\3W\5W\u085f\nW\3X\7X\u0862\nX\fX\16X\u0865\13X\3X\5X\u0868\nX\3X\7"+ - "X\u086b\nX\fX\16X\u086e\13X\3X\3X\3Y\3Y\7Y\u0874\nY\fY\16Y\u0877\13Y\3"+ - "Y\3Y\3Y\7Y\u087c\nY\fY\16Y\u087f\13Y\3Y\3Y\7Y\u0883\nY\fY\16Y\u0886\13"+ - "Y\3Y\3Y\7Y\u088a\nY\fY\16Y\u088d\13Y\3Y\7Y\u0890\nY\fY\16Y\u0893\13Y\3"+ - "Y\7Y\u0896\nY\fY\16Y\u0899\13Y\3Y\3Y\5Y\u089d\nY\3Z\3Z\7Z\u08a1\nZ\fZ"+ - "\16Z\u08a4\13Z\3Z\3Z\7Z\u08a8\nZ\fZ\16Z\u08ab\13Z\3Z\3Z\7Z\u08af\nZ\f"+ - "Z\16Z\u08b2\13Z\3Z\7Z\u08b5\nZ\fZ\16Z\u08b8\13Z\3Z\7Z\u08bb\nZ\fZ\16Z"+ - "\u08be\13Z\3Z\3Z\3[\5[\u08c3\n[\3[\3[\5[\u08c7\n[\3\\\6\\\u08ca\n\\\r"+ - "\\\16\\\u08cb\3]\3]\7]\u08d0\n]\f]\16]\u08d3\13]\3]\5]\u08d6\n]\3^\5^"+ - "\u08d9\n^\3^\7^\u08dc\n^\f^\16^\u08df\13^\3^\3^\7^\u08e3\n^\f^\16^\u08e6"+ - "\13^\3^\3^\7^\u08ea\n^\f^\16^\u08ed\13^\5^\u08ef\n^\3^\5^\u08f2\n^\3^"+ - "\7^\u08f5\n^\f^\16^\u08f8\13^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3"+ - "_\3_\3_\5_\u090a\n_\3`\3`\7`\u090e\n`\f`\16`\u0911\13`\3`\3`\7`\u0915"+ - "\n`\f`\16`\u0918\13`\3`\3`\3a\3a\7a\u091e\na\fa\16a\u0921\13a\3a\3a\7"+ - "a\u0925\na\fa\16a\u0928\13a\3a\3a\7a\u092c\na\fa\16a\u092f\13a\3a\7a\u0932"+ - "\na\fa\16a\u0935\13a\3a\7a\u0938\na\fa\16a\u093b\13a\3a\3a\3a\3a\7a\u0941"+ - "\na\fa\16a\u0944\13a\3a\5a\u0947\na\3b\3b\3c\3c\5c\u094d\nc\3d\3d\3d\7"+ - "d\u0952\nd\fd\16d\u0955\13d\3d\3d\3e\3e\3e\3e\7e\u095d\ne\fe\16e\u0960"+ - "\13e\3e\3e\3f\3f\3g\3g\3g\3g\3h\3h\3i\3i\7i\u096e\ni\fi\16i\u0971\13i"+ - "\3i\3i\7i\u0975\ni\fi\16i\u0978\13i\3i\3i\3j\3j\7j\u097e\nj\fj\16j\u0981"+ - "\13j\3j\3j\7j\u0985\nj\fj\16j\u0988\13j\3j\3j\3j\3j\7j\u098e\nj\fj\16"+ - "j\u0991\13j\3j\5j\u0994\nj\3j\7j\u0997\nj\fj\16j\u099a\13j\3j\3j\7j\u099e"+ - "\nj\fj\16j\u09a1\13j\3j\3j\7j\u09a5\nj\fj\16j\u09a8\13j\3j\3j\5j\u09ac"+ - "\nj\3k\3k\7k\u09b0\nk\fk\16k\u09b3\13k\3k\3k\7k\u09b7\nk\fk\16k\u09ba"+ - "\13k\3k\7k\u09bd\nk\fk\16k\u09c0\13k\3l\3l\3l\7l\u09c5\nl\fl\16l\u09c8"+ - "\13l\3l\3l\7l\u09cc\nl\fl\16l\u09cf\13l\3l\5l\u09d2\nl\5l\u09d4\nl\3m"+ - "\3m\7m\u09d8\nm\fm\16m\u09db\13m\3m\3m\7m\u09df\nm\fm\16m\u09e2\13m\3"+ - "m\3m\5m\u09e6\nm\3m\7m\u09e9\nm\fm\16m\u09ec\13m\3m\3m\7m\u09f0\nm\fm"+ - "\16m\u09f3\13m\3m\3m\7m\u09f7\nm\fm\16m\u09fa\13m\3m\5m\u09fd\nm\3m\7"+ - "m\u0a00\nm\fm\16m\u0a03\13m\3m\5m\u0a06\nm\3m\7m\u0a09\nm\fm\16m\u0a0c"+ - "\13m\3m\5m\u0a0f\nm\3n\3n\5n\u0a13\nn\3o\3o\7o\u0a17\no\fo\16o\u0a1a\13"+ - "o\3o\3o\7o\u0a1e\no\fo\16o\u0a21\13o\3o\3o\7o\u0a25\no\fo\16o\u0a28\13"+ - "o\3o\5o\u0a2b\no\3o\3o\7o\u0a2f\no\fo\16o\u0a32\13o\3o\5o\u0a35\no\3p"+ - "\3p\3q\3q\3q\7q\u0a3c\nq\fq\16q\u0a3f\13q\3q\3q\7q\u0a43\nq\fq\16q\u0a46"+ - "\13q\3q\3q\5q\u0a4a\nq\3q\3q\5q\u0a4e\nq\3q\5q\u0a51\nq\3r\3r\5r\u0a55"+ - "\nr\3s\3s\7s\u0a59\ns\fs\16s\u0a5c\13s\3s\3s\7s\u0a60\ns\fs\16s\u0a63"+ - "\13s\3s\3s\7s\u0a67\ns\fs\16s\u0a6a\13s\3s\3s\7s\u0a6e\ns\fs\16s\u0a71"+ - "\13s\3s\3s\5s\u0a75\ns\3s\7s\u0a78\ns\fs\16s\u0a7b\13s\3s\3s\7s\u0a7f"+ - "\ns\fs\16s\u0a82\13s\3s\5s\u0a85\ns\3s\3s\7s\u0a89\ns\fs\16s\u0a8c\13"+ - "s\3s\3s\7s\u0a90\ns\fs\16s\u0a93\13s\3s\3s\7s\u0a97\ns\fs\16s\u0a9a\13"+ - "s\3s\3s\7s\u0a9e\ns\fs\16s\u0aa1\13s\3s\3s\7s\u0aa5\ns\fs\16s\u0aa8\13"+ - "s\5s\u0aaa\ns\3s\3s\7s\u0aae\ns\fs\16s\u0ab1\13s\3s\3s\5s\u0ab5\ns\3t"+ - "\3t\7t\u0ab9\nt\ft\16t\u0abc\13t\3t\3t\3t\3t\5t\u0ac2\nt\3t\7t\u0ac5\n"+ - "t\ft\16t\u0ac8\13t\3t\3t\7t\u0acc\nt\ft\16t\u0acf\13t\3t\3t\7t\u0ad3\n"+ - "t\ft\16t\u0ad6\13t\7t\u0ad8\nt\ft\16t\u0adb\13t\3t\7t\u0ade\nt\ft\16t"+ - "\u0ae1\13t\3t\3t\3u\3u\7u\u0ae7\nu\fu\16u\u0aea\13u\3u\3u\7u\u0aee\nu"+ - "\fu\16u\u0af1\13u\3u\7u\u0af4\nu\fu\16u\u0af7\13u\3u\7u\u0afa\nu\fu\16"+ - "u\u0afd\13u\3u\3u\7u\u0b01\nu\fu\16u\u0b04\13u\3u\3u\5u\u0b08\nu\3u\3"+ - "u\7u\u0b0c\nu\fu\16u\u0b0f\13u\3u\3u\7u\u0b13\nu\fu\16u\u0b16\13u\3u\3"+ - "u\5u\u0b1a\nu\5u\u0b1c\nu\3v\3v\3v\5v\u0b21\nv\3w\3w\7w\u0b25\nw\fw\16"+ - "w\u0b28\13w\3w\3w\3x\3x\7x\u0b2e\nx\fx\16x\u0b31\13x\3x\3x\3y\3y\7y\u0b37"+ - "\ny\fy\16y\u0b3a\13y\3y\3y\7y\u0b3e\ny\fy\16y\u0b41\13y\3y\6y\u0b44\n"+ - "y\ry\16y\u0b45\3y\7y\u0b49\ny\fy\16y\u0b4c\13y\3y\5y\u0b4f\ny\3y\7y\u0b52"+ - "\ny\fy\16y\u0b55\13y\3y\5y\u0b58\ny\3z\3z\7z\u0b5c\nz\fz\16z\u0b5f\13"+ - "z\3z\3z\7z\u0b63\nz\fz\16z\u0b66\13z\3z\3z\3z\3z\3z\7z\u0b6d\nz\fz\16"+ - "z\u0b70\13z\3z\3z\3{\3{\7{\u0b76\n{\f{\16{\u0b79\13{\3{\3{\3|\3|\3|\5"+ - "|\u0b80\n|\3}\3}\7}\u0b84\n}\f}\16}\u0b87\13}\3}\3}\7}\u0b8b\n}\f}\16"+ - "}\u0b8e\13}\3}\3}\5}\u0b92\n}\3}\3}\3}\3}\7}\u0b98\n}\f}\16}\u0b9b\13"+ - "}\3}\5}\u0b9e\n}\3~\3~\7~\u0ba2\n~\f~\16~\u0ba5\13~\3~\3~\3~\3~\7~\u0bab"+ - "\n~\f~\16~\u0bae\13~\3~\3~\3~\3~\7~\u0bb4\n~\f~\16~\u0bb7\13~\3~\3~\3"+ - "~\3~\7~\u0bbd\n~\f~\16~\u0bc0\13~\3~\3~\5~\u0bc4\n~\3\177\3\177\7\177"+ - "\u0bc8\n\177\f\177\16\177\u0bcb\13\177\3\177\5\177\u0bce\n\177\3\177\7"+ - "\177\u0bd1\n\177\f\177\16\177\u0bd4\13\177\3\177\3\177\7\177\u0bd8\n\177"+ - "\f\177\16\177\u0bdb\13\177\3\177\3\177\3\177\3\177\3\u0080\3\u0080\7\u0080"+ - "\u0be3\n\u0080\f\u0080\16\u0080\u0be6\13\u0080\3\u0080\3\u0080\3\u0080"+ - "\5\u0080\u0beb\n\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u0bf1\n"+ - "\u0080\3\u0081\5\u0081\u0bf4\n\u0081\3\u0081\7\u0081\u0bf7\n\u0081\f\u0081"+ - "\16\u0081\u0bfa\13\u0081\3\u0081\3\u0081\7\u0081\u0bfe\n\u0081\f\u0081"+ - "\16\u0081\u0c01\13\u0081\3\u0081\3\u0081\5\u0081\u0c05\n\u0081\3\u0082"+ - "\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086\3\u0086"+ - "\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a"+ - "\3\u008a\3\u008a\5\u008a\u0c1c\n\u008a\3\u008b\3\u008b\3\u008b\3\u008b"+ - "\5\u008b\u0c22\n\u008b\3\u008c\3\u008c\3\u008c\5\u008c\u0c27\n\u008c\3"+ - "\u008d\3\u008d\6\u008d\u0c2b\n\u008d\r\u008d\16\u008d\u0c2c\3\u008e\3"+ - "\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u0c37\n"+ - "\u008e\3\u008e\7\u008e\u0c3a\n\u008e\f\u008e\16\u008e\u0c3d\13\u008e\3"+ - "\u008f\3\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093"+ - "\3\u0093\3\u0094\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\3\u0097\3\u0097"+ - "\3\u0098\3\u0098\3\u0099\3\u0099\7\u0099\u0c55\n\u0099\f\u0099\16\u0099"+ - "\u0c58\13\u0099\3\u009a\3\u009a\5\u009a\u0c5c\n\u009a\3\u009a\7\u009a"+ - "\u0c5f\n\u009a\f\u009a\16\u009a\u0c62\13\u009a\3\u009b\3\u009b\7\u009b"+ - "\u0c66\n\u009b\f\u009b\16\u009b\u0c69\13\u009b\3\u009b\3\u009b\7\u009b"+ - "\u0c6d\n\u009b\f\u009b\16\u009b\u0c70\13\u009b\3\u009b\3\u009b\3\u009b"+ - "\3\u009b\5\u009b\u0c76\n\u009b\3\u009c\3\u009c\7\u009c\u0c7a\n\u009c\f"+ - "\u009c\16\u009c\u0c7d\13\u009c\3\u009c\3\u009c\7\u009c\u0c81\n\u009c\f"+ - "\u009c\16\u009c\u0c84\13\u009c\3\u009c\3\u009c\6\u009c\u0c88\n\u009c\r"+ - "\u009c\16\u009c\u0c89\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\6\u009c"+ - "\u0c91\n\u009c\r\u009c\16\u009c\u0c92\3\u009c\3\u009c\5\u009c\u0c97\n"+ - "\u009c\3\u009d\3\u009d\3\u009e\3\u009e\5\u009e\u0c9d\n\u009e\3\u009f\3"+ - "\u009f\3\u00a0\3\u00a0\7\u00a0\u0ca3\n\u00a0\f\u00a0\16\u00a0\u0ca6\13"+ - "\u00a0\3\u00a0\3\u00a0\7\u00a0\u0caa\n\u00a0\f\u00a0\16\u00a0\u0cad\13"+ - "\u00a0\3\u00a1\3\u00a1\6\u00a1\u0cb1\n\u00a1\r\u00a1\16\u00a1\u0cb2\3"+ - "\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a5"+ - "\3\u00a5\3\u00a6\3\u00a6\7\u00a6\u0cc1\n\u00a6\f\u00a6\16\u00a6\u0cc4"+ - "\13\u00a6\3\u00a6\5\u00a6\u0cc7\n\u00a6\3\u00a7\6\u00a7\u0cca\n\u00a7"+ - "\r\u00a7\16\u00a7\u0ccb\3\u00a7\5\u00a7\u0ccf\n\u00a7\3\u00a7\2\2\u00a8"+ - "\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+ - "JLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+ - "\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+ - "\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+ - "\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+ - "\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+ - "\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104"+ - "\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c"+ - "\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134"+ - "\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c"+ - "\2\36\3\2?@\3\2CD\5\2\u008a\u008a\u008d\u0092\u0096\u0096\3\2\u00a3\u00a5"+ - "\3\2\u00a8\u00aa\4\2;;JJ\4\288XX\3\2\37#\4\2\62\63\65\66\3\2.\61\4\2]"+ - "]__\4\2\\\\^^\3\2\24\25\3\2\21\23\4\2\64\64[[\3\2qu\4\2||\u0081\u0081"+ - "\3\2mp\4\2]]``\3\2v{\3\2}\177\3\2\u0082\u0084\3\2\u0086\u0087\3\2el\t"+ - "\2>>FIMMRS`cm\u0087\u0093\u0093\3\2,-\3\2\32\33\4\2\7\7\35\35\2\u0e4d"+ - "\2\u014f\3\2\2\2\4\u0168\3\2\2\2\6\u0182\3\2\2\2\b\u01a6\3\2\2\2\n\u01ab"+ - "\3\2\2\2\f\u01ae\3\2\2\2\16\u01b8\3\2\2\2\20\u01bb\3\2\2\2\22\u01c0\3"+ - "\2\2\2\24\u020f\3\2\2\2\26\u0213\3\2\2\2\30\u0239\3\2\2\2\32\u025d\3\2"+ - "\2\2\34\u0274\3\2\2\2\36\u0283\3\2\2\2 \u0285\3\2\2\2\"\u028a\3\2\2\2"+ - "$\u029b\3\2\2\2&\u02b1\3\2\2\2(\u02b8\3\2\2\2*\u02ba\3\2\2\2,\u02c4\3"+ - "\2\2\2.\u02f7\3\2\2\2\60\u02f9\3\2\2\2\62\u031b\3\2\2\2\64\u033f\3\2\2"+ - "\2\66\u0355\3\2\2\28\u03a2\3\2\2\2:\u03c8\3\2\2\2<\u03db\3\2\2\2>\u03eb"+ - "\3\2\2\2@\u0405\3\2\2\2B\u0408\3\2\2\2D\u042c\3\2\2\2F\u0459\3\2\2\2H"+ - "\u04ca\3\2\2\2J\u04f0\3\2\2\2L\u050a\3\2\2\2N\u0540\3\2\2\2P\u0572\3\2"+ - "\2\2R\u0575\3\2\2\2T\u0597\3\2\2\2V\u05bb\3\2\2\2X\u05d5\3\2\2\2Z\u05e8"+ - "\3\2\2\2\\\u05eb\3\2\2\2^\u05f4\3\2\2\2`\u0600\3\2\2\2b\u0602\3\2\2\2"+ - "d\u0614\3\2\2\2f\u0623\3\2\2\2h\u0633\3\2\2\2j\u0646\3\2\2\2l\u064d\3"+ - "\2\2\2n\u0681\3\2\2\2p\u0683\3\2\2\2r\u068d\3\2\2\2t\u06b6\3\2\2\2v\u06d4"+ - "\3\2\2\2x\u06e7\3\2\2\2z\u0703\3\2\2\2|\u0709\3\2\2\2~\u0717\3\2\2\2\u0080"+ - "\u072d\3\2\2\2\u0082\u072f\3\2\2\2\u0084\u0731\3\2\2\2\u0086\u0745\3\2"+ - "\2\2\u0088\u0759\3\2\2\2\u008a\u0768\3\2\2\2\u008c\u0774\3\2\2\2\u008e"+ - "\u078c\3\2\2\2\u0090\u07a1\3\2\2\2\u0092\u07b0\3\2\2\2\u0094\u07be\3\2"+ - "\2\2\u0096\u07cd\3\2\2\2\u0098\u07dc\3\2\2\2\u009a\u07f1\3\2\2\2\u009c"+ - "\u07ff\3\2\2\2\u009e\u0808\3\2\2\2\u00a0\u080f\3\2\2\2\u00a2\u0815\3\2"+ - "\2\2\u00a4\u0817\3\2\2\2\u00a6\u081c\3\2\2\2\u00a8\u081e\3\2\2\2\u00aa"+ - "\u0844\3\2\2\2\u00ac\u085e\3\2\2\2\u00ae\u0863\3\2\2\2\u00b0\u089c\3\2"+ - "\2\2\u00b2\u089e\3\2\2\2\u00b4\u08c6\3\2\2\2\u00b6\u08c9\3\2\2\2\u00b8"+ - "\u08d5\3\2\2\2\u00ba\u08d8\3\2\2\2\u00bc\u0909\3\2\2\2\u00be\u090b\3\2"+ - "\2\2\u00c0\u0946\3\2\2\2\u00c2\u0948\3\2\2\2\u00c4\u094c\3\2\2\2\u00c6"+ - "\u094e\3\2\2\2\u00c8\u0958\3\2\2\2\u00ca\u0963\3\2\2\2\u00cc\u0965\3\2"+ - "\2\2\u00ce\u0969\3\2\2\2\u00d0\u096b\3\2\2\2\u00d2\u09ab\3\2\2\2\u00d4"+ - "\u09ad\3\2\2\2\u00d6\u09d3\3\2\2\2\u00d8\u09d5\3\2\2\2\u00da\u0a12\3\2"+ - "\2\2\u00dc\u0a34\3\2\2\2\u00de\u0a36\3\2\2\2\u00e0\u0a50\3\2\2\2\u00e2"+ - "\u0a54\3\2\2\2\u00e4\u0ab4\3\2\2\2\u00e6\u0ab6\3\2\2\2\u00e8\u0b1b\3\2"+ - "\2\2\u00ea\u0b20\3\2\2\2\u00ec\u0b22\3\2\2\2\u00ee\u0b2b\3\2\2\2\u00f0"+ - "\u0b34\3\2\2\2\u00f2\u0b59\3\2\2\2\u00f4\u0b73\3\2\2\2\u00f6\u0b7f\3\2"+ - "\2\2\u00f8\u0b81\3\2\2\2\u00fa\u0bc3\3\2\2\2\u00fc\u0bc5\3\2\2\2\u00fe"+ - "\u0bf0\3\2\2\2\u0100\u0bf3\3\2\2\2\u0102\u0c06\3\2\2\2\u0104\u0c08\3\2"+ - "\2\2\u0106\u0c0a\3\2\2\2\u0108\u0c0c\3\2\2\2\u010a\u0c0e\3\2\2\2\u010c"+ - "\u0c10\3\2\2\2\u010e\u0c12\3\2\2\2\u0110\u0c14\3\2\2\2\u0112\u0c1b\3\2"+ - "\2\2\u0114\u0c21\3\2\2\2\u0116\u0c26\3\2\2\2\u0118\u0c2a\3\2\2\2\u011a"+ - "\u0c36\3\2\2\2\u011c\u0c3e\3\2\2\2\u011e\u0c40\3\2\2\2\u0120\u0c42\3\2"+ - "\2\2\u0122\u0c44\3\2\2\2\u0124\u0c46\3\2\2\2\u0126\u0c48\3\2\2\2\u0128"+ - "\u0c4a\3\2\2\2\u012a\u0c4c\3\2\2\2\u012c\u0c4e\3\2\2\2\u012e\u0c50\3\2"+ - "\2\2\u0130\u0c52\3\2\2\2\u0132\u0c5b\3\2\2\2\u0134\u0c75\3\2\2\2\u0136"+ - "\u0c96\3\2\2\2\u0138\u0c98\3\2\2\2\u013a\u0c9c\3\2\2\2\u013c\u0c9e\3\2"+ - "\2\2\u013e\u0ca0\3\2\2\2\u0140\u0cae\3\2\2\2\u0142\u0cb4\3\2\2\2\u0144"+ - "\u0cb6\3\2\2\2\u0146\u0cb9\3\2\2\2\u0148\u0cbc\3\2\2\2\u014a\u0cc6\3\2"+ - "\2\2\u014c\u0cce\3\2\2\2\u014e\u0150\5\u0140\u00a1\2\u014f\u014e\3\2\2"+ - "\2\u014f\u0150\3\2\2\2\u0150\u0154\3\2\2\2\u0151\u0153\7\7\2\2\u0152\u0151"+ - "\3\2\2\2\u0153\u0156\3\2\2\2\u0154\u0152\3\2\2\2\u0154\u0155\3\2\2\2\u0155"+ - "\u015a\3\2\2\2\u0156\u0154\3\2\2\2\u0157\u0159\5\6\4\2\u0158\u0157\3\2"+ - "\2\2\u0159\u015c\3\2\2\2\u015a\u0158\3\2\2\2\u015a\u015b\3\2\2\2\u015b"+ - "\u015d\3\2\2\2\u015c\u015a\3\2\2\2\u015d\u015e\5\b\5\2\u015e\u0162\5\n"+ - "\6\2\u015f\u0161\5\20\t\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162"+ - "\u0160\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0165\3\2\2\2\u0164\u0162\3\2"+ - "\2\2\u0165\u0166\7\2\2\3\u0166\3\3\2\2\2\u0167\u0169\5\u0140\u00a1\2\u0168"+ - "\u0167\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016d\3\2\2\2\u016a\u016c\7\7"+ - "\2\2\u016b\u016a\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+ - "\u016e\3\2\2\2\u016e\u0173\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0172\5\6"+ - "\4\2\u0171\u0170\3\2\2\2\u0172\u0175\3\2\2\2\u0173\u0171\3\2\2\2\u0173"+ - "\u0174\3\2\2\2\u0174\u0176\3\2\2\2\u0175\u0173\3\2\2\2\u0176\u0177\5\b"+ - "\5\2\u0177\u017d\5\n\6\2\u0178\u0179\5|?\2\u0179\u017a\5\u014a\u00a6\2"+ - "\u017a\u017c\3\2\2\2\u017b\u0178\3\2\2\2\u017c\u017f\3\2\2\2\u017d\u017b"+ - "\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0180\3\2\2\2\u017f\u017d\3\2\2\2\u0180"+ - "\u0181\7\2\2\3\u0181\5\3\2\2\2\u0182\u0186\7d\2\2\u0183\u0185\7\7\2\2"+ - "\u0184\u0183\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0186\u0187"+ - "\3\2\2\2\u0187\u0189\3\2\2\2\u0188\u0186\3\2\2\2\u0189\u018d\7\34\2\2"+ - "\u018a\u018c\7\7\2\2\u018b\u018a\3\2\2\2\u018c\u018f\3\2\2\2\u018d\u018b"+ - "\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u0199\3\2\2\2\u018f\u018d\3\2\2\2\u0190"+ - "\u0192\7\r\2\2\u0191\u0193\5\u013a\u009e\2\u0192\u0191\3\2\2\2\u0193\u0194"+ - "\3\2\2\2\u0194\u0192\3\2\2\2\u0194\u0195\3\2\2\2\u0195\u0196\3\2\2\2\u0196"+ - "\u0197\7\16\2\2\u0197\u019a\3\2\2\2\u0198\u019a\5\u013a\u009e\2\u0199"+ - "\u0190\3\2\2\2\u0199\u0198\3\2\2\2\u019a\u019e\3\2\2\2\u019b\u019d\7\7"+ - "\2\2\u019c\u019b\3\2\2\2\u019d\u01a0\3\2\2\2\u019e\u019c\3\2\2\2\u019e"+ - "\u019f\3\2\2\2\u019f\7\3\2\2\2\u01a0\u019e\3\2\2\2\u01a1\u01a2\7=\2\2"+ - "\u01a2\u01a4\5\u013e\u00a0\2\u01a3\u01a5\5\u014a\u00a6\2\u01a4\u01a3\3"+ - "\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6\u01a1\3\2\2\2\u01a6"+ - "\u01a7\3\2\2\2\u01a7\t\3\2\2\2\u01a8\u01aa\5\f\7\2\u01a9\u01a8\3\2\2\2"+ - "\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\13"+ - "\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ae\u01af\7>\2\2\u01af\u01b3\5\u013e\u00a0"+ - "\2\u01b0\u01b1\7\t\2\2\u01b1\u01b4\7\21\2\2\u01b2\u01b4\5\16\b\2\u01b3"+ - "\u01b0\3\2\2\2\u01b3\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b6\3\2"+ - "\2\2\u01b5\u01b7\5\u014a\u00a6\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2"+ - "\2\u01b7\r\3\2\2\2\u01b8\u01b9\7[\2\2\u01b9\u01ba\5\u013c\u009f\2\u01ba"+ - "\17\3\2\2\2\u01bb\u01bd\5~@\2\u01bc\u01be\5\u014c\u00a7\2\u01bd\u01bc"+ - "\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\21\3\2\2\2\u01bf\u01c1\5\u0118\u008d"+ - "\2\u01c0\u01bf\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c6"+ - "\t\2\2\2\u01c3\u01c5\7\7\2\2\u01c4\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6"+ - "\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2"+ - "\2\2\u01c9\u01d1\5\u013c\u009f\2\u01ca\u01cc\7\7\2\2\u01cb\u01ca\3\2\2"+ - "\2\u01cc\u01cf\3\2\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0"+ - "\3\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d2\5T+\2\u01d1\u01cd\3\2\2\2\u01d1"+ - "\u01d2\3\2\2\2\u01d2\u01da\3\2\2\2\u01d3\u01d5\7\7\2\2\u01d4\u01d3\3\2"+ - "\2\2\u01d5\u01d8\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7"+ - "\u01d9\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d9\u01db\5\24\13\2\u01da\u01d6\3"+ - "\2\2\2\u01da\u01db\3\2\2\2\u01db\u01ea\3\2\2\2\u01dc\u01de\7\7\2\2\u01dd"+ - "\u01dc\3\2\2\2\u01de\u01e1\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2"+ - "\2\2\u01e0\u01e2\3\2\2\2\u01e1\u01df\3\2\2\2\u01e2\u01e6\7\34\2\2\u01e3"+ - "\u01e5\7\7\2\2\u01e4\u01e3\3\2\2\2\u01e5\u01e8\3\2\2\2\u01e6\u01e4\3\2"+ - "\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e9\3\2\2\2\u01e8\u01e6\3\2\2\2\u01e9"+ - "\u01eb\5\32\16\2\u01ea\u01df\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01f3\3"+ - "\2\2\2\u01ec\u01ee\7\7\2\2\u01ed\u01ec\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef"+ - "\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2\3\2\2\2\u01f1\u01ef\3\2"+ - "\2\2\u01f2\u01f4\5t;\2\u01f3\u01ef\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u0203"+ - "\3\2\2\2\u01f5\u01f7\7\7\2\2\u01f6\u01f5\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8"+ - "\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9\u01fb\3\2\2\2\u01fa\u01f8\3\2"+ - "\2\2\u01fb\u0204\5$\23\2\u01fc\u01fe\7\7\2\2\u01fd\u01fc\3\2\2\2\u01fe"+ - "\u0201\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0202\3\2"+ - "\2\2\u0201\u01ff\3\2\2\2\u0202\u0204\5\60\31\2\u0203\u01f8\3\2\2\2\u0203"+ - "\u01ff\3\2\2\2\u0203\u0204\3\2\2\2\u0204\23\3\2\2\2\u0205\u0207\5\u0118"+ - "\u008d\2\u0206\u0205\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208"+ - "\u020c\7F\2\2\u0209\u020b\7\7\2\2\u020a\u0209\3\2\2\2\u020b\u020e\3\2"+ - "\2\2\u020c\u020a\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u0210\3\2\2\2\u020e"+ - "\u020c\3\2\2\2\u020f\u0206\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0211\3\2"+ - "\2\2\u0211\u0212\5\26\f\2\u0212\25\3\2\2\2\u0213\u0217\7\13\2\2\u0214"+ - "\u0216\7\7\2\2\u0215\u0214\3\2\2\2\u0216\u0219\3\2\2\2\u0217\u0215\3\2"+ - "\2\2\u0217\u0218\3\2\2\2\u0218\u022e\3\2\2\2\u0219\u0217\3\2\2\2\u021a"+ - "\u022b\5\30\r\2\u021b\u021d\7\7\2\2\u021c\u021b\3\2\2\2\u021d\u0220\3"+ - "\2\2\2\u021e\u021c\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0221\3\2\2\2\u0220"+ - "\u021e\3\2\2\2\u0221\u0225\7\n\2\2\u0222\u0224\7\7\2\2\u0223\u0222\3\2"+ - "\2\2\u0224\u0227\3\2\2\2\u0225\u0223\3\2\2\2\u0225\u0226\3\2\2\2\u0226"+ - "\u0228\3\2\2\2\u0227\u0225\3\2\2\2\u0228\u022a\5\30\r\2\u0229\u021e\3"+ - "\2\2\2\u022a\u022d\3\2\2\2\u022b\u0229\3\2\2\2\u022b\u022c\3\2\2\2\u022c"+ - "\u022f\3\2\2\2\u022d\u022b\3\2\2\2\u022e\u021a\3\2\2\2\u022e\u022f\3\2"+ - "\2\2\u022f\u0233\3\2\2\2\u0230\u0232\7\7\2\2\u0231\u0230\3\2\2\2\u0232"+ - "\u0235\3\2\2\2\u0233\u0231\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0236\3\2"+ - "\2\2\u0235\u0233\3\2\2\2\u0236\u0237\7\f\2\2\u0237\27\3\2\2\2\u0238\u023a"+ - "\5\u0118\u008d\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2\u023a\u023c\3"+ - "\2\2\2\u023b\u023d\t\3\2\2\u023c\u023b\3\2\2\2\u023c\u023d\3\2\2\2\u023d"+ - "\u0241\3\2\2\2\u023e\u0240\7\7\2\2\u023f\u023e\3\2\2\2\u0240\u0243\3\2"+ - "\2\2\u0241\u023f\3\2\2\2\u0241\u0242\3\2\2\2\u0242\u0244\3\2\2\2\u0243"+ - "\u0241\3\2\2\2\u0244\u0245\5\u013c\u009f\2\u0245\u0249\7\34\2\2\u0246"+ - "\u0248\7\7\2\2\u0247\u0246\3\2\2\2\u0248\u024b\3\2\2\2\u0249\u0247\3\2"+ - "\2\2\u0249\u024a\3\2\2\2\u024a\u024c\3\2\2\2\u024b\u0249\3\2\2\2\u024c"+ - "\u025b\5\\/\2\u024d\u024f\7\7\2\2\u024e\u024d\3\2\2\2\u024f\u0252\3\2"+ - "\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251\u0253\3\2\2\2\u0252"+ - "\u0250\3\2\2\2\u0253\u0257\7\36\2\2\u0254\u0256\7\7\2\2\u0255\u0254\3"+ - "\2\2\2\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2\u0257\u0258\3\2\2\2\u0258"+ - "\u025a\3\2\2\2\u0259\u0257\3\2\2\2\u025a\u025c\5\u0082B\2\u025b\u0250"+ - "\3\2\2\2\u025b\u025c\3\2\2\2\u025c\31\3\2\2\2\u025d\u026e\5\34\17\2\u025e"+ - "\u0260\7\7\2\2\u025f\u025e\3\2\2\2\u0260\u0263\3\2\2\2\u0261\u025f\3\2"+ - "\2\2\u0261\u0262\3\2\2\2\u0262\u0264\3\2\2\2\u0263\u0261\3\2\2\2\u0264"+ - "\u0268\7\n\2\2\u0265\u0267\7\7\2\2\u0266\u0265\3\2\2\2\u0267\u026a\3\2"+ - "\2\2\u0268\u0266\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026b\3\2\2\2\u026a"+ - "\u0268\3\2\2\2\u026b\u026d\5\34\17\2\u026c\u0261\3\2\2\2\u026d\u0270\3"+ - "\2\2\2\u026e\u026c\3\2\2\2\u026e\u026f\3\2\2\2\u026f\33\3\2\2\2\u0270"+ - "\u026e\3\2\2\2\u0271\u0273\5\u0132\u009a\2\u0272\u0271\3\2\2\2\u0273\u0276"+ - "\3\2\2\2\u0274\u0272\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u027a\3\2\2\2\u0276"+ - "\u0274\3\2\2\2\u0277\u0279\7\7\2\2\u0278\u0277\3\2\2\2\u0279\u027c\3\2"+ - "\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027d\3\2\2\2\u027c"+ - "\u027a\3\2\2\2\u027d\u027e\5\36\20\2\u027e\35\3\2\2\2\u027f\u0284\5 \21"+ - "\2\u0280\u0284\5\"\22\2\u0281\u0284\5l\67\2\u0282\u0284\5h\65\2\u0283"+ - "\u027f\3\2\2\2\u0283\u0280\3\2\2\2\u0283\u0281\3\2\2\2\u0283\u0282\3\2"+ - "\2\2\u0284\37\3\2\2\2\u0285\u0286\5l\67\2\u0286\u0287\5\u00b0Y\2\u0287"+ - "!\3\2\2\2\u0288\u028b\5l\67\2\u0289\u028b\5h\65\2\u028a\u0288\3\2\2\2"+ - "\u028a\u0289\3\2\2\2\u028b\u028f\3\2\2\2\u028c\u028e\7\7\2\2\u028d\u028c"+ - "\3\2\2\2\u028e\u0291\3\2\2\2\u028f\u028d\3\2\2\2\u028f\u0290\3\2\2\2\u0290"+ - "\u0292\3\2\2\2\u0291\u028f\3\2\2\2\u0292\u0296\7G\2\2\u0293\u0295\7\7"+ - "\2\2\u0294\u0293\3\2\2\2\u0295\u0298\3\2\2\2\u0296\u0294\3\2\2\2\u0296"+ - "\u0297\3\2\2\2\u0297\u0299\3\2\2\2\u0298\u0296\3\2\2\2\u0299\u029a\5\u0082"+ - "B\2\u029a#\3\2\2\2\u029b\u029f\7\17\2\2\u029c\u029e\7\7\2\2\u029d\u029c"+ - "\3\2\2\2\u029e\u02a1\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0"+ - "\u02a2\3\2\2\2\u02a1\u029f\3\2\2\2\u02a2\u02a6\5&\24\2\u02a3\u02a5\7\7"+ - "\2\2\u02a4\u02a3\3\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a6"+ - "\u02a7\3\2\2\2\u02a7\u02a9\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a9\u02aa\7\20"+ - "\2\2\u02aa%\3\2\2\2\u02ab\u02ad\5(\25\2\u02ac\u02ae\5\u014c\u00a7\2\u02ad"+ - "\u02ac\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b0\3\2\2\2\u02af\u02ab\3\2"+ - "\2\2\u02b0\u02b3\3\2\2\2\u02b1\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2"+ - "\'\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b4\u02b9\5~@\2\u02b5\u02b9\5D#\2\u02b6"+ - "\u02b9\5*\26\2\u02b7\u02b9\5,\27\2\u02b8\u02b4\3\2\2\2\u02b8\u02b5\3\2"+ - "\2\2\u02b8\u02b6\3\2\2\2\u02b8\u02b7\3\2\2\2\u02b9)\3\2\2\2\u02ba\u02be"+ - "\7I\2\2\u02bb\u02bd\7\7\2\2\u02bc\u02bb\3\2\2\2\u02bd\u02c0\3\2\2\2\u02be"+ - "\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c1\3\2\2\2\u02c0\u02be\3\2"+ - "\2\2\u02c1\u02c2\5x=\2\u02c2+\3\2\2\2\u02c3\u02c5\5\u0118\u008d\2\u02c4"+ - "\u02c3\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02ca\7F"+ - "\2\2\u02c7\u02c9\7\7\2\2\u02c8\u02c7\3\2\2\2\u02c9\u02cc\3\2\2\2\u02ca"+ - "\u02c8\3\2\2\2\u02ca\u02cb\3\2\2\2\u02cb\u02cd\3\2\2\2\u02cc\u02ca\3\2"+ - "\2\2\u02cd\u02dc\58\35\2\u02ce\u02d0\7\7\2\2\u02cf\u02ce\3\2\2\2\u02d0"+ - "\u02d3\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d1\u02d2\3\2\2\2\u02d2\u02d4\3\2"+ - "\2\2\u02d3\u02d1\3\2\2\2\u02d4\u02d8\7\34\2\2\u02d5\u02d7\7\7\2\2\u02d6"+ - "\u02d5\3\2\2\2\u02d7\u02da\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d9\3\2"+ - "\2\2\u02d9\u02db\3\2\2\2\u02da\u02d8\3\2\2\2\u02db\u02dd\5.\30\2\u02dc"+ - "\u02d1\3\2\2\2\u02dc\u02dd\3\2\2\2\u02dd\u02e1\3\2\2\2\u02de\u02e0\7\7"+ - "\2\2\u02df\u02de\3\2\2\2\u02e0\u02e3\3\2\2\2\u02e1\u02df\3\2\2\2\u02e1"+ - "\u02e2\3\2\2\2\u02e2\u02e5\3\2\2\2\u02e3\u02e1\3\2\2\2\u02e4\u02e6\5x"+ - "=\2\u02e5\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6-\3\2\2\2\u02e7\u02eb"+ - "\7J\2\2\u02e8\u02ea\7\7\2\2\u02e9\u02e8\3\2\2\2\u02ea\u02ed\3\2\2\2\u02eb"+ - "\u02e9\3\2\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ee\3\2\2\2\u02ed\u02eb\3\2"+ - "\2\2\u02ee\u02f8\5\u00b0Y\2\u02ef\u02f3\7K\2\2\u02f0\u02f2\7\7\2\2\u02f1"+ - "\u02f0\3\2\2\2\u02f2\u02f5\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f3\u02f4\3\2"+ - "\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f6\u02f8\5\u00b0Y\2\u02f7"+ - "\u02e7\3\2\2\2\u02f7\u02ef\3\2\2\2\u02f8/\3\2\2\2\u02f9\u02fd\7\17\2\2"+ - "\u02fa\u02fc\7\7\2\2\u02fb\u02fa\3\2\2\2\u02fc\u02ff\3\2\2\2\u02fd\u02fb"+ - "\3\2\2\2\u02fd\u02fe\3\2\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2\2\u0300"+ - "\u0302\5\62\32\2\u0301\u0300\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0311\3"+ - "\2\2\2\u0303\u0305\7\7\2\2\u0304\u0303\3\2\2\2\u0305\u0308\3\2\2\2\u0306"+ - "\u0304\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u0309\3\2\2\2\u0308\u0306\3\2"+ - "\2\2\u0309\u030d\7\35\2\2\u030a\u030c\7\7\2\2\u030b\u030a\3\2\2\2\u030c"+ - "\u030f\3\2\2\2\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030e\u0310\3\2"+ - "\2\2\u030f\u030d\3\2\2\2\u0310\u0312\5&\24\2\u0311\u0306\3\2\2\2\u0311"+ - "\u0312\3\2\2\2\u0312\u0316\3\2\2\2\u0313\u0315\7\7\2\2\u0314\u0313\3\2"+ - "\2\2\u0315\u0318\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0317\3\2\2\2\u0317"+ - "\u0319\3\2\2\2\u0318\u0316\3\2\2\2\u0319\u031a\7\20\2\2\u031a\61\3\2\2"+ - "\2\u031b\u032c\5\64\33\2\u031c\u031e\7\7\2\2\u031d\u031c\3\2\2\2\u031e"+ - "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ - "\2\2\u0321\u031f\3\2\2\2\u0322\u0326\7\n\2\2\u0323\u0325\7\7\2\2\u0324"+ - "\u0323\3\2\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326\u0327\3\2"+ - "\2\2\u0327\u0329\3\2\2\2\u0328\u0326\3\2\2\2\u0329\u032b\5\64\33\2\u032a"+ - "\u031f\3\2\2\2\u032b\u032e\3\2\2\2\u032c\u032a\3\2\2\2\u032c\u032d\3\2"+ - "\2\2\u032d\u0332\3\2\2\2\u032e\u032c\3\2\2\2\u032f\u0331\7\7\2\2\u0330"+ - "\u032f\3\2\2\2\u0331\u0334\3\2\2\2\u0332\u0330\3\2\2\2\u0332\u0333\3\2"+ - "\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2\2\2\u0335\u0337\7\n\2\2\u0336"+ - "\u0335\3\2\2\2\u0336\u0337\3\2\2\2\u0337\63\3\2\2\2\u0338\u033c\5\u0118"+ - "\u008d\2\u0339\u033b\7\7\2\2\u033a\u0339\3\2\2\2\u033b\u033e\3\2\2\2\u033c"+ - "\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u0340\3\2\2\2\u033e\u033c\3\2"+ - "\2\2\u033f\u0338\3\2\2\2\u033f\u0340\3\2\2\2\u0340\u0341\3\2\2\2\u0341"+ - "\u0349\5\u013c\u009f\2\u0342\u0344\7\7\2\2\u0343\u0342\3\2\2\2\u0344\u0347"+ - "\3\2\2\2\u0345\u0343\3\2\2\2\u0345\u0346\3\2\2\2\u0346\u0348\3\2\2\2\u0347"+ - "\u0345\3\2\2\2\u0348\u034a\5\u00b0Y\2\u0349\u0345\3\2\2\2\u0349\u034a"+ - "\3\2\2\2\u034a\u0352\3\2\2\2\u034b\u034d\7\7\2\2\u034c\u034b\3\2\2\2\u034d"+ - "\u0350\3\2\2\2\u034e\u034c\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0351\3\2"+ - "\2\2\u0350\u034e\3\2\2\2\u0351\u0353\5$\23\2\u0352\u034e\3\2\2\2\u0352"+ - "\u0353\3\2\2\2\u0353\65\3\2\2\2\u0354\u0356\5\u0118\u008d\2\u0355\u0354"+ - "\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0357\3\2\2\2\u0357\u035f\7A\2\2\u0358"+ - "\u035a\7\7\2\2\u0359\u0358\3\2\2\2\u035a\u035d\3\2\2\2\u035b\u0359\3\2"+ - "\2\2\u035b\u035c\3\2\2\2\u035c\u035e\3\2\2\2\u035d\u035b\3\2\2\2\u035e"+ - "\u0360\5T+\2\u035f\u035b\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0370\3\2\2"+ - "\2\u0361\u0363\7\7\2\2\u0362\u0361\3\2\2\2\u0363\u0366\3\2\2\2\u0364\u0362"+ - "\3\2\2\2\u0364\u0365\3\2\2\2\u0365\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367"+ - "\u036b\5j\66\2\u0368\u036a\7\7\2\2\u0369\u0368\3\2\2\2\u036a\u036d\3\2"+ - "\2\2\u036b\u0369\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036e\3\2\2\2\u036d"+ - "\u036b\3\2\2\2\u036e\u036f\7\t\2\2\u036f\u0371\3\2\2\2\u0370\u0364\3\2"+ - "\2\2\u0370\u0371\3\2\2\2\u0371\u0375\3\2\2\2\u0372\u0374\7\7\2\2\u0373"+ - "\u0372\3\2\2\2\u0374\u0377\3\2\2\2\u0375\u0373\3\2\2\2\u0375\u0376\3\2"+ - "\2\2\u0376\u0378\3\2\2\2\u0377\u0375\3\2\2\2\u0378\u037c\5\u013c\u009f"+ - "\2\u0379\u037b\7\7\2\2\u037a\u0379\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a"+ - "\3\2\2\2\u037c\u037d\3\2\2\2\u037d\u037f\3\2\2\2\u037e\u037c\3\2\2\2\u037f"+ - "\u038e\58\35\2\u0380\u0382\7\7\2\2\u0381\u0380\3\2\2\2\u0382\u0385\3\2"+ - "\2\2\u0383\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0386\3\2\2\2\u0385"+ - "\u0383\3\2\2\2\u0386\u038a\7\34\2\2\u0387\u0389\7\7\2\2\u0388\u0387\3"+ - "\2\2\2\u0389\u038c\3\2\2\2\u038a\u0388\3\2\2\2\u038a\u038b\3\2\2\2\u038b"+ - "\u038d\3\2\2\2\u038c\u038a\3\2\2\2\u038d\u038f\5\\/\2\u038e\u0383\3\2"+ - "\2\2\u038e\u038f\3\2\2\2\u038f\u0397\3\2\2\2\u0390\u0392\7\7\2\2\u0391"+ - "\u0390\3\2\2\2\u0392\u0395\3\2\2\2\u0393\u0391\3\2\2\2\u0393\u0394\3\2"+ - "\2\2\u0394\u0396\3\2\2\2\u0395\u0393\3\2\2\2\u0396\u0398\5t;\2\u0397\u0393"+ - "\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u03a0\3\2\2\2\u0399\u039b\7\7\2\2\u039a"+ - "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ - "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a1\5@!\2\u03a0\u039c"+ - "\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\67\3\2\2\2\u03a2\u03a6\7\13\2\2\u03a3"+ - "\u03a5\7\7\2\2\u03a4\u03a3\3\2\2\2\u03a5\u03a8\3\2\2\2\u03a6\u03a4\3\2"+ - "\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03bd\3\2\2\2\u03a8\u03a6\3\2\2\2\u03a9"+ - "\u03ba\5:\36\2\u03aa\u03ac\7\7\2\2\u03ab\u03aa\3\2\2\2\u03ac\u03af\3\2"+ - "\2\2\u03ad\u03ab\3\2\2\2\u03ad\u03ae\3\2\2\2\u03ae\u03b0\3\2\2\2\u03af"+ - "\u03ad\3\2\2\2\u03b0\u03b4\7\n\2\2\u03b1\u03b3\7\7\2\2\u03b2\u03b1\3\2"+ - "\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5"+ - "\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b9\5:\36\2\u03b8\u03ad\3\2"+ - "\2\2\u03b9\u03bc\3\2\2\2\u03ba\u03b8\3\2\2\2\u03ba\u03bb\3\2\2\2\u03bb"+ - "\u03be\3\2\2\2\u03bc\u03ba\3\2\2\2\u03bd\u03a9\3\2\2\2\u03bd\u03be\3\2"+ - "\2\2\u03be\u03c2\3\2\2\2\u03bf\u03c1\7\7\2\2\u03c0\u03bf\3\2\2\2\u03c1"+ - "\u03c4\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c5\3\2"+ - "\2\2\u03c4\u03c2\3\2\2\2\u03c5\u03c6\7\f\2\2\u03c69\3\2\2\2\u03c7\u03c9"+ - "\5\u0118\u008d\2\u03c8\u03c7\3\2\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03ca\3"+ - "\2\2\2\u03ca\u03d9\5<\37\2\u03cb\u03cd\7\7\2\2\u03cc\u03cb\3\2\2\2\u03cd"+ - "\u03d0\3\2\2\2\u03ce\u03cc\3\2\2\2\u03ce\u03cf\3\2\2\2\u03cf\u03d1\3\2"+ - "\2\2\u03d0\u03ce\3\2\2\2\u03d1\u03d5\7\36\2\2\u03d2\u03d4\7\7\2\2\u03d3"+ - "\u03d2\3\2\2\2\u03d4\u03d7\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d5\u03d6\3\2"+ - "\2\2\u03d6\u03d8\3\2\2\2\u03d7\u03d5\3\2\2\2\u03d8\u03da\5\u0082B\2\u03d9"+ - "\u03ce\3\2\2\2\u03d9\u03da\3\2\2\2\u03da;\3\2\2\2\u03db\u03df\5\u013c"+ - "\u009f\2\u03dc\u03de\7\7\2\2\u03dd\u03dc\3\2\2\2\u03de\u03e1\3\2\2\2\u03df"+ - "\u03dd\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e2\3\2\2\2\u03e1\u03df\3\2"+ - "\2\2\u03e2\u03e6\7\34\2\2\u03e3\u03e5\7\7\2\2\u03e4\u03e3\3\2\2\2\u03e5"+ - "\u03e8\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03e9\3\2"+ - "\2\2\u03e8\u03e6\3\2\2\2\u03e9\u03ea\5\\/\2\u03ea=\3\2\2\2\u03eb\u03ef"+ - "\5\u013c\u009f\2\u03ec\u03ee\7\7\2\2\u03ed\u03ec\3\2\2\2\u03ee\u03f1\3"+ - "\2\2\2\u03ef\u03ed\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0\u03fa\3\2\2\2\u03f1"+ - "\u03ef\3\2\2\2\u03f2\u03f6\7\34\2\2\u03f3\u03f5\7\7\2\2\u03f4\u03f3\3"+ - "\2\2\2\u03f5\u03f8\3\2\2\2\u03f6\u03f4\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7"+ - "\u03f9\3\2\2\2\u03f8\u03f6\3\2\2\2\u03f9\u03fb\5\\/\2\u03fa\u03f2\3\2"+ - "\2\2\u03fa\u03fb\3\2\2\2\u03fb?\3\2\2\2\u03fc\u0406\5x=\2\u03fd\u0401"+ - "\7\36\2\2\u03fe\u0400\7\7\2\2\u03ff\u03fe\3\2\2\2\u0400\u0403\3\2\2\2"+ - "\u0401\u03ff\3\2\2\2\u0401\u0402\3\2\2\2\u0402\u0404\3\2\2\2\u0403\u0401"+ - "\3\2\2\2\u0404\u0406\5\u0082B\2\u0405\u03fc\3\2\2\2\u0405\u03fd\3\2\2"+ - "\2\u0406A\3\2\2\2\u0407\u0409\5\u0118\u008d\2\u0408\u0407\3\2\2\2\u0408"+ - "\u0409\3\2\2\2\u0409\u040a\3\2\2\2\u040a\u040e\7B\2\2\u040b\u040d\7\7"+ - "\2\2\u040c\u040b\3\2\2\2\u040d\u0410\3\2\2\2\u040e\u040c\3\2\2\2\u040e"+ - "\u040f\3\2\2\2\u040f\u0411\3\2\2\2\u0410\u040e\3\2\2\2\u0411\u0420\5\u013c"+ - "\u009f\2\u0412\u0414\7\7\2\2\u0413\u0412\3\2\2\2\u0414\u0417\3\2\2\2\u0415"+ - "\u0413\3\2\2\2\u0415\u0416\3\2\2\2\u0416\u0418\3\2\2\2\u0417\u0415\3\2"+ - "\2\2\u0418\u041c\7\34\2\2\u0419\u041b\7\7\2\2\u041a\u0419\3\2\2\2\u041b"+ - "\u041e\3\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u041f\3\2"+ - "\2\2\u041e\u041c\3\2\2\2\u041f\u0421\5\32\16\2\u0420\u0415\3\2\2\2\u0420"+ - "\u0421\3\2\2\2\u0421\u0429\3\2\2\2\u0422\u0424\7\7\2\2\u0423\u0422\3\2"+ - "\2\2\u0424\u0427\3\2\2\2\u0425\u0423\3\2\2\2\u0425\u0426\3\2\2\2\u0426"+ - "\u0428\3\2\2\2\u0427\u0425\3\2\2\2\u0428\u042a\5$\23\2\u0429\u0425\3\2"+ - "\2\2\u0429\u042a\3\2\2\2\u042aC\3\2\2\2\u042b\u042d\5\u0118\u008d\2\u042c"+ - "\u042b\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\3\2\2\2\u042e\u0432\7H"+ - "\2\2\u042f\u0431\7\7\2\2\u0430\u042f\3\2\2\2\u0431\u0434\3\2\2\2\u0432"+ - "\u0430\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0435\3\2\2\2\u0434\u0432\3\2"+ - "\2\2\u0435\u043d\7B\2\2\u0436\u0438\7\7\2\2\u0437\u0436\3\2\2\2\u0438"+ - "\u043b\3\2\2\2\u0439\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043c\3\2"+ - "\2\2\u043b\u0439\3\2\2\2\u043c\u043e\5\u013c\u009f\2\u043d\u0439\3\2\2"+ - "\2\u043d\u043e\3\2\2\2\u043e\u044d\3\2\2\2\u043f\u0441\7\7\2\2\u0440\u043f"+ - "\3\2\2\2\u0441\u0444\3\2\2\2\u0442\u0440\3\2\2\2\u0442\u0443\3\2\2\2\u0443"+ - "\u0445\3\2\2\2\u0444\u0442\3\2\2\2\u0445\u0449\7\34\2\2\u0446\u0448\7"+ - "\7\2\2\u0447\u0446\3\2\2\2\u0448\u044b\3\2\2\2\u0449\u0447\3\2\2\2\u0449"+ - "\u044a\3\2\2\2\u044a\u044c\3\2\2\2\u044b\u0449\3\2\2\2\u044c\u044e\5\32"+ - "\16\2\u044d\u0442\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u0456\3\2\2\2\u044f"+ - "\u0451\7\7\2\2\u0450\u044f\3\2\2\2\u0451\u0454\3\2\2\2\u0452\u0450\3\2"+ - "\2\2\u0452\u0453\3\2\2\2\u0453\u0455\3\2\2\2\u0454\u0452\3\2\2\2\u0455"+ - "\u0457\5$\23\2\u0456\u0452\3\2\2\2\u0456\u0457\3\2\2\2\u0457E\3\2\2\2"+ - "\u0458\u045a\5\u0118\u008d\2\u0459\u0458\3\2\2\2\u0459\u045a\3\2\2\2\u045a"+ - "\u045b\3\2\2\2\u045b\u0463\t\3\2\2\u045c\u045e\7\7\2\2\u045d\u045c\3\2"+ - "\2\2\u045e\u0461\3\2\2\2\u045f\u045d\3\2\2\2\u045f\u0460\3\2\2\2\u0460"+ - "\u0462\3\2\2\2\u0461\u045f\3\2\2\2\u0462\u0464\5T+\2\u0463\u045f\3\2\2"+ - "\2\u0463\u0464\3\2\2\2\u0464\u0474\3\2\2\2\u0465\u0467\7\7\2\2\u0466\u0465"+ - "\3\2\2\2\u0467\u046a\3\2\2\2\u0468\u0466\3\2\2\2\u0468\u0469\3\2\2\2\u0469"+ - "\u046b\3\2\2\2\u046a\u0468\3\2\2\2\u046b\u046f\5j\66\2\u046c\u046e\7\7"+ - "\2\2\u046d\u046c\3\2\2\2\u046e\u0471\3\2\2\2\u046f\u046d\3\2\2\2\u046f"+ - "\u0470\3\2\2\2\u0470\u0472\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0473\7\t"+ - "\2\2\u0473\u0475\3\2\2\2\u0474\u0468\3\2\2\2\u0474\u0475\3\2\2\2\u0475"+ - "\u0479\3\2\2\2\u0476\u0478\7\7\2\2\u0477\u0476\3\2\2\2\u0478\u047b\3\2"+ - "\2\2\u0479\u0477\3\2\2\2\u0479\u047a\3\2\2\2\u047a\u047e\3\2\2\2\u047b"+ - "\u0479\3\2\2\2\u047c\u047f\5H%\2\u047d\u047f\5J&\2\u047e\u047c\3\2\2\2"+ - "\u047e\u047d\3\2\2\2\u047f\u0487\3\2\2\2\u0480\u0482\7\7\2\2\u0481\u0480"+ - "\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2\2\2\u0484"+ - "\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0488\5t;\2\u0487\u0483\3\2\2"+ - "\2\u0487\u0488\3\2\2\2\u0488\u049a\3\2\2\2\u0489\u048b\7\7\2\2\u048a\u0489"+ - "\3\2\2\2\u048b\u048e\3\2\2\2\u048c\u048a\3\2\2\2\u048c\u048d\3\2\2\2\u048d"+ - "\u0498\3\2\2\2\u048e\u048c\3\2\2\2\u048f\u0493\7\36\2\2\u0490\u0492\7"+ - "\7\2\2\u0491\u0490\3\2\2\2\u0492\u0495\3\2\2\2\u0493\u0491\3\2\2\2\u0493"+ - "\u0494\3\2\2\2\u0494\u0496\3\2\2\2\u0495\u0493\3\2\2\2\u0496\u0499\5\u0082"+ - "B\2\u0497\u0499\5L\'\2\u0498\u048f\3\2\2\2\u0498\u0497\3\2\2\2\u0499\u049b"+ - "\3\2\2\2\u049a\u048c\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u04a2\3\2\2\2\u049c"+ - "\u049e\7\7\2\2\u049d\u049c\3\2\2\2\u049e\u049f\3\2\2\2\u049f\u049d\3\2"+ - "\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a3\7\35\2\2\u04a2"+ - "\u049d\3\2\2\2\u04a2\u04a3\3\2\2\2\u04a3\u04a7\3\2\2\2\u04a4\u04a6\7\7"+ - "\2\2\u04a5\u04a4\3\2\2\2\u04a6\u04a9\3\2\2\2\u04a7\u04a5\3\2\2\2\u04a7"+ - "\u04a8\3\2\2\2\u04a8\u04c8\3\2\2\2\u04a9\u04a7\3\2\2\2\u04aa\u04ac\5N"+ - "(\2\u04ab\u04aa\3\2\2\2\u04ab\u04ac\3\2\2\2\u04ac\u04b7\3\2\2\2\u04ad"+ - "\u04af\7\7\2\2\u04ae\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2"+ - "\2\2\u04b0\u04b1\3\2\2\2\u04b1\u04b4\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3"+ - "\u04b5\5\u014a\u00a6\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6"+ - "\3\2\2\2\u04b6\u04b8\5P)\2\u04b7\u04b0\3\2\2\2\u04b7\u04b8\3\2\2\2\u04b8"+ - "\u04c9\3\2\2\2\u04b9\u04bb\5P)\2\u04ba\u04b9\3\2\2\2\u04ba\u04bb\3\2\2"+ - "\2\u04bb\u04c6\3\2\2\2\u04bc\u04be\7\7\2\2\u04bd\u04bc\3\2\2\2\u04be\u04c1"+ - "\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c3\3\2\2\2\u04c1"+ - "\u04bf\3\2\2\2\u04c2\u04c4\5\u014a\u00a6\2\u04c3\u04c2\3\2\2\2\u04c3\u04c4"+ - "\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c7\5N(\2\u04c6\u04bf\3\2\2\2\u04c6"+ - "\u04c7\3\2\2\2\u04c7\u04c9\3\2\2\2\u04c8\u04ab\3\2\2\2\u04c8\u04ba\3\2"+ - "\2\2\u04c9G\3\2\2\2\u04ca\u04ce\7\13\2\2\u04cb\u04cd\7\7\2\2\u04cc\u04cb"+ - "\3\2\2\2\u04cd\u04d0\3\2\2\2\u04ce\u04cc\3\2\2\2\u04ce\u04cf\3\2\2\2\u04cf"+ - "\u04d1\3\2\2\2\u04d0\u04ce\3\2\2\2\u04d1\u04e2\5J&\2\u04d2\u04d4\7\7\2"+ - "\2\u04d3\u04d2\3\2\2\2\u04d4\u04d7\3\2\2\2\u04d5\u04d3\3\2\2\2\u04d5\u04d6"+ - "\3\2\2\2\u04d6\u04d8\3\2\2\2\u04d7\u04d5\3\2\2\2\u04d8\u04dc\7\n\2\2\u04d9"+ - "\u04db\7\7\2\2\u04da\u04d9\3\2\2\2\u04db\u04de\3\2\2\2\u04dc\u04da\3\2"+ - "\2\2\u04dc\u04dd\3\2\2\2\u04dd\u04df\3\2\2\2\u04de\u04dc\3\2\2\2\u04df"+ - "\u04e1\5J&\2\u04e0\u04d5\3\2\2\2\u04e1\u04e4\3\2\2\2\u04e2\u04e0\3\2\2"+ - "\2\u04e2\u04e3\3\2\2\2\u04e3\u04e8\3\2\2\2\u04e4\u04e2\3\2\2\2\u04e5\u04e7"+ - "\7\7\2\2\u04e6\u04e5\3\2\2\2\u04e7\u04ea\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e8"+ - "\u04e9\3\2\2\2\u04e9\u04eb\3\2\2\2\u04ea\u04e8\3\2\2\2\u04eb\u04ec\7\f"+ - "\2\2\u04ecI\3\2\2\2\u04ed\u04ef\5\u0132\u009a\2\u04ee\u04ed\3\2\2\2\u04ef"+ - "\u04f2\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u04f6\3\2"+ - "\2\2\u04f2\u04f0\3\2\2\2\u04f3\u04f5\7\7\2\2\u04f4\u04f3\3\2\2\2\u04f5"+ - "\u04f8\3\2\2\2\u04f6\u04f4\3\2\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f9\3\2"+ - "\2\2\u04f8\u04f6\3\2\2\2\u04f9\u0508\5\u013c\u009f\2\u04fa\u04fc\7\7\2"+ - "\2\u04fb\u04fa\3\2\2\2\u04fc\u04ff\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fd\u04fe"+ - "\3\2\2\2\u04fe\u0500\3\2\2\2\u04ff\u04fd\3\2\2\2\u0500\u0504\7\34\2\2"+ - "\u0501\u0503\7\7\2\2\u0502\u0501\3\2\2\2\u0503\u0506\3\2\2\2\u0504\u0502"+ - "\3\2\2\2\u0504\u0505\3\2\2\2\u0505\u0507\3\2\2\2\u0506\u0504\3\2\2\2\u0507"+ - "\u0509\5\\/\2\u0508\u04fd\3\2\2\2\u0508\u0509\3\2\2\2\u0509K\3\2\2\2\u050a"+ - "\u050e\7G\2\2\u050b\u050d\7\7\2\2\u050c\u050b\3\2\2\2\u050d\u0510\3\2"+ - "\2\2\u050e\u050c\3\2\2\2\u050e\u050f\3\2\2\2\u050f\u0511\3\2\2\2\u0510"+ - "\u050e\3\2\2\2\u0511\u0512\5\u0082B\2\u0512M\3\2\2\2\u0513\u0515\5\u0118"+ - "\u008d\2\u0514\u0513\3\2\2\2\u0514\u0515\3\2\2\2\u0515\u0516\3\2\2\2\u0516"+ - "\u0541\7a\2\2\u0517\u0519\5\u0118\u008d\2\u0518\u0517\3\2\2\2\u0518\u0519"+ - "\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051e\7a\2\2\u051b\u051d\7\7\2\2\u051c"+ - "\u051b\3\2\2\2\u051d\u0520\3\2\2\2\u051e\u051c\3\2\2\2\u051e\u051f\3\2"+ - "\2\2\u051f\u0521\3\2\2\2\u0520\u051e\3\2\2\2\u0521\u0525\7\13\2\2\u0522"+ - "\u0524\7\7\2\2\u0523\u0522\3\2\2\2\u0524\u0527\3\2\2\2\u0525\u0523\3\2"+ - "\2\2\u0525\u0526\3\2\2\2\u0526\u0528\3\2\2\2\u0527\u0525\3\2\2\2\u0528"+ - "\u0537\7\f\2\2\u0529\u052b\7\7\2\2\u052a\u0529\3\2\2\2\u052b\u052e\3\2"+ - "\2\2\u052c\u052a\3\2\2\2\u052c\u052d\3\2\2\2\u052d\u052f\3\2\2\2\u052e"+ - "\u052c\3\2\2\2\u052f\u0533\7\34\2\2\u0530\u0532\7\7\2\2\u0531\u0530\3"+ - "\2\2\2\u0532\u0535\3\2\2\2\u0533\u0531\3\2\2\2\u0533\u0534\3\2\2\2\u0534"+ - "\u0536\3\2\2\2\u0535\u0533\3\2\2\2\u0536\u0538\5\\/\2\u0537\u052c\3\2"+ - "\2\2\u0537\u0538\3\2\2\2\u0538\u053c\3\2\2\2\u0539\u053b\7\7\2\2\u053a"+ - "\u0539\3\2\2\2\u053b\u053e\3\2\2\2\u053c\u053a\3\2\2\2\u053c\u053d\3\2"+ - "\2\2\u053d\u053f\3\2\2\2\u053e\u053c\3\2\2\2\u053f\u0541\5@!\2\u0540\u0514"+ - "\3\2\2\2\u0540\u0518\3\2\2\2\u0541O\3\2\2\2\u0542\u0544\5\u0118\u008d"+ - "\2\u0543\u0542\3\2\2\2\u0543\u0544\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0573"+ - "\7b\2\2\u0546\u0548\5\u0118\u008d\2\u0547\u0546\3\2\2\2\u0547\u0548\3"+ - "\2\2\2\u0548\u0549\3\2\2\2\u0549\u054d\7b\2\2\u054a\u054c\7\7\2\2\u054b"+ - "\u054a\3\2\2\2\u054c\u054f\3\2\2\2\u054d\u054b\3\2\2\2\u054d\u054e\3\2"+ - "\2\2\u054e\u0550\3\2\2\2\u054f\u054d\3\2\2\2\u0550\u0555\7\13\2\2\u0551"+ - "\u0554\5\u0132\u009a\2\u0552\u0554\5\u012a\u0096\2\u0553\u0551\3\2\2\2"+ - "\u0553\u0552\3\2\2\2\u0554\u0557\3\2\2\2\u0555\u0553\3\2\2\2\u0555\u0556"+ - "\3\2\2\2\u0556\u0558\3\2\2\2\u0557\u0555\3\2\2\2\u0558\u0559\5> \2\u0559"+ - "\u0568\7\f\2\2\u055a\u055c\7\7\2\2\u055b\u055a\3\2\2\2\u055c\u055f\3\2"+ - "\2\2\u055d\u055b\3\2\2\2\u055d\u055e\3\2\2\2\u055e\u0560\3\2\2\2\u055f"+ - "\u055d\3\2\2\2\u0560\u0564\7\34\2\2\u0561\u0563\7\7\2\2\u0562\u0561\3"+ - "\2\2\2\u0563\u0566\3\2\2\2\u0564\u0562\3\2\2\2\u0564\u0565\3\2\2\2\u0565"+ - "\u0567\3\2\2\2\u0566\u0564\3\2\2\2\u0567\u0569\5\\/\2\u0568\u055d\3\2"+ - "\2\2\u0568\u0569\3\2\2\2\u0569\u056d\3\2\2\2\u056a\u056c\7\7\2\2\u056b"+ - "\u056a\3\2\2\2\u056c\u056f\3\2\2\2\u056d\u056b\3\2\2\2\u056d\u056e\3\2"+ - "\2\2\u056e\u0570\3\2\2\2\u056f\u056d\3\2\2\2\u0570\u0571\5@!\2\u0571\u0573"+ - "\3\2\2\2\u0572\u0543\3\2\2\2\u0572\u0547\3\2\2\2\u0573Q\3\2\2\2\u0574"+ - "\u0576\5\u0118\u008d\2\u0575\u0574\3\2\2\2\u0575\u0576\3\2\2\2\u0576\u0577"+ - "\3\2\2\2\u0577\u057b\7E\2\2\u0578\u057a\7\7\2\2\u0579\u0578\3\2\2\2\u057a"+ - "\u057d\3\2\2\2\u057b\u0579\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u057e\3\2"+ - "\2\2\u057d\u057b\3\2\2\2\u057e\u0586\5\u013c\u009f\2\u057f\u0581\7\7\2"+ - "\2\u0580\u057f\3\2\2\2\u0581\u0584\3\2\2\2\u0582\u0580\3\2\2\2\u0582\u0583"+ - "\3\2\2\2\u0583\u0585\3\2\2\2\u0584\u0582\3\2\2\2\u0585\u0587\5T+\2\u0586"+ - "\u0582\3\2\2\2\u0586\u0587\3\2\2\2\u0587\u058b\3\2\2\2\u0588\u058a\7\7"+ - "\2\2\u0589\u0588\3\2\2\2\u058a\u058d\3\2\2\2\u058b\u0589\3\2\2\2\u058b"+ - "\u058c\3\2\2\2\u058c\u058e\3\2\2\2\u058d\u058b\3\2\2\2\u058e\u0592\7\36"+ - "\2\2\u058f\u0591\7\7\2\2\u0590\u058f\3\2\2\2\u0591\u0594\3\2\2\2\u0592"+ - "\u0590\3\2\2\2\u0592\u0593\3\2\2\2\u0593\u0595\3\2\2\2\u0594\u0592\3\2"+ - "\2\2\u0595\u0596\5\\/\2\u0596S\3\2\2\2\u0597\u059b\7.\2\2\u0598\u059a"+ - "\7\7\2\2\u0599\u0598\3\2\2\2\u059a\u059d\3\2\2\2\u059b\u0599\3\2\2\2\u059b"+ - "\u059c\3\2\2\2\u059c\u059e\3\2\2\2\u059d\u059b\3\2\2\2\u059e\u05af\5V"+ - ",\2\u059f\u05a1\7\7\2\2\u05a0\u059f\3\2\2\2\u05a1\u05a4\3\2\2\2\u05a2"+ - "\u05a0\3\2\2\2\u05a2\u05a3\3\2\2\2\u05a3\u05a5\3\2\2\2\u05a4\u05a2\3\2"+ - "\2\2\u05a5\u05a9\7\n\2\2\u05a6\u05a8\7\7\2\2\u05a7\u05a6\3\2\2\2\u05a8"+ - "\u05ab\3\2\2\2\u05a9\u05a7\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ac\3\2"+ - "\2\2\u05ab\u05a9\3\2\2\2\u05ac\u05ae\5V,\2\u05ad\u05a2\3\2\2\2\u05ae\u05b1"+ - "\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05b0\3\2\2\2\u05b0\u05b5\3\2\2\2\u05b1"+ - "\u05af\3\2\2\2\u05b2\u05b4\7\7\2\2\u05b3\u05b2\3\2\2\2\u05b4\u05b7\3\2"+ - "\2\2\u05b5\u05b3\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u05b8\3\2\2\2\u05b7"+ - "\u05b5\3\2\2\2\u05b8\u05b9\7/\2\2\u05b9U\3\2\2\2\u05ba\u05bc\5X-\2\u05bb"+ - "\u05ba\3\2\2\2\u05bb\u05bc\3\2\2\2\u05bc\u05c0\3\2\2\2\u05bd\u05bf\7\7"+ - "\2\2\u05be\u05bd\3\2\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0"+ - "\u05c1\3\2\2\2\u05c1\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05d2\5\u013c"+ - "\u009f\2\u05c4\u05c6\7\7\2\2\u05c5\u05c4\3\2\2\2\u05c6\u05c9\3\2\2\2\u05c7"+ - "\u05c5\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8\u05ca\3\2\2\2\u05c9\u05c7\3\2"+ - "\2\2\u05ca\u05ce\7\34\2\2\u05cb\u05cd\7\7\2\2\u05cc\u05cb\3\2\2\2\u05cd"+ - "\u05d0\3\2\2\2\u05ce\u05cc\3\2\2\2\u05ce\u05cf\3\2\2\2\u05cf\u05d1\3\2"+ - "\2\2\u05d0\u05ce\3\2\2\2\u05d1\u05d3\5\\/\2\u05d2\u05c7\3\2\2\2\u05d2"+ - "\u05d3\3\2\2\2\u05d3W\3\2\2\2\u05d4\u05d6\5Z.\2\u05d5\u05d4\3\2\2\2\u05d6"+ - "\u05d7\3\2\2\2\u05d7\u05d5\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8Y\3\2\2\2"+ - "\u05d9\u05dd\5\u012c\u0097\2\u05da\u05dc\7\7\2\2\u05db\u05da\3\2\2\2\u05dc"+ - "\u05df\3\2\2\2\u05dd\u05db\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05e9\3\2"+ - "\2\2\u05df\u05dd\3\2\2\2\u05e0\u05e4\5\u0122\u0092\2\u05e1\u05e3\7\7\2"+ - "\2\u05e2\u05e1\3\2\2\2\u05e3\u05e6\3\2\2\2\u05e4\u05e2\3\2\2\2\u05e4\u05e5"+ - "\3\2\2\2\u05e5\u05e9\3\2\2\2\u05e6\u05e4\3\2\2\2\u05e7\u05e9\5\u0132\u009a"+ - "\2\u05e8\u05d9\3\2\2\2\u05e8\u05e0\3\2\2\2\u05e8\u05e7\3\2\2\2\u05e9["+ - "\3\2\2\2\u05ea\u05ec\5^\60\2\u05eb\u05ea\3\2\2\2\u05eb\u05ec\3\2\2\2\u05ec"+ - "\u05f1\3\2\2\2\u05ed\u05f2\5b\62\2\u05ee\u05f2\5d\63\2\u05ef\u05f2\5f"+ - "\64\2\u05f0\u05f2\5h\65\2\u05f1\u05ed\3\2\2\2\u05f1\u05ee\3\2\2\2\u05f1"+ - "\u05ef\3\2\2\2\u05f1\u05f0\3\2\2\2\u05f2]\3\2\2\2\u05f3\u05f5\5`\61\2"+ - "\u05f4\u05f3\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f6\u05f7"+ - "\3\2\2\2\u05f7_\3\2\2\2\u05f8\u0601\5\u0132\u009a\2\u05f9\u05fd\7{\2\2"+ - "\u05fa\u05fc\7\7\2\2\u05fb\u05fa\3\2\2\2\u05fc\u05ff\3\2\2\2\u05fd\u05fb"+ - "\3\2\2\2\u05fd\u05fe\3\2\2\2\u05fe\u0601\3\2\2\2\u05ff\u05fd\3\2\2\2\u0600"+ - "\u05f8\3\2\2\2\u0600\u05f9\3\2\2\2\u0601a\3\2\2\2\u0602\u0606\7\13\2\2"+ - "\u0603\u0605\7\7\2\2\u0604\u0603\3\2\2\2\u0605\u0608\3\2\2\2\u0606\u0604"+ - "\3\2\2\2\u0606\u0607\3\2\2\2\u0607\u0609\3\2\2\2\u0608\u0606\3\2\2\2\u0609"+ - "\u060d\5\\/\2\u060a\u060c\7\7\2\2\u060b\u060a\3\2\2\2\u060c\u060f\3\2"+ - "\2\2\u060d\u060b\3\2\2\2\u060d\u060e\3\2\2\2\u060e\u0610\3\2\2\2\u060f"+ - "\u060d\3\2\2\2\u0610\u0611\7\f\2\2\u0611c\3\2\2\2\u0612\u0615\5f\64\2"+ - "\u0613\u0615\5b\62\2\u0614\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0619"+ - "\3\2\2\2\u0616\u0618\7\7\2\2\u0617\u0616\3\2\2\2\u0618\u061b\3\2\2\2\u0619"+ - "\u0617\3\2\2\2\u0619\u061a\3\2\2\2\u061a\u061d\3\2\2\2\u061b\u0619\3\2"+ - "\2\2\u061c\u061e\5\u0142\u00a2\2\u061d\u061c\3\2\2\2\u061e\u061f\3\2\2"+ - "\2\u061f\u061d\3\2\2\2\u061f\u0620\3\2\2\2\u0620e\3\2\2\2\u0621\u0624"+ - "\5l\67\2\u0622\u0624\7c\2\2\u0623\u0621\3\2\2\2\u0623\u0622\3\2\2\2\u0624"+ - "g\3\2\2\2\u0625\u0629\5j\66\2\u0626\u0628\7\7\2\2\u0627\u0626\3\2\2\2"+ - "\u0628\u062b\3\2\2\2\u0629\u0627\3\2\2\2\u0629\u062a\3\2\2\2\u062a\u062c"+ - "\3\2\2\2\u062b\u0629\3\2\2\2\u062c\u0630\7\t\2\2\u062d\u062f\7\7\2\2\u062e"+ - "\u062d\3\2\2\2\u062f\u0632\3\2\2\2\u0630\u062e\3\2\2\2\u0630\u0631\3\2"+ - "\2\2\u0631\u0634\3\2\2\2\u0632\u0630\3\2\2\2\u0633\u0625\3\2\2\2\u0633"+ - "\u0634\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u0639\5r:\2\u0636\u0638\7\7\2"+ - "\2\u0637\u0636\3\2\2\2\u0638\u063b\3\2\2\2\u0639\u0637\3\2\2\2\u0639\u063a"+ - "\3\2\2\2\u063a\u063c\3\2\2\2\u063b\u0639\3\2\2\2\u063c\u0640\7$\2\2\u063d"+ - "\u063f\7\7\2\2\u063e\u063d\3\2\2\2\u063f\u0642\3\2\2\2\u0640\u063e\3\2"+ - "\2\2\u0640\u0641\3\2\2\2\u0641\u0643\3\2\2\2\u0642\u0640\3\2\2\2\u0643"+ - "\u0644\5\\/\2\u0644i\3\2\2\2\u0645\u0647\5^\60\2\u0646\u0645\3\2\2\2\u0646"+ - "\u0647\3\2\2\2\u0647\u064b\3\2\2\2\u0648\u064c\5b\62\2\u0649\u064c\5d"+ - "\63\2\u064a\u064c\5f\64\2\u064b\u0648\3\2\2\2\u064b\u0649\3\2\2\2\u064b"+ - "\u064a\3\2\2\2\u064ck\3\2\2\2\u064d\u065e\5p9\2\u064e\u0650\7\7\2\2\u064f"+ - "\u064e\3\2\2\2\u0650\u0653\3\2\2\2\u0651\u064f\3\2\2\2\u0651\u0652\3\2"+ - "\2\2\u0652\u0654\3\2\2\2\u0653\u0651\3\2\2\2\u0654\u0658\7\t\2\2\u0655"+ - "\u0657\7\7\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2"+ - "\2\2\u0658\u0659\3\2\2\2\u0659\u065b\3\2\2\2\u065a\u0658\3\2\2\2\u065b"+ - "\u065d\5p9\2\u065c\u0651\3\2\2\2\u065d\u0660\3\2\2\2\u065e\u065c\3\2\2"+ - "\2\u065e\u065f\3\2\2\2\u065fm\3\2\2\2\u0660\u065e\3\2\2\2\u0661\u0665"+ - "\7\13\2\2\u0662\u0664\7\7\2\2\u0663\u0662\3\2\2\2\u0664\u0667\3\2\2\2"+ - "\u0665\u0663\3\2\2\2\u0665\u0666\3\2\2\2\u0666\u0668\3\2\2\2\u0667\u0665"+ - "\3\2\2\2\u0668\u066c\5l\67\2\u0669\u066b\7\7\2\2\u066a\u0669\3\2\2\2\u066b"+ - "\u066e\3\2\2\2\u066c\u066a\3\2\2\2\u066c\u066d\3\2\2\2\u066d\u066f\3\2"+ - "\2\2\u066e\u066c\3\2\2\2\u066f\u0670\7\f\2\2\u0670\u0682\3\2\2\2\u0671"+ - "\u0675\7\13\2\2\u0672\u0674\7\7\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3"+ - "\2\2\2\u0675\u0673\3\2\2\2\u0675\u0676\3\2\2\2\u0676\u0678\3\2\2\2\u0677"+ - "\u0675\3\2\2\2\u0678\u067c\5n8\2\u0679\u067b\7\7\2\2\u067a\u0679\3\2\2"+ - "\2\u067b\u067e\3\2\2\2\u067c\u067a\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u067f"+ - "\3\2\2\2\u067e\u067c\3\2\2\2\u067f\u0680\7\f\2\2\u0680\u0682\3\2\2\2\u0681"+ - "\u0661\3\2\2\2\u0681\u0671\3\2\2\2\u0682o\3\2\2\2\u0683\u068b\5\u013c"+ - "\u009f\2\u0684\u0686\7\7\2\2\u0685\u0684\3\2\2\2\u0686\u0689\3\2\2\2\u0687"+ - "\u0685\3\2\2\2\u0687\u0688\3\2\2\2\u0688\u068a\3\2\2\2\u0689\u0687\3\2"+ - "\2\2\u068a\u068c\5\u00b2Z\2\u068b\u0687\3\2\2\2\u068b\u068c\3\2\2\2\u068c"+ - "q\3\2\2\2\u068d\u0691\7\13\2\2\u068e\u0690\7\7\2\2\u068f\u068e\3\2\2\2"+ - "\u0690\u0693\3\2\2\2\u0691\u068f\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u0696"+ - "\3\2\2\2\u0693\u0691\3\2\2\2\u0694\u0697\5<\37\2\u0695\u0697\5\\/\2\u0696"+ - "\u0694\3\2\2\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u06ab\3\2"+ - "\2\2\u0698\u069a\7\7\2\2\u0699\u0698\3\2\2\2\u069a\u069d\3\2\2\2\u069b"+ - "\u0699\3\2\2\2\u069b\u069c\3\2\2\2\u069c\u069e\3\2\2\2\u069d\u069b\3\2"+ - "\2\2\u069e\u06a2\7\n\2\2\u069f\u06a1\7\7\2\2\u06a0\u069f\3\2\2\2\u06a1"+ - "\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a7\3\2"+ - "\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a8\5<\37\2\u06a6\u06a8\5\\/\2\u06a7"+ - "\u06a5\3\2\2\2\u06a7\u06a6\3\2\2\2\u06a8\u06aa\3\2\2\2\u06a9\u069b\3\2"+ - "\2\2\u06aa\u06ad\3\2\2\2\u06ab\u06a9\3\2\2\2\u06ab\u06ac\3\2\2\2\u06ac"+ - "\u06b1\3\2\2\2\u06ad\u06ab\3\2\2\2\u06ae\u06b0\7\7\2\2\u06af\u06ae\3\2"+ - "\2\2\u06b0\u06b3\3\2\2\2\u06b1\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2"+ - "\u06b4\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b4\u06b5\7\f\2\2\u06b5s\3\2\2\2"+ - "\u06b6\u06ba\7M\2\2\u06b7\u06b9\7\7\2\2\u06b8\u06b7\3\2\2\2\u06b9\u06bc"+ - "\3\2\2\2\u06ba\u06b8\3\2\2\2\u06ba\u06bb\3\2\2\2\u06bb\u06bd\3\2\2\2\u06bc"+ - "\u06ba\3\2\2\2\u06bd\u06ce\5v<\2\u06be\u06c0\7\7\2\2\u06bf\u06be\3\2\2"+ - "\2\u06c0\u06c3\3\2\2\2\u06c1\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c4"+ - "\3\2\2\2\u06c3\u06c1\3\2\2\2\u06c4\u06c8\7\n\2\2\u06c5\u06c7\7\7\2\2\u06c6"+ - "\u06c5\3\2\2\2\u06c7\u06ca\3\2\2\2\u06c8\u06c6\3\2\2\2\u06c8\u06c9\3\2"+ - "\2\2\u06c9\u06cb\3\2\2\2\u06ca\u06c8\3\2\2\2\u06cb\u06cd\5v<\2\u06cc\u06c1"+ - "\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2\2\2\u06ce\u06cf\3\2\2\2\u06cf"+ - "u\3\2\2\2\u06d0\u06ce\3\2\2\2\u06d1\u06d3\5\u0132\u009a\2\u06d2\u06d1"+ - "\3\2\2\2\u06d3\u06d6\3\2\2\2\u06d4\u06d2\3\2\2\2\u06d4\u06d5\3\2\2\2\u06d5"+ - "\u06d7\3\2\2\2\u06d6\u06d4\3\2\2\2\u06d7\u06db\5\u013c\u009f\2\u06d8\u06da"+ - "\7\7\2\2\u06d9\u06d8\3\2\2\2\u06da\u06dd\3\2\2\2\u06db\u06d9\3\2\2\2\u06db"+ - "\u06dc\3\2\2\2\u06dc\u06de\3\2\2\2\u06dd\u06db\3\2\2\2\u06de\u06e2\7\34"+ - "\2\2\u06df\u06e1\7\7\2\2\u06e0\u06df\3\2\2\2\u06e1\u06e4\3\2\2\2\u06e2"+ - "\u06e0\3\2\2\2\u06e2\u06e3\3\2\2\2\u06e3\u06e5\3\2\2\2\u06e4\u06e2\3\2"+ - "\2\2\u06e5\u06e6\5\\/\2\u06e6w\3\2\2\2\u06e7\u06eb\7\17\2\2\u06e8\u06ea"+ - "\7\7\2\2\u06e9\u06e8\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9\3\2\2\2\u06eb"+ - "\u06ec\3\2\2\2\u06ec\u06ee\3\2\2\2\u06ed\u06eb\3\2\2\2\u06ee\u06f2\5z"+ - ">\2\u06ef\u06f1\7\7\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2\2\2\u06f2"+ - "\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f5\3\2\2\2\u06f4\u06f2\3\2"+ - "\2\2\u06f5\u06f6\7\20\2\2\u06f6y\3\2\2\2\u06f7\u06fd\5|?\2\u06f8\u06f9"+ - "\5\u014c\u00a7\2\u06f9\u06fa\5|?\2\u06fa\u06fc\3\2\2\2\u06fb\u06f8\3\2"+ - "\2\2\u06fc\u06ff\3\2\2\2\u06fd\u06fb\3\2\2\2\u06fd\u06fe\3\2\2\2\u06fe"+ - "\u0701\3\2\2\2\u06ff\u06fd\3\2\2\2\u0700\u0702\5\u014c\u00a7\2\u0701\u0700"+ - "\3\2\2\2\u0701\u0702\3\2\2\2\u0702\u0704\3\2\2\2\u0703\u06f7\3\2\2\2\u0703"+ - "\u0704\3\2\2\2\u0704{\3\2\2\2\u0705\u0708\5\u0130\u0099\2\u0706\u0708"+ - "\5\u0132\u009a\2\u0707\u0705\3\2\2\2\u0707\u0706\3\2\2\2\u0708\u070b\3"+ - "\2\2\2\u0709\u0707\3\2\2\2\u0709\u070a\3\2\2\2\u070a\u0710\3\2\2\2\u070b"+ - "\u0709\3\2\2\2\u070c\u0711\5~@\2\u070d\u0711\5\u0080A\2\u070e\u0711\5"+ - "\u00f6|\2\u070f\u0711\5\u0082B\2\u0710\u070c\3\2\2\2\u0710\u070d\3\2\2"+ - "\2\u0710\u070e\3\2\2\2\u0710\u070f\3\2\2\2\u0711}\3\2\2\2\u0712\u0718"+ - "\5\22\n\2\u0713\u0718\5B\"\2\u0714\u0718\5\66\34\2\u0715\u0718\5F$\2\u0716"+ - "\u0718\5R*\2\u0717\u0712\3\2\2\2\u0717\u0713\3\2\2\2\u0717\u0714\3\2\2"+ - "\2\u0717\u0715\3\2\2\2\u0717\u0716\3\2\2\2\u0718\177\3\2\2\2\u0719\u071a"+ - "\5\u00a2R\2\u071a\u071e\7\36\2\2\u071b\u071d\7\7\2\2\u071c\u071b\3\2\2"+ - "\2\u071d\u0720\3\2\2\2\u071e\u071c\3\2\2\2\u071e\u071f\3\2\2\2\u071f\u0721"+ - "\3\2\2\2\u0720\u071e\3\2\2\2\u0721\u0722\5\u0082B\2\u0722\u072e\3\2\2"+ - "\2\u0723\u0724\5\u00a4S\2\u0724\u0728\5\u0102\u0082\2\u0725\u0727\7\7"+ - "\2\2\u0726\u0725\3\2\2\2\u0727\u072a\3\2\2\2\u0728\u0726\3\2\2\2\u0728"+ - "\u0729\3\2\2\2\u0729\u072b\3\2\2\2\u072a\u0728\3\2\2\2\u072b\u072c\5\u0082"+ - "B\2\u072c\u072e\3\2\2\2\u072d\u0719\3\2\2\2\u072d\u0723\3\2\2\2\u072e"+ - "\u0081\3\2\2\2\u072f\u0730\5\u0084C\2\u0730\u0083\3\2\2\2\u0731\u0742"+ - "\5\u0086D\2\u0732\u0734\7\7\2\2\u0733\u0732\3\2\2\2\u0734\u0737\3\2\2"+ - "\2\u0735\u0733\3\2\2\2\u0735\u0736\3\2\2\2\u0736\u0738\3\2\2\2\u0737\u0735"+ - "\3\2\2\2\u0738\u073c\7\31\2\2\u0739\u073b\7\7\2\2\u073a\u0739\3\2\2\2"+ - "\u073b\u073e\3\2\2\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u073f"+ - "\3\2\2\2\u073e\u073c\3\2\2\2\u073f\u0741\5\u0086D\2\u0740\u0735\3\2\2"+ - "\2\u0741\u0744\3\2\2\2\u0742\u0740\3\2\2\2\u0742\u0743\3\2\2\2\u0743\u0085"+ - "\3\2\2\2\u0744\u0742\3\2\2\2\u0745\u0756\5\u0088E\2\u0746\u0748\7\7\2"+ - "\2\u0747\u0746\3\2\2\2\u0748\u074b\3\2\2\2\u0749\u0747\3\2\2\2\u0749\u074a"+ - "\3\2\2\2\u074a\u074c\3\2\2\2\u074b\u0749\3\2\2\2\u074c\u0750\7\30\2\2"+ - "\u074d\u074f\7\7\2\2\u074e\u074d\3\2\2\2\u074f\u0752\3\2\2\2\u0750\u074e"+ - "\3\2\2\2\u0750\u0751\3\2\2\2\u0751\u0753\3\2\2\2\u0752\u0750\3\2\2\2\u0753"+ - "\u0755\5\u0088E\2\u0754\u0749\3\2\2\2\u0755\u0758\3\2\2\2\u0756\u0754"+ - "\3\2\2\2\u0756\u0757\3\2\2\2\u0757\u0087\3\2\2\2\u0758\u0756\3\2\2\2\u0759"+ - "\u0765\5\u008aF\2\u075a\u075e\5\u0104\u0083\2\u075b\u075d\7\7\2\2\u075c"+ - "\u075b\3\2\2\2\u075d\u0760\3\2\2\2\u075e\u075c\3\2\2\2\u075e\u075f\3\2"+ - "\2\2\u075f\u0761\3\2\2\2\u0760\u075e\3\2\2\2\u0761\u0762\5\u008aF\2\u0762"+ - "\u0764\3\2\2\2\u0763\u075a\3\2\2\2\u0764\u0767\3\2\2\2\u0765\u0763\3\2"+ - "\2\2\u0765\u0766\3\2\2\2\u0766\u0089\3\2\2\2\u0767\u0765\3\2\2\2\u0768"+ - "\u0772\5\u008cG\2\u0769\u076d\5\u0106\u0084\2\u076a\u076c\7\7\2\2\u076b"+ - "\u076a\3\2\2\2\u076c\u076f\3\2\2\2\u076d\u076b\3\2\2\2\u076d\u076e\3\2"+ - "\2\2\u076e\u0770\3\2\2\2\u076f\u076d\3\2\2\2\u0770\u0771\5\u008cG\2\u0771"+ - "\u0773\3\2\2\2\u0772\u0769\3\2\2\2\u0772\u0773\3\2\2\2\u0773\u008b\3\2"+ - "\2\2\u0774\u0789\5\u008eH\2\u0775\u0779\5\u0108\u0085\2\u0776\u0778\7"+ - "\7\2\2\u0777\u0776\3\2\2\2\u0778\u077b\3\2\2\2\u0779\u0777\3\2\2\2\u0779"+ - "\u077a\3\2\2\2\u077a\u077c\3\2\2\2\u077b\u0779\3\2\2\2\u077c\u077d\5\u008e"+ - "H\2\u077d\u0788\3\2\2\2\u077e\u0782\5\u010a\u0086\2\u077f\u0781\7\7\2"+ - "\2\u0780\u077f\3\2\2\2\u0781\u0784\3\2\2\2\u0782\u0780\3\2\2\2\u0782\u0783"+ - "\3\2\2\2\u0783\u0785\3\2\2\2\u0784\u0782\3\2\2\2\u0785\u0786\5\\/\2\u0786"+ - "\u0788\3\2\2\2\u0787\u0775\3\2\2\2\u0787\u077e\3\2\2\2\u0788\u078b\3\2"+ - "\2\2\u0789\u0787\3\2\2\2\u0789\u078a\3\2\2\2\u078a\u008d\3\2\2\2\u078b"+ - "\u0789\3\2\2\2\u078c\u079e\5\u0090I\2\u078d\u078f\7\7\2\2\u078e\u078d"+ - "\3\2\2\2\u078f\u0792\3\2\2\2\u0790\u078e\3\2\2\2\u0790\u0791\3\2\2\2\u0791"+ - "\u0793\3\2\2\2\u0792\u0790\3\2\2\2\u0793\u0797\5\u0144\u00a3\2\u0794\u0796"+ - "\7\7\2\2\u0795\u0794\3\2\2\2\u0796\u0799\3\2\2\2\u0797\u0795\3\2\2\2\u0797"+ - "\u0798\3\2\2\2\u0798\u079a\3\2\2\2\u0799\u0797\3\2\2\2\u079a\u079b\5\u0090"+ - "I\2\u079b\u079d\3\2\2\2\u079c\u0790\3\2\2\2\u079d\u07a0\3\2\2\2\u079e"+ - "\u079c\3\2\2\2\u079e\u079f\3\2\2\2\u079f\u008f\3\2\2\2\u07a0\u079e\3\2"+ - "\2\2\u07a1\u07ad\5\u0092J\2\u07a2\u07a6\5\u013c\u009f\2\u07a3\u07a5\7"+ - "\7\2\2\u07a4\u07a3\3\2\2\2\u07a5\u07a8\3\2\2\2\u07a6\u07a4\3\2\2\2\u07a6"+ - "\u07a7\3\2\2\2\u07a7\u07a9\3\2\2\2\u07a8\u07a6\3\2\2\2\u07a9\u07aa\5\u0092"+ - "J\2\u07aa\u07ac\3\2\2\2\u07ab\u07a2\3\2\2\2\u07ac\u07af\3\2\2\2\u07ad"+ - "\u07ab\3\2\2\2\u07ad\u07ae\3\2\2\2\u07ae\u0091\3\2\2\2\u07af\u07ad\3\2"+ - "\2\2\u07b0\u07bb\5\u0094K\2\u07b1\u07b5\7&\2\2\u07b2\u07b4\7\7\2\2\u07b3"+ - "\u07b2\3\2\2\2\u07b4\u07b7\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b5\u07b6\3\2"+ - "\2\2\u07b6\u07b8\3\2\2\2\u07b7\u07b5\3\2\2\2\u07b8\u07ba\5\u0094K\2\u07b9"+ - "\u07b1\3\2\2\2\u07ba\u07bd\3\2\2\2\u07bb\u07b9\3\2\2\2\u07bb\u07bc\3\2"+ - "\2\2\u07bc\u0093\3\2\2\2\u07bd\u07bb\3\2\2\2\u07be\u07ca\5\u0096L\2\u07bf"+ - "\u07c3\5\u010c\u0087\2\u07c0\u07c2\7\7\2\2\u07c1\u07c0\3\2\2\2\u07c2\u07c5"+ - "\3\2\2\2\u07c3\u07c1\3\2\2\2\u07c3\u07c4\3\2\2\2\u07c4\u07c6\3\2\2\2\u07c5"+ - "\u07c3\3\2\2\2\u07c6\u07c7\5\u0096L\2\u07c7\u07c9\3\2\2\2\u07c8\u07bf"+ - "\3\2\2\2\u07c9\u07cc\3\2\2\2\u07ca\u07c8\3\2\2\2\u07ca\u07cb\3\2\2\2\u07cb"+ - "\u0095\3\2\2\2\u07cc\u07ca\3\2\2\2\u07cd\u07d9\5\u0098M\2\u07ce\u07d2"+ - "\5\u010e\u0088\2\u07cf\u07d1\7\7\2\2\u07d0\u07cf\3\2\2\2\u07d1\u07d4\3"+ - "\2\2\2\u07d2\u07d0\3\2\2\2\u07d2\u07d3\3\2\2\2\u07d3\u07d5\3\2\2\2\u07d4"+ - "\u07d2\3\2\2\2\u07d5\u07d6\5\u0098M\2\u07d6\u07d8\3\2\2\2\u07d7\u07ce"+ - "\3\2\2\2\u07d8\u07db\3\2\2\2\u07d9\u07d7\3\2\2\2\u07d9\u07da\3\2\2\2\u07da"+ - "\u0097\3\2\2\2\u07db\u07d9\3\2\2\2\u07dc\u07ec\5\u009aN\2\u07dd\u07df"+ - "\7\7\2\2\u07de\u07dd\3\2\2\2\u07df\u07e2\3\2\2\2\u07e0\u07de\3\2\2\2\u07e0"+ - "\u07e1\3\2\2\2\u07e1\u07e3\3\2\2\2\u07e2\u07e0\3\2\2\2\u07e3\u07e7\5\u0110"+ - "\u0089\2\u07e4\u07e6\7\7\2\2\u07e5\u07e4\3\2\2\2\u07e6\u07e9\3\2\2\2\u07e7"+ - "\u07e5\3\2\2\2\u07e7\u07e8\3\2\2\2\u07e8\u07ea\3\2\2\2\u07e9\u07e7\3\2"+ - "\2\2\u07ea\u07eb\5\\/\2\u07eb\u07ed\3\2\2\2\u07ec\u07e0\3\2\2\2\u07ec"+ - "\u07ed\3\2\2\2\u07ed\u0099\3\2\2\2\u07ee\u07f0\5\u009cO\2\u07ef\u07ee"+ - "\3\2\2\2\u07f0\u07f3\3\2\2\2\u07f1\u07ef\3\2\2\2\u07f1\u07f2\3\2\2\2\u07f2"+ - "\u07f4\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f4\u07f5\5\u009eP\2\u07f5\u009b"+ - "\3\2\2\2\u07f6\u0800\5\u0132\u009a\2\u07f7\u0800\5\u0130\u0099\2\u07f8"+ - "\u07fc\5\u0112\u008a\2\u07f9\u07fb\7\7\2\2\u07fa\u07f9\3\2\2\2\u07fb\u07fe"+ - "\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u0800\3\2\2\2\u07fe"+ - "\u07fc\3\2\2\2\u07ff\u07f6\3\2\2\2\u07ff\u07f7\3\2\2\2\u07ff\u07f8\3\2"+ - "\2\2\u0800\u009d\3\2\2\2\u0801\u0809\5\u00bc_\2\u0802\u0804\5\u00bc_\2"+ - "\u0803\u0805\5\u00a0Q\2\u0804\u0803\3\2\2\2\u0805\u0806\3\2\2\2\u0806"+ - "\u0804\3\2\2\2\u0806\u0807\3\2\2\2\u0807\u0809\3\2\2\2\u0808\u0801\3\2"+ - "\2\2\u0808\u0802\3\2\2\2\u0809\u009f\3\2\2\2\u080a\u0810\5\u0114\u008b"+ - "\2\u080b\u0810\5\u00b2Z\2\u080c\u0810\5\u00acW\2\u080d\u0810\5\u00a8U"+ - "\2\u080e\u0810\5\u00aaV\2\u080f\u080a\3\2\2\2\u080f\u080b\3\2\2\2\u080f"+ - "\u080c\3\2\2\2\u080f\u080d\3\2\2\2\u080f\u080e\3\2\2\2\u0810\u00a1\3\2"+ - "\2\2\u0811\u0812\5\u009eP\2\u0812\u0813\5\u00a6T\2\u0813\u0816\3\2\2\2"+ - "\u0814\u0816\5\u013c\u009f\2\u0815\u0811\3\2\2\2\u0815\u0814\3\2\2\2\u0816"+ - "\u00a3\3\2\2\2\u0817\u0818\5\u009aN\2\u0818\u00a5\3\2\2\2\u0819\u081d"+ - "\5\u00b2Z\2\u081a\u081d\5\u00a8U\2\u081b\u081d\5\u00aaV\2\u081c\u0819"+ - "\3\2\2\2\u081c\u081a\3\2\2\2\u081c\u081b\3\2\2\2\u081d\u00a7\3\2\2\2\u081e"+ - "\u0822\7\r\2\2\u081f\u0821\7\7\2\2\u0820\u081f\3\2\2\2\u0821\u0824\3\2"+ - "\2\2\u0822\u0820\3\2\2\2\u0822\u0823\3\2\2\2\u0823\u0825\3\2\2\2\u0824"+ - "\u0822\3\2\2\2\u0825\u0836\5\u0082B\2\u0826\u0828\7\7\2\2\u0827\u0826"+ - "\3\2\2\2\u0828\u082b\3\2\2\2\u0829\u0827\3\2\2\2\u0829\u082a\3\2\2\2\u082a"+ - "\u082c\3\2\2\2\u082b\u0829\3\2\2\2\u082c\u0830\7\n\2\2\u082d\u082f\7\7"+ - "\2\2\u082e\u082d\3\2\2\2\u082f\u0832\3\2\2\2\u0830\u082e\3\2\2\2\u0830"+ - "\u0831\3\2\2\2\u0831\u0833\3\2\2\2\u0832\u0830\3\2\2\2\u0833\u0835\5\u0082"+ - "B\2\u0834\u0829\3\2\2\2\u0835\u0838\3\2\2\2\u0836\u0834\3\2\2\2\u0836"+ - "\u0837\3\2\2\2\u0837\u083c\3\2\2\2\u0838\u0836\3\2\2\2\u0839\u083b\7\7"+ - "\2\2\u083a\u0839\3\2\2\2\u083b\u083e\3\2\2\2\u083c\u083a\3\2\2\2\u083c"+ - "\u083d\3\2\2\2\u083d\u083f\3\2\2\2\u083e\u083c\3\2\2\2\u083f\u0840\7\16"+ - "\2\2\u0840\u00a9\3\2\2\2\u0841\u0843\7\7\2\2\u0842\u0841\3\2\2\2\u0843"+ - "\u0846\3\2\2\2\u0844\u0842\3\2\2\2\u0844\u0845\3\2\2\2\u0845\u0847\3\2"+ - "\2\2\u0846\u0844\3\2\2\2\u0847\u084b\5\u0116\u008c\2\u0848\u084a\7\7\2"+ - "\2\u0849\u0848\3\2\2\2\u084a\u084d\3\2\2\2\u084b\u0849\3\2\2\2\u084b\u084c"+ - "\3\2\2\2\u084c\u0851\3\2\2\2\u084d\u084b\3\2\2\2\u084e\u0852\5\u013c\u009f"+ - "\2\u084f\u0852\5\u00be`\2\u0850\u0852\7?\2\2\u0851\u084e\3\2\2\2\u0851"+ - "\u084f\3\2\2\2\u0851\u0850\3\2\2\2\u0852\u00ab\3\2\2\2\u0853\u0855\5\u00b2"+ - "Z\2\u0854\u0853\3\2\2\2\u0854\u0855\3\2\2\2\u0855\u0857\3\2\2\2\u0856"+ - "\u0858\5\u00b0Y\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0859"+ - "\3\2\2\2\u0859\u085f\5\u00aeX\2\u085a\u085c\5\u00b2Z\2\u085b\u085a\3\2"+ - "\2\2\u085b\u085c\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085f\5\u00b0Y\2\u085e"+ - "\u0854\3\2\2\2\u085e\u085b\3\2\2\2\u085f\u00ad\3\2\2\2\u0860\u0862\5\u0132"+ - "\u009a\2\u0861\u0860\3\2\2\2\u0862\u0865\3\2\2\2\u0863\u0861\3\2\2\2\u0863"+ - "\u0864\3\2\2\2\u0864\u0867\3\2\2\2\u0865\u0863\3\2\2\2\u0866\u0868\5\u0130"+ - "\u0099\2\u0867\u0866\3\2\2\2\u0867\u0868\3\2\2\2\u0868\u086c\3\2\2\2\u0869"+ - "\u086b\7\7\2\2\u086a\u0869\3\2\2\2\u086b\u086e\3\2\2\2\u086c\u086a\3\2"+ - "\2\2\u086c\u086d\3\2\2\2\u086d\u086f\3\2\2\2\u086e\u086c\3\2\2\2\u086f"+ - "\u0870\5\u00d2j\2\u0870\u00af\3\2\2\2\u0871\u0875\7\13\2\2\u0872\u0874"+ - "\7\7\2\2\u0873\u0872\3\2\2\2\u0874\u0877\3\2\2\2\u0875\u0873\3\2\2\2\u0875"+ - "\u0876\3\2\2\2\u0876\u0878\3\2\2\2\u0877\u0875\3\2\2\2\u0878\u089d\7\f"+ - "\2\2\u0879\u087d\7\13\2\2\u087a\u087c\7\7\2\2\u087b\u087a\3\2\2\2\u087c"+ - "\u087f\3\2\2\2\u087d\u087b\3\2\2\2\u087d\u087e\3\2\2\2\u087e\u0880\3\2"+ - "\2\2\u087f\u087d\3\2\2\2\u0880\u0891\5\u00ba^\2\u0881\u0883\7\7\2\2\u0882"+ - "\u0881\3\2\2\2\u0883\u0886\3\2\2\2\u0884\u0882\3\2\2\2\u0884\u0885"; - private static final String _serializedATNSegment1 = - "\3\2\2\2\u0885\u0887\3\2\2\2\u0886\u0884\3\2\2\2\u0887\u088b\7\n\2\2\u0888"+ - "\u088a\7\7\2\2\u0889\u0888\3\2\2\2\u088a\u088d\3\2\2\2\u088b\u0889\3\2"+ - "\2\2\u088b\u088c\3\2\2\2\u088c\u088e\3\2\2\2\u088d\u088b\3\2\2\2\u088e"+ - "\u0890\5\u00ba^\2\u088f\u0884\3\2\2\2\u0890\u0893\3\2\2\2\u0891\u088f"+ - "\3\2\2\2\u0891\u0892\3\2\2\2\u0892\u0897\3\2\2\2\u0893\u0891\3\2\2\2\u0894"+ - "\u0896\7\7\2\2\u0895\u0894\3\2\2\2\u0896\u0899\3\2\2\2\u0897\u0895\3\2"+ - "\2\2\u0897\u0898\3\2\2\2\u0898\u089a\3\2\2\2\u0899\u0897\3\2\2\2\u089a"+ - "\u089b\7\f\2\2\u089b\u089d\3\2\2\2\u089c\u0871\3\2\2\2\u089c\u0879\3\2"+ - "\2\2\u089d\u00b1\3\2\2\2\u089e\u08a2\7.\2\2\u089f\u08a1\7\7\2\2\u08a0"+ - "\u089f\3\2\2\2\u08a1\u08a4\3\2\2\2\u08a2\u08a0\3\2\2\2\u08a2\u08a3\3\2"+ - "\2\2\u08a3\u08a5\3\2\2\2\u08a4\u08a2\3\2\2\2\u08a5\u08b6\5\u00b4[\2\u08a6"+ - "\u08a8\7\7\2\2\u08a7\u08a6\3\2\2\2\u08a8\u08ab\3\2\2\2\u08a9\u08a7\3\2"+ - "\2\2\u08a9\u08aa\3\2\2\2\u08aa\u08ac\3\2\2\2\u08ab\u08a9\3\2\2\2\u08ac"+ - "\u08b0\7\n\2\2\u08ad\u08af\7\7\2\2\u08ae\u08ad\3\2\2\2\u08af\u08b2\3\2"+ - "\2\2\u08b0\u08ae\3\2\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08b3\3\2\2\2\u08b2"+ - "\u08b0\3\2\2\2\u08b3\u08b5\5\u00b4[\2\u08b4\u08a9\3\2\2\2\u08b5\u08b8"+ - "\3\2\2\2\u08b6\u08b4\3\2\2\2\u08b6\u08b7\3\2\2\2\u08b7\u08bc\3\2\2\2\u08b8"+ - "\u08b6\3\2\2\2\u08b9\u08bb\7\7\2\2\u08ba\u08b9\3\2\2\2\u08bb\u08be\3\2"+ - "\2\2\u08bc\u08ba\3\2\2\2\u08bc\u08bd\3\2\2\2\u08bd\u08bf\3\2\2\2\u08be"+ - "\u08bc\3\2\2\2\u08bf\u08c0\7/\2\2\u08c0\u00b3\3\2\2\2\u08c1\u08c3\5\u00b6"+ - "\\\2\u08c2\u08c1\3\2\2\2\u08c2\u08c3\3\2\2\2\u08c3\u08c4\3\2\2\2\u08c4"+ - "\u08c7\5\\/\2\u08c5\u08c7\7\21\2\2\u08c6\u08c2\3\2\2\2\u08c6\u08c5\3\2"+ - "\2\2\u08c7\u00b5\3\2\2\2\u08c8\u08ca\5\u00b8]\2\u08c9\u08c8\3\2\2\2\u08ca"+ - "\u08cb\3\2\2\2\u08cb\u08c9\3\2\2\2\u08cb\u08cc\3\2\2\2\u08cc\u00b7\3\2"+ - "\2\2\u08cd\u08d1\5\u0122\u0092\2\u08ce\u08d0\7\7\2\2\u08cf\u08ce\3\2\2"+ - "\2\u08d0\u08d3\3\2\2\2\u08d1\u08cf\3\2\2\2\u08d1\u08d2\3\2\2\2\u08d2\u08d6"+ - "\3\2\2\2\u08d3\u08d1\3\2\2\2\u08d4\u08d6\5\u0132\u009a\2\u08d5\u08cd\3"+ - "\2\2\2\u08d5\u08d4\3\2\2\2\u08d6\u00b9\3\2\2\2\u08d7\u08d9\5\u0132\u009a"+ - "\2\u08d8\u08d7\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9\u08dd\3\2\2\2\u08da\u08dc"+ - "\7\7\2\2\u08db\u08da\3\2\2\2\u08dc\u08df\3\2\2\2\u08dd\u08db\3\2\2\2\u08dd"+ - "\u08de\3\2\2\2\u08de\u08ee\3\2\2\2\u08df\u08dd\3\2\2\2\u08e0\u08e4\5\u013c"+ - "\u009f\2\u08e1\u08e3\7\7\2\2\u08e2\u08e1\3\2\2\2\u08e3\u08e6\3\2\2\2\u08e4"+ - "\u08e2\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5\u08e7\3\2\2\2\u08e6\u08e4\3\2"+ - "\2\2\u08e7\u08eb\7\36\2\2\u08e8\u08ea\7\7\2\2\u08e9\u08e8\3\2\2\2\u08ea"+ - "\u08ed\3\2\2\2\u08eb\u08e9\3\2\2\2\u08eb\u08ec\3\2\2\2\u08ec\u08ef\3\2"+ - "\2\2\u08ed\u08eb\3\2\2\2\u08ee\u08e0\3\2\2\2\u08ee\u08ef\3\2\2\2\u08ef"+ - "\u08f1\3\2\2\2\u08f0\u08f2\7\21\2\2\u08f1\u08f0\3\2\2\2\u08f1\u08f2\3"+ - "\2\2\2\u08f2\u08f6\3\2\2\2\u08f3\u08f5\7\7\2\2\u08f4\u08f3\3\2\2\2\u08f5"+ - "\u08f8\3\2\2\2\u08f6\u08f4\3\2\2\2\u08f6\u08f7\3\2\2\2\u08f7\u08f9\3\2"+ - "\2\2\u08f8\u08f6\3\2\2\2\u08f9\u08fa\5\u0082B\2\u08fa\u00bb\3\2\2\2\u08fb"+ - "\u090a\5\u00be`\2\u08fc\u090a\5\u00c2b\2\u08fd\u090a\5\u00c4c\2\u08fe"+ - "\u090a\5\u013c\u009f\2\u08ff\u090a\5\u0100\u0081\2\u0900\u090a\5\u00da"+ - "n\2\u0901\u090a\5\u00dco\2\u0902\u090a\5\u00c0a\2\u0903\u090a\5\u00de"+ - "p\2\u0904\u090a\5\u00e0q\2\u0905\u090a\5\u00e4s\2\u0906\u090a\5\u00e6"+ - "t\2\u0907\u090a\5\u00f0y\2\u0908\u090a\5\u00fe\u0080\2\u0909\u08fb\3\2"+ - "\2\2\u0909\u08fc\3\2\2\2\u0909\u08fd\3\2\2\2\u0909\u08fe\3\2\2\2\u0909"+ - "\u08ff\3\2\2\2\u0909\u0900\3\2\2\2\u0909\u0901\3\2\2\2\u0909\u0902\3\2"+ - "\2\2\u0909\u0903\3\2\2\2\u0909\u0904\3\2\2\2\u0909\u0905\3\2\2\2\u0909"+ - "\u0906\3\2\2\2\u0909\u0907\3\2\2\2\u0909\u0908\3\2\2\2\u090a\u00bd\3\2"+ - "\2\2\u090b\u090f\7\13\2\2\u090c\u090e\7\7\2\2\u090d\u090c\3\2\2\2\u090e"+ - "\u0911\3\2\2\2\u090f\u090d\3\2\2\2\u090f\u0910\3\2\2\2\u0910\u0912\3\2"+ - "\2\2\u0911\u090f\3\2\2\2\u0912\u0916\5\u0082B\2\u0913\u0915\7\7\2\2\u0914"+ - "\u0913\3\2\2\2\u0915\u0918\3\2\2\2\u0916\u0914\3\2\2\2\u0916\u0917\3\2"+ - "\2\2\u0917\u0919\3\2\2\2\u0918\u0916\3\2\2\2\u0919\u091a\7\f\2\2\u091a"+ - "\u00bf\3\2\2\2\u091b\u091f\7\r\2\2\u091c\u091e\7\7\2\2\u091d\u091c\3\2"+ - "\2\2\u091e\u0921\3\2\2\2\u091f\u091d\3\2\2\2\u091f\u0920\3\2\2\2\u0920"+ - "\u0922\3\2\2\2\u0921\u091f\3\2\2\2\u0922\u0933\5\u0082B\2\u0923\u0925"+ - "\7\7\2\2\u0924\u0923\3\2\2\2\u0925\u0928\3\2\2\2\u0926\u0924\3\2\2\2\u0926"+ - "\u0927\3\2\2\2\u0927\u0929\3\2\2\2\u0928\u0926\3\2\2\2\u0929\u092d\7\n"+ - "\2\2\u092a\u092c\7\7\2\2\u092b\u092a\3\2\2\2\u092c\u092f\3\2\2\2\u092d"+ - "\u092b\3\2\2\2\u092d\u092e\3\2\2\2\u092e\u0930\3\2\2\2\u092f\u092d\3\2"+ - "\2\2\u0930\u0932\5\u0082B\2\u0931\u0926\3\2\2\2\u0932\u0935\3\2\2\2\u0933"+ - "\u0931\3\2\2\2\u0933\u0934\3\2\2\2\u0934\u0939\3\2\2\2\u0935\u0933\3\2"+ - "\2\2\u0936\u0938\7\7\2\2\u0937\u0936\3\2\2\2\u0938\u093b\3\2\2\2\u0939"+ - "\u0937\3\2\2\2\u0939\u093a\3\2\2\2\u093a\u093c\3\2\2\2\u093b\u0939\3\2"+ - "\2\2\u093c\u093d\7\16\2\2\u093d\u0947\3\2\2\2\u093e\u0942\7\r\2\2\u093f"+ - "\u0941\7\7\2\2\u0940\u093f\3\2\2\2\u0941\u0944\3\2\2\2\u0942\u0940\3\2"+ - "\2\2\u0942\u0943\3\2\2\2\u0943\u0945\3\2\2\2\u0944\u0942\3\2\2\2\u0945"+ - "\u0947\7\16\2\2\u0946\u091b\3\2\2\2\u0946\u093e\3\2\2\2\u0947\u00c1\3"+ - "\2\2\2\u0948\u0949\t\4\2\2\u0949\u00c3\3\2\2\2\u094a\u094d\5\u00c6d\2"+ - "\u094b\u094d\5\u00c8e\2\u094c\u094a\3\2\2\2\u094c\u094b\3\2\2\2\u094d"+ - "\u00c5\3\2\2\2\u094e\u0953\7\u0088\2\2\u094f\u0952\5\u00caf\2\u0950\u0952"+ - "\5\u00ccg\2\u0951\u094f\3\2\2\2\u0951\u0950\3\2\2\2\u0952\u0955\3\2\2"+ - "\2\u0953\u0951\3\2\2\2\u0953\u0954\3\2\2\2\u0954\u0956\3\2\2\2\u0955\u0953"+ - "\3\2\2\2\u0956\u0957\7\u00a2\2\2\u0957\u00c7\3\2\2\2\u0958\u095e\7\u0089"+ - "\2\2\u0959\u095d\5\u00ceh\2\u095a\u095d\5\u00d0i\2\u095b\u095d\7\u00a8"+ - "\2\2\u095c\u0959\3\2\2\2\u095c\u095a\3\2\2\2\u095c\u095b\3\2\2\2\u095d"+ - "\u0960\3\2\2\2\u095e\u095c\3\2\2\2\u095e\u095f\3\2\2\2\u095f\u0961\3\2"+ - "\2\2\u0960\u095e\3\2\2\2\u0961\u0962\7\u00a7\2\2\u0962\u00c9\3\2\2\2\u0963"+ - "\u0964\t\5\2\2\u0964\u00cb\3\2\2\2\u0965\u0966\7\u00a6\2\2\u0966\u0967"+ - "\5\u0082B\2\u0967\u0968\7\20\2\2\u0968\u00cd\3\2\2\2\u0969\u096a\t\6\2"+ - "\2\u096a\u00cf\3\2\2\2\u096b\u096f\7\u00ab\2\2\u096c\u096e\7\7\2\2\u096d"+ - "\u096c\3\2\2\2\u096e\u0971\3\2\2\2\u096f\u096d\3\2\2\2\u096f\u0970\3\2"+ - "\2\2\u0970\u0972\3\2\2\2\u0971\u096f\3\2\2\2\u0972\u0976\5\u0082B\2\u0973"+ - "\u0975\7\7\2\2\u0974\u0973\3\2\2\2\u0975\u0978\3\2\2\2\u0976\u0974\3\2"+ - "\2\2\u0976\u0977\3\2\2\2\u0977\u0979\3\2\2\2\u0978\u0976\3\2\2\2\u0979"+ - "\u097a\7\20\2\2\u097a\u00d1\3\2\2\2\u097b\u097f\7\17\2\2\u097c\u097e\7"+ - "\7\2\2\u097d\u097c\3\2\2\2\u097e\u0981\3\2\2\2\u097f\u097d\3\2\2\2\u097f"+ - "\u0980\3\2\2\2\u0980\u0982\3\2\2\2\u0981\u097f\3\2\2\2\u0982\u0986\5z"+ - ">\2\u0983\u0985\7\7\2\2\u0984\u0983\3\2\2\2\u0985\u0988\3\2\2\2\u0986"+ - "\u0984\3\2\2\2\u0986\u0987\3\2\2\2\u0987\u0989\3\2\2\2\u0988\u0986\3\2"+ - "\2\2\u0989\u098a\7\20\2\2\u098a\u09ac\3\2\2\2\u098b\u098f\7\17\2\2\u098c"+ - "\u098e\7\7\2\2\u098d\u098c\3\2\2\2\u098e\u0991\3\2\2\2\u098f\u098d\3\2"+ - "\2\2\u098f\u0990\3\2\2\2\u0990\u0993\3\2\2\2\u0991\u098f\3\2\2\2\u0992"+ - "\u0994\5\u00d4k\2\u0993\u0992\3\2\2\2\u0993\u0994\3\2\2\2\u0994\u0998"+ - "\3\2\2\2\u0995\u0997\7\7\2\2\u0996\u0995\3\2\2\2\u0997\u099a\3\2\2\2\u0998"+ - "\u0996\3\2\2\2\u0998\u0999\3\2\2\2\u0999\u099b\3\2\2\2\u099a\u0998\3\2"+ - "\2\2\u099b\u099f\7$\2\2\u099c\u099e\7\7\2\2\u099d\u099c\3\2\2\2\u099e"+ - "\u09a1\3\2\2\2\u099f\u099d\3\2\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a2\3\2"+ - "\2\2\u09a1\u099f\3\2\2\2\u09a2\u09a6\5z>\2\u09a3\u09a5\7\7\2\2\u09a4\u09a3"+ - "\3\2\2\2\u09a5\u09a8\3\2\2\2\u09a6\u09a4\3\2\2\2\u09a6\u09a7\3\2\2\2\u09a7"+ - "\u09a9\3\2\2\2\u09a8\u09a6\3\2\2\2\u09a9\u09aa\7\20\2\2\u09aa\u09ac\3"+ - "\2\2\2\u09ab\u097b\3\2\2\2\u09ab\u098b\3\2\2\2\u09ac\u00d3\3\2\2\2\u09ad"+ - "\u09be\5\u00d6l\2\u09ae\u09b0\7\7\2\2\u09af\u09ae\3\2\2\2\u09b0\u09b3"+ - "\3\2\2\2\u09b1\u09af\3\2\2\2\u09b1\u09b2\3\2\2\2\u09b2\u09b4\3\2\2\2\u09b3"+ - "\u09b1\3\2\2\2\u09b4\u09b8\7\n\2\2\u09b5\u09b7\7\7\2\2\u09b6\u09b5\3\2"+ - "\2\2\u09b7\u09ba\3\2\2\2\u09b8\u09b6\3\2\2\2\u09b8\u09b9\3\2\2\2\u09b9"+ - "\u09bb\3\2\2\2\u09ba\u09b8\3\2\2\2\u09bb\u09bd\5\u00d6l\2\u09bc\u09b1"+ - "\3\2\2\2\u09bd\u09c0\3\2\2\2\u09be\u09bc\3\2\2\2\u09be\u09bf\3\2\2\2\u09bf"+ - "\u00d5\3\2\2\2\u09c0\u09be\3\2\2\2\u09c1\u09d4\5J&\2\u09c2\u09d1\5H%\2"+ - "\u09c3\u09c5\7\7\2\2\u09c4\u09c3\3\2\2\2\u09c5\u09c8\3\2\2\2\u09c6\u09c4"+ - "\3\2\2\2\u09c6\u09c7\3\2\2\2\u09c7\u09c9\3\2\2\2\u09c8\u09c6\3\2\2\2\u09c9"+ - "\u09cd\7\34\2\2\u09ca\u09cc\7\7\2\2\u09cb\u09ca\3\2\2\2\u09cc\u09cf\3"+ - "\2\2\2\u09cd\u09cb\3\2\2\2\u09cd\u09ce\3\2\2\2\u09ce\u09d0\3\2\2\2\u09cf"+ - "\u09cd\3\2\2\2\u09d0\u09d2\5\\/\2\u09d1\u09c6\3\2\2\2\u09d1\u09d2\3\2"+ - "\2\2\u09d2\u09d4\3\2\2\2\u09d3\u09c1\3\2\2\2\u09d3\u09c2\3\2\2\2\u09d4"+ - "\u00d7\3\2\2\2\u09d5\u09e5\7A\2\2\u09d6\u09d8\7\7\2\2\u09d7\u09d6\3\2"+ - "\2\2\u09d8\u09db\3\2\2\2\u09d9\u09d7\3\2\2\2\u09d9\u09da\3\2\2\2\u09da"+ - "\u09dc\3\2\2\2\u09db\u09d9\3\2\2\2\u09dc\u09e0\5\\/\2\u09dd\u09df\7\7"+ - "\2\2\u09de\u09dd\3\2\2\2\u09df\u09e2\3\2\2\2\u09e0\u09de\3\2\2\2\u09e0"+ - "\u09e1\3\2\2\2\u09e1\u09e3\3\2\2\2\u09e2\u09e0\3\2\2\2\u09e3\u09e4\7\t"+ - "\2\2\u09e4\u09e6\3\2\2\2\u09e5\u09d9\3\2\2\2\u09e5\u09e6\3\2\2\2\u09e6"+ - "\u09ea\3\2\2\2\u09e7\u09e9\7\7\2\2\u09e8\u09e7\3\2\2\2\u09e9\u09ec\3\2"+ - "\2\2\u09ea\u09e8\3\2\2\2\u09ea\u09eb\3\2\2\2\u09eb\u09ed\3\2\2\2\u09ec"+ - "\u09ea\3\2\2\2\u09ed\u09fc\58\35\2\u09ee\u09f0\7\7\2\2\u09ef\u09ee\3\2"+ - "\2\2\u09f0\u09f3\3\2\2\2\u09f1\u09ef\3\2\2\2\u09f1\u09f2\3\2\2\2\u09f2"+ - "\u09f4\3\2\2\2\u09f3\u09f1\3\2\2\2\u09f4\u09f8\7\34\2\2\u09f5\u09f7\7"+ - "\7\2\2\u09f6\u09f5\3\2\2\2\u09f7\u09fa\3\2\2\2\u09f8\u09f6\3\2\2\2\u09f8"+ - "\u09f9\3\2\2\2\u09f9\u09fb\3\2\2\2\u09fa\u09f8\3\2\2\2\u09fb\u09fd\5\\"+ - "/\2\u09fc\u09f1\3\2\2\2\u09fc\u09fd\3\2\2\2\u09fd\u0a05\3\2\2\2\u09fe"+ - "\u0a00\7\7\2\2\u09ff\u09fe\3\2\2\2\u0a00\u0a03\3\2\2\2\u0a01\u09ff\3\2"+ - "\2\2\u0a01\u0a02\3\2\2\2\u0a02\u0a04\3\2\2\2\u0a03\u0a01\3\2\2\2\u0a04"+ - "\u0a06\5t;\2\u0a05\u0a01\3\2\2\2\u0a05\u0a06\3\2\2\2\u0a06\u0a0e\3\2\2"+ - "\2\u0a07\u0a09\7\7\2\2\u0a08\u0a07\3\2\2\2\u0a09\u0a0c\3\2\2\2\u0a0a\u0a08"+ - "\3\2\2\2\u0a0a\u0a0b\3\2\2\2\u0a0b\u0a0d\3\2\2\2\u0a0c\u0a0a\3\2\2\2\u0a0d"+ - "\u0a0f\5@!\2\u0a0e\u0a0a\3\2\2\2\u0a0e\u0a0f\3\2\2\2\u0a0f\u00d9\3\2\2"+ - "\2\u0a10\u0a13\5\u00d2j\2\u0a11\u0a13\5\u00d8m\2\u0a12\u0a10\3\2\2\2\u0a12"+ - "\u0a11\3\2\2\2\u0a13\u00db\3\2\2\2\u0a14\u0a18\7B\2\2\u0a15\u0a17\7\7"+ - "\2\2\u0a16\u0a15\3\2\2\2\u0a17\u0a1a\3\2\2\2\u0a18\u0a16\3\2\2\2\u0a18"+ - "\u0a19\3\2\2\2\u0a19\u0a1b\3\2\2\2\u0a1a\u0a18\3\2\2\2\u0a1b\u0a1f\7\34"+ - "\2\2\u0a1c\u0a1e\7\7\2\2\u0a1d\u0a1c\3\2\2\2\u0a1e\u0a21\3\2\2\2\u0a1f"+ - "\u0a1d\3\2\2\2\u0a1f\u0a20\3\2\2\2\u0a20\u0a22\3\2\2\2\u0a21\u0a1f\3\2"+ - "\2\2\u0a22\u0a2a\5\32\16\2\u0a23\u0a25\7\7\2\2\u0a24\u0a23\3\2\2\2\u0a25"+ - "\u0a28\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a26\u0a27\3\2\2\2\u0a27\u0a29\3\2"+ - "\2\2\u0a28\u0a26\3\2\2\2\u0a29\u0a2b\5$\23\2\u0a2a\u0a26\3\2\2\2\u0a2a"+ - "\u0a2b\3\2\2\2\u0a2b\u0a35\3\2\2\2\u0a2c\u0a30\7B\2\2\u0a2d\u0a2f\7\7"+ - "\2\2\u0a2e\u0a2d\3\2\2\2\u0a2f\u0a32\3\2\2\2\u0a30\u0a2e\3\2\2\2\u0a30"+ - "\u0a31\3\2\2\2\u0a31\u0a33\3\2\2\2\u0a32\u0a30\3\2\2\2\u0a33\u0a35\5$"+ - "\23\2\u0a34\u0a14\3\2\2\2\u0a34\u0a2c\3\2\2\2\u0a35\u00dd\3\2\2\2\u0a36"+ - "\u0a37\t\7\2\2\u0a37\u00df\3\2\2\2\u0a38\u0a49\7K\2\2\u0a39\u0a3d\7.\2"+ - "\2\u0a3a\u0a3c\7\7\2\2\u0a3b\u0a3a\3\2\2\2\u0a3c\u0a3f\3\2\2\2\u0a3d\u0a3b"+ - "\3\2\2\2\u0a3d\u0a3e\3\2\2\2\u0a3e\u0a40\3\2\2\2\u0a3f\u0a3d\3\2\2\2\u0a40"+ - "\u0a44\5\\/\2\u0a41\u0a43\7\7\2\2\u0a42\u0a41\3\2\2\2\u0a43\u0a46\3\2"+ - "\2\2\u0a44\u0a42\3\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a47\3\2\2\2\u0a46"+ - "\u0a44\3\2\2\2\u0a47\u0a48\7/\2\2\u0a48\u0a4a\3\2\2\2\u0a49\u0a39\3\2"+ - "\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a4d\3\2\2\2\u0a4b\u0a4c\7*\2\2\u0a4c"+ - "\u0a4e\5\u013c\u009f\2\u0a4d\u0a4b\3\2\2\2\u0a4d\u0a4e\3\2\2\2\u0a4e\u0a51"+ - "\3\2\2\2\u0a4f\u0a51\7<\2\2\u0a50\u0a38\3\2\2\2\u0a50\u0a4f\3\2\2\2\u0a51"+ - "\u00e1\3\2\2\2\u0a52\u0a55\5x=\2\u0a53\u0a55\5|?\2\u0a54\u0a52\3\2\2\2"+ - "\u0a54\u0a53\3\2\2\2\u0a55\u00e3\3\2\2\2\u0a56\u0a5a\7N\2\2\u0a57\u0a59"+ - "\7\7\2\2\u0a58\u0a57\3\2\2\2\u0a59\u0a5c\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5a"+ - "\u0a5b\3\2\2\2\u0a5b\u0a5d\3\2\2\2\u0a5c\u0a5a\3\2\2\2\u0a5d\u0a61\7\13"+ - "\2\2\u0a5e\u0a60\7\7\2\2\u0a5f\u0a5e\3\2\2\2\u0a60\u0a63\3\2\2\2\u0a61"+ - "\u0a5f\3\2\2\2\u0a61\u0a62\3\2\2\2\u0a62\u0a64\3\2\2\2\u0a63\u0a61\3\2"+ - "\2\2\u0a64\u0a68\5\u0082B\2\u0a65\u0a67\7\7\2\2\u0a66\u0a65\3\2\2\2\u0a67"+ - "\u0a6a\3\2\2\2\u0a68\u0a66\3\2\2\2\u0a68\u0a69\3\2\2\2\u0a69\u0a6b\3\2"+ - "\2\2\u0a6a\u0a68\3\2\2\2\u0a6b\u0a6f\7\f\2\2\u0a6c\u0a6e\7\7\2\2\u0a6d"+ - "\u0a6c\3\2\2\2\u0a6e\u0a71\3\2\2\2\u0a6f\u0a6d\3\2\2\2\u0a6f\u0a70\3\2"+ - "\2\2\u0a70\u0a72\3\2\2\2\u0a71\u0a6f\3\2\2\2\u0a72\u0a84\5\u00e2r\2\u0a73"+ - "\u0a75\7\35\2\2\u0a74\u0a73\3\2\2\2\u0a74\u0a75\3\2\2\2\u0a75\u0a79\3"+ - "\2\2\2\u0a76\u0a78\7\7\2\2\u0a77\u0a76\3\2\2\2\u0a78\u0a7b\3\2\2\2\u0a79"+ - "\u0a77\3\2\2\2\u0a79\u0a7a\3\2\2\2\u0a7a\u0a7c\3\2\2\2\u0a7b\u0a79\3\2"+ - "\2\2\u0a7c\u0a80\7O\2\2\u0a7d\u0a7f\7\7\2\2\u0a7e\u0a7d\3\2\2\2\u0a7f"+ - "\u0a82\3\2\2\2\u0a80\u0a7e\3\2\2\2\u0a80\u0a81\3\2\2\2\u0a81\u0a83\3\2"+ - "\2\2\u0a82\u0a80\3\2\2\2\u0a83\u0a85\5\u00e2r\2\u0a84\u0a74\3\2\2\2\u0a84"+ - "\u0a85\3\2\2\2\u0a85\u0ab5\3\2\2\2\u0a86\u0a8a\7N\2\2\u0a87\u0a89\7\7"+ - "\2\2\u0a88\u0a87\3\2\2\2\u0a89\u0a8c\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8a"+ - "\u0a8b\3\2\2\2\u0a8b\u0a8d\3\2\2\2\u0a8c\u0a8a\3\2\2\2\u0a8d\u0a91\7\13"+ - "\2\2\u0a8e\u0a90\7\7\2\2\u0a8f\u0a8e\3\2\2\2\u0a90\u0a93\3\2\2\2\u0a91"+ - "\u0a8f\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a94\3\2\2\2\u0a93\u0a91\3\2"+ - "\2\2\u0a94\u0a98\5\u0082B\2\u0a95\u0a97\7\7\2\2\u0a96\u0a95\3\2\2\2\u0a97"+ - "\u0a9a\3\2\2\2\u0a98\u0a96\3\2\2\2\u0a98\u0a99\3\2\2\2\u0a99\u0a9b\3\2"+ - "\2\2\u0a9a\u0a98\3\2\2\2\u0a9b\u0a9f\7\f\2\2\u0a9c\u0a9e\7\7\2\2\u0a9d"+ - "\u0a9c\3\2\2\2\u0a9e\u0aa1\3\2\2\2\u0a9f\u0a9d\3\2\2\2\u0a9f\u0aa0\3\2"+ - "\2\2\u0aa0\u0aa9\3\2\2\2\u0aa1\u0a9f\3\2\2\2\u0aa2\u0aa6\7\35\2\2\u0aa3"+ - "\u0aa5\7\7\2\2\u0aa4\u0aa3\3\2\2\2\u0aa5\u0aa8\3\2\2\2\u0aa6\u0aa4\3\2"+ - "\2\2\u0aa6\u0aa7\3\2\2\2\u0aa7\u0aaa\3\2\2\2\u0aa8\u0aa6\3\2\2\2\u0aa9"+ - "\u0aa2\3\2\2\2\u0aa9\u0aaa\3\2\2\2\u0aaa\u0aab\3\2\2\2\u0aab\u0aaf\7O"+ - "\2\2\u0aac\u0aae\7\7\2\2\u0aad\u0aac\3\2\2\2\u0aae\u0ab1\3\2\2\2\u0aaf"+ - "\u0aad\3\2\2\2\u0aaf\u0ab0\3\2\2\2\u0ab0\u0ab2\3\2\2\2\u0ab1\u0aaf\3\2"+ - "\2\2\u0ab2\u0ab3\5\u00e2r\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0a56\3\2\2\2\u0ab4"+ - "\u0a86\3\2\2\2\u0ab5\u00e5\3\2\2\2\u0ab6\u0aba\7P\2\2\u0ab7\u0ab9\7\7"+ - "\2\2\u0ab8\u0ab7\3\2\2\2\u0ab9\u0abc\3\2\2\2\u0aba\u0ab8\3\2\2\2\u0aba"+ - "\u0abb\3\2\2\2\u0abb\u0ac1\3\2\2\2\u0abc\u0aba\3\2\2\2\u0abd\u0abe\7\13"+ - "\2\2\u0abe\u0abf\5\u0082B\2\u0abf\u0ac0\7\f\2\2\u0ac0\u0ac2\3\2\2\2\u0ac1"+ - "\u0abd\3\2\2\2\u0ac1\u0ac2\3\2\2\2\u0ac2\u0ac6\3\2\2\2\u0ac3\u0ac5\7\7"+ - "\2\2\u0ac4\u0ac3\3\2\2\2\u0ac5\u0ac8\3\2\2\2\u0ac6\u0ac4\3\2\2\2\u0ac6"+ - "\u0ac7\3\2\2\2\u0ac7\u0ac9\3\2\2\2\u0ac8\u0ac6\3\2\2\2\u0ac9\u0acd\7\17"+ - "\2\2\u0aca\u0acc\7\7\2\2\u0acb\u0aca\3\2\2\2\u0acc\u0acf\3\2\2\2\u0acd"+ - "\u0acb\3\2\2\2\u0acd\u0ace\3\2\2\2\u0ace\u0ad9\3\2\2\2\u0acf\u0acd\3\2"+ - "\2\2\u0ad0\u0ad4\5\u00e8u\2\u0ad1\u0ad3\7\7\2\2\u0ad2\u0ad1\3\2\2\2\u0ad3"+ - "\u0ad6\3\2\2\2\u0ad4\u0ad2\3\2\2\2\u0ad4\u0ad5\3\2\2\2\u0ad5\u0ad8\3\2"+ - "\2\2\u0ad6\u0ad4\3\2\2\2\u0ad7\u0ad0\3\2\2\2\u0ad8\u0adb\3\2\2\2\u0ad9"+ - "\u0ad7\3\2\2\2\u0ad9\u0ada\3\2\2\2\u0ada\u0adf\3\2\2\2\u0adb\u0ad9\3\2"+ - "\2\2\u0adc\u0ade\7\7\2\2\u0add\u0adc\3\2\2\2\u0ade\u0ae1\3\2\2\2\u0adf"+ - "\u0add\3\2\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u0ae2\3\2\2\2\u0ae1\u0adf\3\2"+ - "\2\2\u0ae2\u0ae3\7\20\2\2\u0ae3\u00e7\3\2\2\2\u0ae4\u0af5\5\u00eav\2\u0ae5"+ - "\u0ae7\7\7\2\2\u0ae6\u0ae5\3\2\2\2\u0ae7\u0aea\3\2\2\2\u0ae8\u0ae6\3\2"+ - "\2\2\u0ae8\u0ae9\3\2\2\2\u0ae9\u0aeb\3\2\2\2\u0aea\u0ae8\3\2\2\2\u0aeb"+ - "\u0aef\7\n\2\2\u0aec\u0aee\7\7\2\2\u0aed\u0aec\3\2\2\2\u0aee\u0af1\3\2"+ - "\2\2\u0aef\u0aed\3\2\2\2\u0aef\u0af0\3\2\2\2\u0af0\u0af2\3\2\2\2\u0af1"+ - "\u0aef\3\2\2\2\u0af2\u0af4\5\u00eav\2\u0af3\u0ae8\3\2\2\2\u0af4\u0af7"+ - "\3\2\2\2\u0af5\u0af3\3\2\2\2\u0af5\u0af6\3\2\2\2\u0af6\u0afb\3\2\2\2\u0af7"+ - "\u0af5\3\2\2\2\u0af8\u0afa\7\7\2\2\u0af9\u0af8\3\2\2\2\u0afa\u0afd\3\2"+ - "\2\2\u0afb\u0af9\3\2\2\2\u0afb\u0afc\3\2\2\2\u0afc\u0afe\3\2\2\2\u0afd"+ - "\u0afb\3\2\2\2\u0afe\u0b02\7$\2\2\u0aff\u0b01\7\7\2\2\u0b00\u0aff\3\2"+ - "\2\2\u0b01\u0b04\3\2\2\2\u0b02\u0b00\3\2\2\2\u0b02\u0b03\3\2\2\2\u0b03"+ - "\u0b05\3\2\2\2\u0b04\u0b02\3\2\2\2\u0b05\u0b07\5\u00e2r\2\u0b06\u0b08"+ - "\5\u014a\u00a6\2\u0b07\u0b06\3\2\2\2\u0b07\u0b08\3\2\2\2\u0b08\u0b1c\3"+ - "\2\2\2\u0b09\u0b0d\7O\2\2\u0b0a\u0b0c\7\7\2\2\u0b0b\u0b0a\3\2\2\2\u0b0c"+ - "\u0b0f\3\2\2\2\u0b0d\u0b0b\3\2\2\2\u0b0d\u0b0e\3\2\2\2\u0b0e\u0b10\3\2"+ - "\2\2\u0b0f\u0b0d\3\2\2\2\u0b10\u0b14\7$\2\2\u0b11\u0b13\7\7\2\2\u0b12"+ - "\u0b11\3\2\2\2\u0b13\u0b16\3\2\2\2\u0b14\u0b12\3\2\2\2\u0b14\u0b15\3\2"+ - "\2\2\u0b15\u0b17\3\2\2\2\u0b16\u0b14\3\2\2\2\u0b17\u0b19\5\u00e2r\2\u0b18"+ - "\u0b1a\5\u014a\u00a6\2\u0b19\u0b18\3\2\2\2\u0b19\u0b1a\3\2\2\2\u0b1a\u0b1c"+ - "\3\2\2\2\u0b1b\u0ae4\3\2\2\2\u0b1b\u0b09\3\2\2\2\u0b1c\u00e9\3\2\2\2\u0b1d"+ - "\u0b21\5\u0082B\2\u0b1e\u0b21\5\u00ecw\2\u0b1f\u0b21\5\u00eex\2\u0b20"+ - "\u0b1d\3\2\2\2\u0b20\u0b1e\3\2\2\2\u0b20\u0b1f\3\2\2\2\u0b21\u00eb\3\2"+ - "\2\2\u0b22\u0b26\5\u0108\u0085\2\u0b23\u0b25\7\7\2\2\u0b24\u0b23\3\2\2"+ - "\2\u0b25\u0b28\3\2\2\2\u0b26\u0b24\3\2\2\2\u0b26\u0b27\3\2\2\2\u0b27\u0b29"+ - "\3\2\2\2\u0b28\u0b26\3\2\2\2\u0b29\u0b2a\5\u0082B\2\u0b2a\u00ed\3\2\2"+ - "\2\u0b2b\u0b2f\5\u010a\u0086\2\u0b2c\u0b2e\7\7\2\2\u0b2d\u0b2c\3\2\2\2"+ - "\u0b2e\u0b31\3\2\2\2\u0b2f\u0b2d\3\2\2\2\u0b2f\u0b30\3\2\2\2\u0b30\u0b32"+ - "\3\2\2\2\u0b31\u0b2f\3\2\2\2\u0b32\u0b33\5\\/\2\u0b33\u00ef\3\2\2\2\u0b34"+ - "\u0b38\7Q\2\2\u0b35\u0b37\7\7\2\2\u0b36\u0b35\3\2\2\2\u0b37\u0b3a\3\2"+ - "\2\2\u0b38\u0b36\3\2\2\2\u0b38\u0b39\3\2\2\2\u0b39\u0b3b\3\2\2\2\u0b3a"+ - "\u0b38\3\2\2\2\u0b3b\u0b57\5x=\2\u0b3c\u0b3e\7\7\2\2\u0b3d\u0b3c\3\2\2"+ - "\2\u0b3e\u0b41\3\2\2\2\u0b3f\u0b3d\3\2\2\2\u0b3f\u0b40\3\2\2\2\u0b40\u0b42"+ - "\3\2\2\2\u0b41\u0b3f\3\2\2\2\u0b42\u0b44\5\u00f2z\2\u0b43\u0b3f\3\2\2"+ - "\2\u0b44\u0b45\3\2\2\2\u0b45\u0b43\3\2\2\2\u0b45\u0b46\3\2\2\2\u0b46\u0b4e"+ - "\3\2\2\2\u0b47\u0b49\7\7\2\2\u0b48\u0b47\3\2\2\2\u0b49\u0b4c\3\2\2\2\u0b4a"+ - "\u0b48\3\2\2\2\u0b4a\u0b4b\3\2\2\2\u0b4b\u0b4d\3\2\2\2\u0b4c\u0b4a\3\2"+ - "\2\2\u0b4d\u0b4f\5\u00f4{\2\u0b4e\u0b4a\3\2\2\2\u0b4e\u0b4f\3\2\2\2\u0b4f"+ - "\u0b58\3\2\2\2\u0b50\u0b52\7\7\2\2\u0b51\u0b50\3\2\2\2\u0b52\u0b55\3\2"+ - "\2\2\u0b53\u0b51\3\2\2\2\u0b53\u0b54\3\2\2\2\u0b54\u0b56\3\2\2\2\u0b55"+ - "\u0b53\3\2\2\2\u0b56\u0b58\5\u00f4{\2\u0b57\u0b43\3\2\2\2\u0b57\u0b53"+ - "\3\2\2\2\u0b58\u00f1\3\2\2\2\u0b59\u0b5d\7R\2\2\u0b5a\u0b5c\7\7\2\2\u0b5b"+ - "\u0b5a\3\2\2\2\u0b5c\u0b5f\3\2\2\2\u0b5d\u0b5b\3\2\2\2\u0b5d\u0b5e\3\2"+ - "\2\2\u0b5e\u0b60\3\2\2\2\u0b5f\u0b5d\3\2\2\2\u0b60\u0b64\7\13\2\2\u0b61"+ - "\u0b63\5\u0132\u009a\2\u0b62\u0b61\3\2\2\2\u0b63\u0b66\3\2\2\2\u0b64\u0b62"+ - "\3\2\2\2\u0b64\u0b65\3\2\2\2\u0b65\u0b67\3\2\2\2\u0b66\u0b64\3\2\2\2\u0b67"+ - "\u0b68\5\u013c\u009f\2\u0b68\u0b69\7\34\2\2\u0b69\u0b6a\5l\67\2\u0b6a"+ - "\u0b6e\7\f\2\2\u0b6b\u0b6d\7\7\2\2\u0b6c\u0b6b\3\2\2\2\u0b6d\u0b70\3\2"+ - "\2\2\u0b6e\u0b6c\3\2\2\2\u0b6e\u0b6f\3\2\2\2\u0b6f\u0b71\3\2\2\2\u0b70"+ - "\u0b6e\3\2\2\2\u0b71\u0b72\5x=\2\u0b72\u00f3\3\2\2\2\u0b73\u0b77\7S\2"+ - "\2\u0b74\u0b76\7\7\2\2\u0b75\u0b74\3\2\2\2\u0b76\u0b79\3\2\2\2\u0b77\u0b75"+ - "\3\2\2\2\u0b77\u0b78\3\2\2\2\u0b78\u0b7a\3\2\2\2\u0b79\u0b77\3\2\2\2\u0b7a"+ - "\u0b7b\5x=\2\u0b7b\u00f5\3\2\2\2\u0b7c\u0b80\5\u00f8}\2\u0b7d\u0b80\5"+ - "\u00fa~\2\u0b7e\u0b80\5\u00fc\177\2\u0b7f\u0b7c\3\2\2\2\u0b7f\u0b7d\3"+ - "\2\2\2\u0b7f\u0b7e\3\2\2\2\u0b80\u00f7\3\2\2\2\u0b81\u0b85\7T\2\2\u0b82"+ - "\u0b84\7\7\2\2\u0b83\u0b82\3\2\2\2\u0b84\u0b87\3\2\2\2\u0b85\u0b83\3\2"+ - "\2\2\u0b85\u0b86\3\2\2\2\u0b86\u0b88\3\2\2\2\u0b87\u0b85\3\2\2\2\u0b88"+ - "\u0b8c\7\13\2\2\u0b89\u0b8b\5\u0132\u009a\2\u0b8a\u0b89\3\2\2\2\u0b8b"+ - "\u0b8e\3\2\2\2\u0b8c\u0b8a\3\2\2\2\u0b8c\u0b8d\3\2\2\2\u0b8d\u0b91\3\2"+ - "\2\2\u0b8e\u0b8c\3\2\2\2\u0b8f\u0b92\5J&\2\u0b90\u0b92\5H%\2\u0b91\u0b8f"+ - "\3\2\2\2\u0b91\u0b90\3\2\2\2\u0b92\u0b93\3\2\2\2\u0b93\u0b94\7]\2\2\u0b94"+ - "\u0b95\5\u0082B\2\u0b95\u0b99\7\f\2\2\u0b96\u0b98\7\7\2\2\u0b97\u0b96"+ - "\3\2\2\2\u0b98\u0b9b\3\2\2\2\u0b99\u0b97\3\2\2\2\u0b99\u0b9a\3\2\2\2\u0b9a"+ - "\u0b9d\3\2\2\2\u0b9b\u0b99\3\2\2\2\u0b9c\u0b9e\5\u00e2r\2\u0b9d\u0b9c"+ - "\3\2\2\2\u0b9d\u0b9e\3\2\2\2\u0b9e\u00f9\3\2\2\2\u0b9f\u0ba3\7V\2\2\u0ba0"+ - "\u0ba2\7\7\2\2\u0ba1\u0ba0\3\2\2\2\u0ba2\u0ba5\3\2\2\2\u0ba3\u0ba1\3\2"+ - "\2\2\u0ba3\u0ba4\3\2\2\2\u0ba4\u0ba6\3\2\2\2\u0ba5\u0ba3\3\2\2\2\u0ba6"+ - "\u0ba7\7\13\2\2\u0ba7\u0ba8\5\u0082B\2\u0ba8\u0bac\7\f\2\2\u0ba9\u0bab"+ - "\7\7\2\2\u0baa\u0ba9\3\2\2\2\u0bab\u0bae\3\2\2\2\u0bac\u0baa\3\2\2\2\u0bac"+ - "\u0bad\3\2\2\2\u0bad\u0baf\3\2\2\2\u0bae\u0bac\3\2\2\2\u0baf\u0bb0\5\u00e2"+ - "r\2\u0bb0\u0bc4\3\2\2\2\u0bb1\u0bb5\7V\2\2\u0bb2\u0bb4\7\7\2\2\u0bb3\u0bb2"+ - "\3\2\2\2\u0bb4\u0bb7\3\2\2\2\u0bb5\u0bb3\3\2\2\2\u0bb5\u0bb6\3\2\2\2\u0bb6"+ - "\u0bb8\3\2\2\2\u0bb7\u0bb5\3\2\2\2\u0bb8\u0bb9\7\13\2\2\u0bb9\u0bba\5"+ - "\u0082B\2\u0bba\u0bbe\7\f\2\2\u0bbb\u0bbd\7\7\2\2\u0bbc\u0bbb\3\2\2\2"+ - "\u0bbd\u0bc0\3\2\2\2\u0bbe\u0bbc\3\2\2\2\u0bbe\u0bbf\3\2\2\2\u0bbf\u0bc1"+ - "\3\2\2\2\u0bc0\u0bbe\3\2\2\2\u0bc1\u0bc2\7\35\2\2\u0bc2\u0bc4\3\2\2\2"+ - "\u0bc3\u0b9f\3\2\2\2\u0bc3\u0bb1\3\2\2\2\u0bc4\u00fb\3\2\2\2\u0bc5\u0bc9"+ - "\7U\2\2\u0bc6\u0bc8\7\7\2\2\u0bc7\u0bc6\3\2\2\2\u0bc8\u0bcb\3\2\2\2\u0bc9"+ - "\u0bc7\3\2\2\2\u0bc9\u0bca\3\2\2\2\u0bca\u0bcd\3\2\2\2\u0bcb\u0bc9\3\2"+ - "\2\2\u0bcc\u0bce\5\u00e2r\2\u0bcd\u0bcc\3\2\2\2\u0bcd\u0bce\3\2\2\2\u0bce"+ - "\u0bd2\3\2\2\2\u0bcf\u0bd1\7\7\2\2\u0bd0\u0bcf\3\2\2\2\u0bd1\u0bd4\3\2"+ - "\2\2\u0bd2\u0bd0\3\2\2\2\u0bd2\u0bd3\3\2\2\2\u0bd3\u0bd5\3\2\2\2\u0bd4"+ - "\u0bd2\3\2\2\2\u0bd5\u0bd9\7V\2\2\u0bd6\u0bd8\7\7\2\2\u0bd7\u0bd6\3\2"+ - "\2\2\u0bd8\u0bdb\3\2\2\2\u0bd9\u0bd7\3\2\2\2\u0bd9\u0bda\3\2\2\2\u0bda"+ - "\u0bdc\3\2\2\2\u0bdb\u0bd9\3\2\2\2\u0bdc\u0bdd\7\13\2\2\u0bdd\u0bde\5"+ - "\u0082B\2\u0bde\u0bdf\7\f\2\2\u0bdf\u00fd\3\2\2\2\u0be0\u0be4\7W\2\2\u0be1"+ - "\u0be3\7\7\2\2\u0be2\u0be1\3\2\2\2\u0be3\u0be6\3\2\2\2\u0be4\u0be2\3\2"+ - "\2\2\u0be4\u0be5\3\2\2\2\u0be5\u0be7\3\2\2\2\u0be6\u0be4\3\2\2\2\u0be7"+ - "\u0bf1\5\u0082B\2\u0be8\u0bea\t\b\2\2\u0be9\u0beb\5\u0082B\2\u0bea\u0be9"+ - "\3\2\2\2\u0bea\u0beb\3\2\2\2\u0beb\u0bf1\3\2\2\2\u0bec\u0bf1\7Y\2\2\u0bed"+ - "\u0bf1\79\2\2\u0bee\u0bf1\7Z\2\2\u0bef\u0bf1\7:\2\2\u0bf0\u0be0\3\2\2"+ - "\2\u0bf0\u0be8\3\2\2\2\u0bf0\u0bec\3\2\2\2\u0bf0\u0bed\3\2\2\2\u0bf0\u0bee"+ - "\3\2\2\2\u0bf0\u0bef\3\2\2\2\u0bf1\u00ff\3\2\2\2\u0bf2\u0bf4\5j\66\2\u0bf3"+ - "\u0bf2\3\2\2\2\u0bf3\u0bf4\3\2\2\2\u0bf4\u0bf8\3\2\2\2\u0bf5\u0bf7\7\7"+ - "\2\2\u0bf6\u0bf5\3\2\2\2\u0bf7\u0bfa\3\2\2\2\u0bf8\u0bf6\3\2\2\2\u0bf8"+ - "\u0bf9\3\2\2\2\u0bf9\u0bfb\3\2\2\2\u0bfa\u0bf8\3\2\2\2\u0bfb\u0bff\7\'"+ - "\2\2\u0bfc\u0bfe\7\7\2\2\u0bfd\u0bfc\3\2\2\2\u0bfe\u0c01\3\2\2\2\u0bff"+ - "\u0bfd\3\2\2\2\u0bff\u0c00\3\2\2\2\u0c00\u0c04\3\2\2\2\u0c01\u0bff\3\2"+ - "\2\2\u0c02\u0c05\5\u013c\u009f\2\u0c03\u0c05\7?\2\2\u0c04\u0c02\3\2\2"+ - "\2\u0c04\u0c03\3\2\2\2\u0c05\u0101\3\2\2\2\u0c06\u0c07\t\t\2\2\u0c07\u0103"+ - "\3\2\2\2\u0c08\u0c09\t\n\2\2\u0c09\u0105\3\2\2\2\u0c0a\u0c0b\t\13\2\2"+ - "\u0c0b\u0107\3\2\2\2\u0c0c\u0c0d\t\f\2\2\u0c0d\u0109\3\2\2\2\u0c0e\u0c0f"+ - "\t\r\2\2\u0c0f\u010b\3\2\2\2\u0c10\u0c11\t\16\2\2\u0c11\u010d\3\2\2\2"+ - "\u0c12\u0c13\t\17\2\2\u0c13\u010f\3\2\2\2\u0c14\u0c15\t\20\2\2\u0c15\u0111"+ - "\3\2\2\2\u0c16\u0c1c\7\26\2\2\u0c17\u0c1c\7\27\2\2\u0c18\u0c1c\7\25\2"+ - "\2\u0c19\u0c1c\7\24\2\2\u0c1a\u0c1c\5\u0148\u00a5\2\u0c1b\u0c16\3\2\2"+ - "\2\u0c1b\u0c17\3\2\2\2\u0c1b\u0c18\3\2\2\2\u0c1b\u0c19\3\2\2\2\u0c1b\u0c1a"+ - "\3\2\2\2\u0c1c\u0113\3\2\2\2\u0c1d\u0c22\7\26\2\2\u0c1e\u0c22\7\27\2\2"+ - "\u0c1f\u0c20\7\33\2\2\u0c20\u0c22\5\u0148\u00a5\2\u0c21\u0c1d\3\2\2\2"+ - "\u0c21\u0c1e\3\2\2\2\u0c21\u0c1f\3\2\2\2\u0c22\u0115\3\2\2\2\u0c23\u0c27"+ - "\7\t\2\2\u0c24\u0c27\5\u0146\u00a4\2\u0c25\u0c27\7\'\2\2\u0c26\u0c23\3"+ - "\2\2\2\u0c26\u0c24\3\2\2\2\u0c26\u0c25\3\2\2\2\u0c27\u0117\3\2\2\2\u0c28"+ - "\u0c2b\5\u0132\u009a\2\u0c29\u0c2b\5\u011a\u008e\2\u0c2a\u0c28\3\2\2\2"+ - "\u0c2a\u0c29\3\2\2\2\u0c2b\u0c2c\3\2\2\2\u0c2c\u0c2a\3\2\2\2\u0c2c\u0c2d"+ - "\3\2\2\2\u0c2d\u0119\3\2\2\2\u0c2e\u0c37\5\u011c\u008f\2\u0c2f\u0c37\5"+ - "\u011e\u0090\2\u0c30\u0c37\5\u0120\u0091\2\u0c31\u0c37\5\u0124\u0093\2"+ - "\u0c32\u0c37\5\u0126\u0094\2\u0c33\u0c37\5\u0128\u0095\2\u0c34\u0c37\5"+ - "\u012a\u0096\2\u0c35\u0c37\5\u012e\u0098\2\u0c36\u0c2e\3\2\2\2\u0c36\u0c2f"+ - "\3\2\2\2\u0c36\u0c30\3\2\2\2\u0c36\u0c31\3\2\2\2\u0c36\u0c32\3\2\2\2\u0c36"+ - "\u0c33\3\2\2\2\u0c36\u0c34\3\2\2\2\u0c36\u0c35\3\2\2\2\u0c37\u0c3b\3\2"+ - "\2\2\u0c38\u0c3a\7\7\2\2\u0c39\u0c38\3\2\2\2\u0c3a\u0c3d\3\2\2\2\u0c3b"+ - "\u0c39\3\2\2\2\u0c3b\u0c3c\3\2\2\2\u0c3c\u011b\3\2\2\2\u0c3d\u0c3b\3\2"+ - "\2\2\u0c3e\u0c3f\t\21\2\2\u0c3f\u011d\3\2\2\2\u0c40\u0c41\t\22\2\2\u0c41"+ - "\u011f\3\2\2\2\u0c42\u0c43\t\23\2\2\u0c43\u0121\3\2\2\2\u0c44\u0c45\t"+ - "\24\2\2\u0c45\u0123\3\2\2\2\u0c46\u0c47\t\25\2\2\u0c47\u0125\3\2\2\2\u0c48"+ - "\u0c49\7\u0080\2\2\u0c49\u0127\3\2\2\2\u0c4a\u0c4b\t\26\2\2\u0c4b\u0129"+ - "\3\2\2\2\u0c4c\u0c4d\t\27\2\2\u0c4d\u012b\3\2\2\2\u0c4e\u0c4f\7\u0085"+ - "\2\2\u0c4f\u012d\3\2\2\2\u0c50\u0c51\t\30\2\2\u0c51\u012f\3\2\2\2\u0c52"+ - "\u0c56\7\u0094\2\2\u0c53\u0c55\7\7\2\2\u0c54\u0c53\3\2\2\2\u0c55\u0c58"+ - "\3\2\2\2\u0c56\u0c54\3\2\2\2\u0c56\u0c57\3\2\2\2\u0c57\u0131\3\2\2\2\u0c58"+ - "\u0c56\3\2\2\2\u0c59\u0c5c\5\u0134\u009b\2\u0c5a\u0c5c\5\u0136\u009c\2"+ - "\u0c5b\u0c59\3\2\2\2\u0c5b\u0c5a\3\2\2\2\u0c5c\u0c60\3\2\2\2\u0c5d\u0c5f"+ - "\7\7\2\2\u0c5e\u0c5d\3\2\2\2\u0c5f\u0c62\3\2\2\2\u0c60\u0c5e\3\2\2\2\u0c60"+ - "\u0c61\3\2\2\2\u0c61\u0133\3\2\2\2\u0c62\u0c60\3\2\2\2\u0c63\u0c67\5\u0138"+ - "\u009d\2\u0c64\u0c66\7\7\2\2\u0c65\u0c64\3\2\2\2\u0c66\u0c69\3\2\2\2\u0c67"+ - "\u0c65\3\2\2\2\u0c67\u0c68\3\2\2\2\u0c68\u0c6a\3\2\2\2\u0c69\u0c67\3\2"+ - "\2\2\u0c6a\u0c6e\7\34\2\2\u0c6b\u0c6d\7\7\2\2\u0c6c\u0c6b\3\2\2\2\u0c6d"+ - "\u0c70\3\2\2\2\u0c6e\u0c6c\3\2\2\2\u0c6e\u0c6f\3\2\2\2\u0c6f\u0c71\3\2"+ - "\2\2\u0c70\u0c6e\3\2\2\2\u0c71\u0c72\5\u013a\u009e\2\u0c72\u0c76\3\2\2"+ - "\2\u0c73\u0c74\7*\2\2\u0c74\u0c76\5\u013a\u009e\2\u0c75\u0c63\3\2\2\2"+ - "\u0c75\u0c73\3\2\2\2\u0c76\u0135\3\2\2\2\u0c77\u0c7b\5\u0138\u009d\2\u0c78"+ - "\u0c7a\7\7\2\2\u0c79\u0c78\3\2\2\2\u0c7a\u0c7d\3\2\2\2\u0c7b\u0c79\3\2"+ - "\2\2\u0c7b\u0c7c\3\2\2\2\u0c7c\u0c7e\3\2\2\2\u0c7d\u0c7b\3\2\2\2\u0c7e"+ - "\u0c82\7\34\2\2\u0c7f\u0c81\7\7\2\2\u0c80\u0c7f\3\2\2\2\u0c81\u0c84\3"+ - "\2\2\2\u0c82\u0c80\3\2\2\2\u0c82\u0c83\3\2\2\2\u0c83\u0c85\3\2\2\2\u0c84"+ - "\u0c82\3\2\2\2\u0c85\u0c87\7\r\2\2\u0c86\u0c88\5\u013a\u009e\2\u0c87\u0c86"+ - "\3\2\2\2\u0c88\u0c89\3\2\2\2\u0c89\u0c87\3\2\2\2\u0c89\u0c8a\3\2\2\2\u0c8a"+ - "\u0c8b\3\2\2\2\u0c8b\u0c8c\7\16\2\2\u0c8c\u0c97\3\2\2\2\u0c8d\u0c8e\7"+ - "*\2\2\u0c8e\u0c90\7\r\2\2\u0c8f\u0c91\5\u013a\u009e\2\u0c90\u0c8f\3\2"+ - "\2\2\u0c91\u0c92\3\2\2\2\u0c92\u0c90\3\2\2\2\u0c92\u0c93\3\2\2\2\u0c93"+ - "\u0c94\3\2\2\2\u0c94\u0c95\7\16\2\2\u0c95\u0c97\3\2\2\2\u0c96\u0c77\3"+ - "\2\2\2\u0c96\u0c8d\3\2\2\2\u0c97\u0137\3\2\2\2\u0c98\u0c99\t\31\2\2\u0c99"+ - "\u0139\3\2\2\2\u0c9a\u0c9d\5 \21\2\u0c9b\u0c9d\5l\67\2\u0c9c\u0c9a\3\2"+ - "\2\2\u0c9c\u0c9b\3\2\2\2\u0c9d\u013b\3\2\2\2\u0c9e\u0c9f\t\32\2\2\u0c9f"+ - "\u013d\3\2\2\2\u0ca0\u0cab\5\u013c\u009f\2\u0ca1\u0ca3\7\7\2\2\u0ca2\u0ca1"+ - "\3\2\2\2\u0ca3\u0ca6\3\2\2\2\u0ca4\u0ca2\3\2\2\2\u0ca4\u0ca5\3\2\2\2\u0ca5"+ - "\u0ca7\3\2\2\2\u0ca6\u0ca4\3\2\2\2\u0ca7\u0ca8\7\t\2\2\u0ca8\u0caa\5\u013c"+ - "\u009f\2\u0ca9\u0ca4\3\2\2\2\u0caa\u0cad\3\2\2\2\u0cab\u0ca9\3\2\2\2\u0cab"+ - "\u0cac\3\2\2\2\u0cac\u013f\3\2\2\2\u0cad\u0cab\3\2\2\2\u0cae\u0cb0\7\3"+ - "\2\2\u0caf\u0cb1\7\7\2\2\u0cb0\u0caf\3\2\2\2\u0cb1\u0cb2\3\2\2\2\u0cb2"+ - "\u0cb0\3\2\2\2\u0cb2\u0cb3\3\2\2\2\u0cb3\u0141\3\2\2\2\u0cb4\u0cb5\t\33"+ - "\2\2\u0cb5\u0143\3\2\2\2\u0cb6\u0cb7\7-\2\2\u0cb7\u0cb8\7\34\2\2\u0cb8"+ - "\u0145\3\2\2\2\u0cb9\u0cba\7-\2\2\u0cba\u0cbb\7\t\2\2\u0cbb\u0147\3\2"+ - "\2\2\u0cbc\u0cbd\t\34\2\2\u0cbd\u0149\3\2\2\2\u0cbe\u0cc2\t\35\2\2\u0cbf"+ - "\u0cc1\7\7\2\2\u0cc0\u0cbf\3\2\2\2\u0cc1\u0cc4\3\2\2\2\u0cc2\u0cc0\3\2"+ - "\2\2\u0cc2\u0cc3\3\2\2\2\u0cc3\u0cc7\3\2\2\2\u0cc4\u0cc2\3\2\2\2\u0cc5"+ - "\u0cc7\7\2\2\3\u0cc6\u0cbe\3\2\2\2\u0cc6\u0cc5\3\2\2\2\u0cc7\u014b\3\2"+ - "\2\2\u0cc8\u0cca\t\35\2\2\u0cc9\u0cc8\3\2\2\2\u0cca\u0ccb\3\2\2\2\u0ccb"+ - "\u0cc9\3\2\2\2\u0ccb\u0ccc\3\2\2\2\u0ccc\u0ccf\3\2\2\2\u0ccd\u0ccf\7\2"+ - "\2\3\u0cce\u0cc9\3\2\2\2\u0cce\u0ccd\3\2\2\2\u0ccf\u014d\3\2\2\2\u01f1"+ - "\u014f\u0154\u015a\u0162\u0168\u016d\u0173\u017d\u0186\u018d\u0194\u0199"+ - "\u019e\u01a4\u01a6\u01ab\u01b3\u01b6\u01bd\u01c0\u01c6\u01cd\u01d1\u01d6"+ - "\u01da\u01df\u01e6\u01ea\u01ef\u01f3\u01f8\u01ff\u0203\u0206\u020c\u020f"+ - "\u0217\u021e\u0225\u022b\u022e\u0233\u0239\u023c\u0241\u0249\u0250\u0257"+ - "\u025b\u0261\u0268\u026e\u0274\u027a\u0283\u028a\u028f\u0296\u029f\u02a6"+ - "\u02ad\u02b1\u02b8\u02be\u02c4\u02ca\u02d1\u02d8\u02dc\u02e1\u02e5\u02eb"+ - "\u02f3\u02f7\u02fd\u0301\u0306\u030d\u0311\u0316\u031f\u0326\u032c\u0332"+ - "\u0336\u033c\u033f\u0345\u0349\u034e\u0352\u0355\u035b\u035f\u0364\u036b"+ - "\u0370\u0375\u037c\u0383\u038a\u038e\u0393\u0397\u039c\u03a0\u03a6\u03ad"+ - "\u03b4\u03ba\u03bd\u03c2\u03c8\u03ce\u03d5\u03d9\u03df\u03e6\u03ef\u03f6"+ - "\u03fa\u0401\u0405\u0408\u040e\u0415\u041c\u0420\u0425\u0429\u042c\u0432"+ - "\u0439\u043d\u0442\u0449\u044d\u0452\u0456\u0459\u045f\u0463\u0468\u046f"+ - "\u0474\u0479\u047e\u0483\u0487\u048c\u0493\u0498\u049a\u049f\u04a2\u04a7"+ - "\u04ab\u04b0\u04b4\u04b7\u04ba\u04bf\u04c3\u04c6\u04c8\u04ce\u04d5\u04dc"+ - "\u04e2\u04e8\u04f0\u04f6\u04fd\u0504\u0508\u050e\u0514\u0518\u051e\u0525"+ - "\u052c\u0533\u0537\u053c\u0540\u0543\u0547\u054d\u0553\u0555\u055d\u0564"+ - "\u0568\u056d\u0572\u0575\u057b\u0582\u0586\u058b\u0592\u059b\u05a2\u05a9"+ - "\u05af\u05b5\u05bb\u05c0\u05c7\u05ce\u05d2\u05d7\u05dd\u05e4\u05e8\u05eb"+ - "\u05f1\u05f6\u05fd\u0600\u0606\u060d\u0614\u0619\u061f\u0623\u0629\u0630"+ - "\u0633\u0639\u0640\u0646\u064b\u0651\u0658\u065e\u0665\u066c\u0675\u067c"+ - "\u0681\u0687\u068b\u0691\u0696\u069b\u06a2\u06a7\u06ab\u06b1\u06ba\u06c1"+ - "\u06c8\u06ce\u06d4\u06db\u06e2\u06eb\u06f2\u06fd\u0701\u0703\u0707\u0709"+ - "\u0710\u0717\u071e\u0728\u072d\u0735\u073c\u0742\u0749\u0750\u0756\u075e"+ - "\u0765\u076d\u0772\u0779\u0782\u0787\u0789\u0790\u0797\u079e\u07a6\u07ad"+ - "\u07b5\u07bb\u07c3\u07ca\u07d2\u07d9\u07e0\u07e7\u07ec\u07f1\u07fc\u07ff"+ - "\u0806\u0808\u080f\u0815\u081c\u0822\u0829\u0830\u0836\u083c\u0844\u084b"+ - "\u0851\u0854\u0857\u085b\u085e\u0863\u0867\u086c\u0875\u087d\u0884\u088b"+ - "\u0891\u0897\u089c\u08a2\u08a9\u08b0\u08b6\u08bc\u08c2\u08c6\u08cb\u08d1"+ - "\u08d5\u08d8\u08dd\u08e4\u08eb\u08ee\u08f1\u08f6\u0909\u090f\u0916\u091f"+ - "\u0926\u092d\u0933\u0939\u0942\u0946\u094c\u0951\u0953\u095c\u095e\u096f"+ - "\u0976\u097f\u0986\u098f\u0993\u0998\u099f\u09a6\u09ab\u09b1\u09b8\u09be"+ - "\u09c6\u09cd\u09d1\u09d3\u09d9\u09e0\u09e5\u09ea\u09f1\u09f8\u09fc\u0a01"+ - "\u0a05\u0a0a\u0a0e\u0a12\u0a18\u0a1f\u0a26\u0a2a\u0a30\u0a34\u0a3d\u0a44"+ - "\u0a49\u0a4d\u0a50\u0a54\u0a5a\u0a61\u0a68\u0a6f\u0a74\u0a79\u0a80\u0a84"+ - "\u0a8a\u0a91\u0a98\u0a9f\u0aa6\u0aa9\u0aaf\u0ab4\u0aba\u0ac1\u0ac6\u0acd"+ - "\u0ad4\u0ad9\u0adf\u0ae8\u0aef\u0af5\u0afb\u0b02\u0b07\u0b0d\u0b14\u0b19"+ - "\u0b1b\u0b20\u0b26\u0b2f\u0b38\u0b3f\u0b45\u0b4a\u0b4e\u0b53\u0b57\u0b5d"+ - "\u0b64\u0b6e\u0b77\u0b7f\u0b85\u0b8c\u0b91\u0b99\u0b9d\u0ba3\u0bac\u0bb5"+ - "\u0bbe\u0bc3\u0bc9\u0bcd\u0bd2\u0bd9\u0be4\u0bea\u0bf0\u0bf3\u0bf8\u0bff"+ - "\u0c04\u0c1b\u0c21\u0c26\u0c2a\u0c2c\u0c36\u0c3b\u0c56\u0c5b\u0c60\u0c67"+ - "\u0c6e\u0c75\u0c7b\u0c82\u0c89\u0c92\u0c96\u0c9c\u0ca4\u0cab\u0cb2\u0cc2"+ - "\u0cc6\u0ccb\u0cce"; - public static final String _serializedATN = Utils.join( - new String[] { - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.tokens b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.tokens deleted file mode 100644 index abcc63e..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParser.tokens +++ /dev/null @@ -1,289 +0,0 @@ -ShebangLine=1 -DelimitedComment=2 -LineComment=3 -WS=4 -NL=5 -RESERVED=6 -DOT=7 -COMMA=8 -LPAREN=9 -RPAREN=10 -LSQUARE=11 -RSQUARE=12 -LCURL=13 -RCURL=14 -MULT=15 -MOD=16 -DIV=17 -ADD=18 -SUB=19 -INCR=20 -DECR=21 -CONJ=22 -DISJ=23 -EXCL_WS=24 -EXCL_NO_WS=25 -COLON=26 -SEMICOLON=27 -ASSIGNMENT=28 -ADD_ASSIGNMENT=29 -SUB_ASSIGNMENT=30 -MULT_ASSIGNMENT=31 -DIV_ASSIGNMENT=32 -MOD_ASSIGNMENT=33 -ARROW=34 -DOUBLE_ARROW=35 -RANGE=36 -COLONCOLON=37 -DOUBLE_SEMICOLON=38 -HASH=39 -AT=40 -AT_WS=41 -QUEST_WS=42 -QUEST_NO_WS=43 -LANGLE=44 -RANGLE=45 -LE=46 -GE=47 -EXCL_EQ=48 -EXCL_EQEQ=49 -AS_SAFE=50 -EQEQ=51 -EQEQEQ=52 -SINGLE_QUOTE=53 -RETURN_AT=54 -CONTINUE_AT=55 -BREAK_AT=56 -THIS_AT=57 -SUPER_AT=58 -PACKAGE=59 -IMPORT=60 -CLASS=61 -INTERFACE=62 -FUN=63 -OBJECT=64 -VAL=65 -VAR=66 -TYPE_ALIAS=67 -CONSTRUCTOR=68 -BY=69 -COMPANION=70 -INIT=71 -THIS=72 -SUPER=73 -TYPEOF=74 -WHERE=75 -IF=76 -ELSE=77 -WHEN=78 -TRY=79 -CATCH=80 -FINALLY=81 -FOR=82 -DO=83 -WHILE=84 -THROW=85 -RETURN=86 -CONTINUE=87 -BREAK=88 -AS=89 -IS=90 -IN=91 -NOT_IS=92 -NOT_IN=93 -OUT=94 -GETTER=95 -SETTER=96 -DYNAMIC=97 -AT_FILE=98 -AT_FIELD=99 -AT_PROPERTY=100 -AT_GET=101 -AT_SET=102 -AT_RECEIVER=103 -AT_PARAM=104 -AT_SETPARAM=105 -AT_DELEGATE=106 -PUBLIC=107 -PRIVATE=108 -PROTECTED=109 -INTERNAL=110 -ENUM=111 -SEALED=112 -ANNOTATION=113 -DATA=114 -INNER=115 -TAILREC=116 -OPERATOR=117 -INLINE=118 -INFIX=119 -EXTERNAL=120 -SUSPEND=121 -OVERRIDE=122 -ABSTRACT=123 -FINAL=124 -OPEN=125 -CONST=126 -LATEINIT=127 -VARARG=128 -NOINLINE=129 -CROSSINLINE=130 -REIFIED=131 -EXPECT=132 -ACTUAL=133 -QUOTE_OPEN=134 -TRIPLE_QUOTE_OPEN=135 -RealLiteral=136 -FloatLiteral=137 -DoubleLiteral=138 -LongLiteral=139 -IntegerLiteral=140 -HexLiteral=141 -BinLiteral=142 -BooleanLiteral=143 -NullLiteral=144 -Identifier=145 -IdentifierAt=146 -FieldIdentifier=147 -CharacterLiteral=148 -ErrorCharacter=149 -UNICODE_CLASS_LL=150 -UNICODE_CLASS_LM=151 -UNICODE_CLASS_LO=152 -UNICODE_CLASS_LT=153 -UNICODE_CLASS_LU=154 -UNICODE_CLASS_ND=155 -UNICODE_CLASS_NL=156 -Inside_Comment=157 -Inside_WS=158 -Inside_NL=159 -QUOTE_CLOSE=160 -LineStrRef=161 -LineStrText=162 -LineStrEscapedChar=163 -LineStrExprStart=164 -TRIPLE_QUOTE_CLOSE=165 -MultiLineStringQuote=166 -MultiLineStrRef=167 -MultiLineStrText=168 -MultiLineStrExprStart=169 -'...'=6 -'.'=7 -','=8 -'('=9 -')'=10 -'['=11 -']'=12 -'{'=13 -'}'=14 -'*'=15 -'%'=16 -'/'=17 -'+'=18 -'-'=19 -'++'=20 -'--'=21 -'&&'=22 -'||'=23 -'!'=25 -':'=26 -';'=27 -'='=28 -'+='=29 -'-='=30 -'*='=31 -'/='=32 -'%='=33 -'->'=34 -'=>'=35 -'..'=36 -'::'=37 -';;'=38 -'#'=39 -'@'=40 -'?'=43 -'<'=44 -'>'=45 -'<='=46 -'>='=47 -'!='=48 -'!=='=49 -'as?'=50 -'=='=51 -'==='=52 -'\''=53 -'package'=59 -'import'=60 -'class'=61 -'interface'=62 -'fun'=63 -'object'=64 -'val'=65 -'var'=66 -'typealias'=67 -'constructor'=68 -'by'=69 -'companion'=70 -'init'=71 -'this'=72 -'super'=73 -'typeof'=74 -'where'=75 -'if'=76 -'else'=77 -'when'=78 -'try'=79 -'catch'=80 -'finally'=81 -'for'=82 -'do'=83 -'while'=84 -'throw'=85 -'return'=86 -'continue'=87 -'break'=88 -'as'=89 -'is'=90 -'in'=91 -'out'=94 -'get'=95 -'set'=96 -'dynamic'=97 -'@file'=98 -'@field'=99 -'@property'=100 -'@get'=101 -'@set'=102 -'@receiver'=103 -'@param'=104 -'@setparam'=105 -'@delegate'=106 -'public'=107 -'private'=108 -'protected'=109 -'internal'=110 -'enum'=111 -'sealed'=112 -'annotation'=113 -'data'=114 -'inner'=115 -'tailrec'=116 -'operator'=117 -'inline'=118 -'infix'=119 -'external'=120 -'suspend'=121 -'override'=122 -'abstract'=123 -'final'=124 -'open'=125 -'const'=126 -'lateinit'=127 -'vararg'=128 -'noinline'=129 -'crossinline'=130 -'reified'=131 -'expect'=132 -'actual'=133 -'"""'=135 -'null'=144 diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserBaseListener.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserBaseListener.java deleted file mode 100644 index 4845b96..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserBaseListener.java +++ /dev/null @@ -1,2030 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.kotlin;// Generated from KotlinParser.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.tree.ErrorNode; -import org.antlr.v4.runtime.tree.TerminalNode; - -/** - * This class provides an empty implementation of {@link KotlinParserListener}, - * which can be extended to create a listener which only needs to handle a subset - * of the available methods. - */ -public class KotlinParserBaseListener implements KotlinParserListener { - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterKotlinFile(KotlinParser.KotlinFileContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitKotlinFile(KotlinParser.KotlinFileContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterScript(KotlinParser.ScriptContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitScript(KotlinParser.ScriptContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPackageHeader(KotlinParser.PackageHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPackageHeader(KotlinParser.PackageHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportList(KotlinParser.ImportListContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportList(KotlinParser.ImportListContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportHeader(KotlinParser.ImportHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportHeader(KotlinParser.ImportHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportAlias(KotlinParser.ImportAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportAlias(KotlinParser.ImportAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassParameters(KotlinParser.ClassParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassParameters(KotlinParser.ClassParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassParameter(KotlinParser.ClassParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassParameter(KotlinParser.ClassParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassBody(KotlinParser.ClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassBody(KotlinParser.ClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumEntries(KotlinParser.EnumEntriesContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumEntries(KotlinParser.EnumEntriesContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumEntry(KotlinParser.EnumEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumEntry(KotlinParser.EnumEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameter(KotlinParser.ParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameter(KotlinParser.ParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSetterParameter(KotlinParser.SetterParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSetterParameter(KotlinParser.SetterParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionBody(KotlinParser.FunctionBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionBody(KotlinParser.FunctionBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCompanionObject(KotlinParser.CompanionObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCompanionObject(KotlinParser.CompanionObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterGetter(KotlinParser.GetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitGetter(KotlinParser.GetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSetter(KotlinParser.SetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSetter(KotlinParser.SetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeAlias(KotlinParser.TypeAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeAlias(KotlinParser.TypeAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameters(KotlinParser.TypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameters(KotlinParser.TypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameter(KotlinParser.TypeParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameter(KotlinParser.TypeParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterType(KotlinParser.TypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitType(KotlinParser.TypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeModifier(KotlinParser.TypeModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeModifier(KotlinParser.TypeModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterNullableType(KotlinParser.NullableTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitNullableType(KotlinParser.NullableTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeReference(KotlinParser.TypeReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeReference(KotlinParser.TypeReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionType(KotlinParser.FunctionTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionType(KotlinParser.FunctionTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterReceiverType(KotlinParser.ReceiverTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitReceiverType(KotlinParser.ReceiverTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUserType(KotlinParser.UserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUserType(KotlinParser.UserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterBlock(KotlinParser.BlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitBlock(KotlinParser.BlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStatements(KotlinParser.StatementsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStatements(KotlinParser.StatementsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStatement(KotlinParser.StatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStatement(KotlinParser.StatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDeclaration(KotlinParser.DeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDeclaration(KotlinParser.DeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignment(KotlinParser.AssignmentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignment(KotlinParser.AssignmentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExpression(KotlinParser.ExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExpression(KotlinParser.ExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDisjunction(KotlinParser.DisjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDisjunction(KotlinParser.DisjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConjunction(KotlinParser.ConjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConjunction(KotlinParser.ConjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEquality(KotlinParser.EqualityContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEquality(KotlinParser.EqualityContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterComparison(KotlinParser.ComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitComparison(KotlinParser.ComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInfixOperation(KotlinParser.InfixOperationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInfixOperation(KotlinParser.InfixOperationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterRangeExpression(KotlinParser.RangeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitRangeExpression(KotlinParser.RangeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAsExpression(KotlinParser.AsExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAsExpression(KotlinParser.AsExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCallSuffix(KotlinParser.CallSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCallSuffix(KotlinParser.CallSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterValueArguments(KotlinParser.ValueArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitValueArguments(KotlinParser.ValueArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjection(KotlinParser.TypeProjectionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjection(KotlinParser.TypeProjectionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterValueArgument(KotlinParser.ValueArgumentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitValueArgument(KotlinParser.ValueArgumentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStringLiteral(KotlinParser.StringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStringLiteral(KotlinParser.StringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringContent(KotlinParser.LineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringContent(KotlinParser.LineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterThisExpression(KotlinParser.ThisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitThisExpression(KotlinParser.ThisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSuperExpression(KotlinParser.SuperExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSuperExpression(KotlinParser.SuperExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIfExpression(KotlinParser.IfExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIfExpression(KotlinParser.IfExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenExpression(KotlinParser.WhenExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenExpression(KotlinParser.WhenExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenEntry(KotlinParser.WhenEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenEntry(KotlinParser.WhenEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenCondition(KotlinParser.WhenConditionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenCondition(KotlinParser.WhenConditionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterRangeTest(KotlinParser.RangeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitRangeTest(KotlinParser.RangeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeTest(KotlinParser.TypeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeTest(KotlinParser.TypeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTryExpression(KotlinParser.TryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTryExpression(KotlinParser.TryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCatchBlock(KotlinParser.CatchBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCatchBlock(KotlinParser.CatchBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLoopStatement(KotlinParser.LoopStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLoopStatement(KotlinParser.LoopStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterForStatement(KotlinParser.ForStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitForStatement(KotlinParser.ForStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhileStatement(KotlinParser.WhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhileStatement(KotlinParser.WhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterJumpExpression(KotlinParser.JumpExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitJumpExpression(KotlinParser.JumpExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCallableReference(KotlinParser.CallableReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCallableReference(KotlinParser.CallableReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInOperator(KotlinParser.InOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInOperator(KotlinParser.InOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIsOperator(KotlinParser.IsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIsOperator(KotlinParser.IsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAsOperator(KotlinParser.AsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAsOperator(KotlinParser.AsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterModifiers(KotlinParser.ModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitModifiers(KotlinParser.ModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterModifier(KotlinParser.ModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitModifier(KotlinParser.ModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassModifier(KotlinParser.ClassModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassModifier(KotlinParser.ClassModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMemberModifier(KotlinParser.MemberModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMemberModifier(KotlinParser.MemberModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameterModifier(KotlinParser.ParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameterModifier(KotlinParser.ParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterReificationModifier(KotlinParser.ReificationModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitReificationModifier(KotlinParser.ReificationModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLabel(KotlinParser.LabelContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLabel(KotlinParser.LabelContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotation(KotlinParser.AnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotation(KotlinParser.AnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIdentifier(KotlinParser.IdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIdentifier(KotlinParser.IdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterShebangLine(KotlinParser.ShebangLineContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitShebangLine(KotlinParser.ShebangLineContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterQuest(KotlinParser.QuestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitQuest(KotlinParser.QuestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterElvis(KotlinParser.ElvisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitElvis(KotlinParser.ElvisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSafeNav(KotlinParser.SafeNavContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSafeNav(KotlinParser.SafeNavContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExcl(KotlinParser.ExclContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExcl(KotlinParser.ExclContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSemi(KotlinParser.SemiContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSemi(KotlinParser.SemiContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSemis(KotlinParser.SemisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSemis(KotlinParser.SemisContext ctx) { } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEveryRule(ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEveryRule(ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void visitTerminal(TerminalNode node) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void visitErrorNode(ErrorNode node) { } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserListener.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserListener.java deleted file mode 100644 index 7482c8a..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/kotlin/KotlinParserListener.java +++ /dev/null @@ -1,1669 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.kotlin;// Generated from KotlinParser.g4 by ANTLR 4.9 -import org.antlr.v4.runtime.tree.ParseTreeListener; - -/** - * This interface defines a complete listener for a parse tree produced by - * {@link KotlinParser}. - */ -public interface KotlinParserListener extends ParseTreeListener { - /** - * Enter a parse tree produced by {@link KotlinParser#kotlinFile}. - * @param ctx the parse tree - */ - void enterKotlinFile(KotlinParser.KotlinFileContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#kotlinFile}. - * @param ctx the parse tree - */ - void exitKotlinFile(KotlinParser.KotlinFileContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#script}. - * @param ctx the parse tree - */ - void enterScript(KotlinParser.ScriptContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#script}. - * @param ctx the parse tree - */ - void exitScript(KotlinParser.ScriptContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#fileAnnotation}. - * @param ctx the parse tree - */ - void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#fileAnnotation}. - * @param ctx the parse tree - */ - void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#packageHeader}. - * @param ctx the parse tree - */ - void enterPackageHeader(KotlinParser.PackageHeaderContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#packageHeader}. - * @param ctx the parse tree - */ - void exitPackageHeader(KotlinParser.PackageHeaderContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importList}. - * @param ctx the parse tree - */ - void enterImportList(KotlinParser.ImportListContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importList}. - * @param ctx the parse tree - */ - void exitImportList(KotlinParser.ImportListContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importHeader}. - * @param ctx the parse tree - */ - void enterImportHeader(KotlinParser.ImportHeaderContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importHeader}. - * @param ctx the parse tree - */ - void exitImportHeader(KotlinParser.ImportHeaderContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importAlias}. - * @param ctx the parse tree - */ - void enterImportAlias(KotlinParser.ImportAliasContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importAlias}. - * @param ctx the parse tree - */ - void exitImportAlias(KotlinParser.ImportAliasContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#topLevelObject}. - * @param ctx the parse tree - */ - void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#topLevelObject}. - * @param ctx the parse tree - */ - void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classDeclaration}. - * @param ctx the parse tree - */ - void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classDeclaration}. - * @param ctx the parse tree - */ - void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#primaryConstructor}. - * @param ctx the parse tree - */ - void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#primaryConstructor}. - * @param ctx the parse tree - */ - void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classParameters}. - * @param ctx the parse tree - */ - void enterClassParameters(KotlinParser.ClassParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classParameters}. - * @param ctx the parse tree - */ - void exitClassParameters(KotlinParser.ClassParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classParameter}. - * @param ctx the parse tree - */ - void enterClassParameter(KotlinParser.ClassParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classParameter}. - * @param ctx the parse tree - */ - void exitClassParameter(KotlinParser.ClassParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#delegationSpecifiers}. - * @param ctx the parse tree - */ - void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#delegationSpecifiers}. - * @param ctx the parse tree - */ - void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. - * @param ctx the parse tree - */ - void enterAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. - * @param ctx the parse tree - */ - void exitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#delegationSpecifier}. - * @param ctx the parse tree - */ - void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#delegationSpecifier}. - * @param ctx the parse tree - */ - void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#constructorInvocation}. - * @param ctx the parse tree - */ - void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#constructorInvocation}. - * @param ctx the parse tree - */ - void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#explicitDelegation}. - * @param ctx the parse tree - */ - void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#explicitDelegation}. - * @param ctx the parse tree - */ - void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classBody}. - * @param ctx the parse tree - */ - void enterClassBody(KotlinParser.ClassBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classBody}. - * @param ctx the parse tree - */ - void exitClassBody(KotlinParser.ClassBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classMemberDeclarations}. - * @param ctx the parse tree - */ - void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classMemberDeclarations}. - * @param ctx the parse tree - */ - void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classMemberDeclaration}. - * @param ctx the parse tree - */ - void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classMemberDeclaration}. - * @param ctx the parse tree - */ - void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#anonymousInitializer}. - * @param ctx the parse tree - */ - void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#anonymousInitializer}. - * @param ctx the parse tree - */ - void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#secondaryConstructor}. - * @param ctx the parse tree - */ - void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#secondaryConstructor}. - * @param ctx the parse tree - */ - void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#constructorDelegationCall}. - * @param ctx the parse tree - */ - void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#constructorDelegationCall}. - * @param ctx the parse tree - */ - void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumClassBody}. - * @param ctx the parse tree - */ - void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumClassBody}. - * @param ctx the parse tree - */ - void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumEntries}. - * @param ctx the parse tree - */ - void enterEnumEntries(KotlinParser.EnumEntriesContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumEntries}. - * @param ctx the parse tree - */ - void exitEnumEntries(KotlinParser.EnumEntriesContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumEntry}. - * @param ctx the parse tree - */ - void enterEnumEntry(KotlinParser.EnumEntryContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumEntry}. - * @param ctx the parse tree - */ - void exitEnumEntry(KotlinParser.EnumEntryContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionDeclaration}. - * @param ctx the parse tree - */ - void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionDeclaration}. - * @param ctx the parse tree - */ - void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionValueParameters}. - * @param ctx the parse tree - */ - void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionValueParameters}. - * @param ctx the parse tree - */ - void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionValueParameter}. - * @param ctx the parse tree - */ - void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionValueParameter}. - * @param ctx the parse tree - */ - void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameter}. - * @param ctx the parse tree - */ - void enterParameter(KotlinParser.ParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameter}. - * @param ctx the parse tree - */ - void exitParameter(KotlinParser.ParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#setterParameter}. - * @param ctx the parse tree - */ - void enterSetterParameter(KotlinParser.SetterParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#setterParameter}. - * @param ctx the parse tree - */ - void exitSetterParameter(KotlinParser.SetterParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionBody}. - * @param ctx the parse tree - */ - void enterFunctionBody(KotlinParser.FunctionBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionBody}. - * @param ctx the parse tree - */ - void exitFunctionBody(KotlinParser.FunctionBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#objectDeclaration}. - * @param ctx the parse tree - */ - void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#objectDeclaration}. - * @param ctx the parse tree - */ - void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#companionObject}. - * @param ctx the parse tree - */ - void enterCompanionObject(KotlinParser.CompanionObjectContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#companionObject}. - * @param ctx the parse tree - */ - void exitCompanionObject(KotlinParser.CompanionObjectContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyDeclaration}. - * @param ctx the parse tree - */ - void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyDeclaration}. - * @param ctx the parse tree - */ - void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. - * @param ctx the parse tree - */ - void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. - * @param ctx the parse tree - */ - void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#variableDeclaration}. - * @param ctx the parse tree - */ - void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#variableDeclaration}. - * @param ctx the parse tree - */ - void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyDelegate}. - * @param ctx the parse tree - */ - void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyDelegate}. - * @param ctx the parse tree - */ - void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#getter}. - * @param ctx the parse tree - */ - void enterGetter(KotlinParser.GetterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#getter}. - * @param ctx the parse tree - */ - void exitGetter(KotlinParser.GetterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#setter}. - * @param ctx the parse tree - */ - void enterSetter(KotlinParser.SetterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#setter}. - * @param ctx the parse tree - */ - void exitSetter(KotlinParser.SetterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeAlias}. - * @param ctx the parse tree - */ - void enterTypeAlias(KotlinParser.TypeAliasContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeAlias}. - * @param ctx the parse tree - */ - void exitTypeAlias(KotlinParser.TypeAliasContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameters}. - * @param ctx the parse tree - */ - void enterTypeParameters(KotlinParser.TypeParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameters}. - * @param ctx the parse tree - */ - void exitTypeParameters(KotlinParser.TypeParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameter}. - * @param ctx the parse tree - */ - void enterTypeParameter(KotlinParser.TypeParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameter}. - * @param ctx the parse tree - */ - void exitTypeParameter(KotlinParser.TypeParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameterModifiers}. - * @param ctx the parse tree - */ - void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameterModifiers}. - * @param ctx the parse tree - */ - void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameterModifier}. - * @param ctx the parse tree - */ - void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameterModifier}. - * @param ctx the parse tree - */ - void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#type}. - * @param ctx the parse tree - */ - void enterType(KotlinParser.TypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#type}. - * @param ctx the parse tree - */ - void exitType(KotlinParser.TypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeModifiers}. - * @param ctx the parse tree - */ - void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeModifiers}. - * @param ctx the parse tree - */ - void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeModifier}. - * @param ctx the parse tree - */ - void enterTypeModifier(KotlinParser.TypeModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeModifier}. - * @param ctx the parse tree - */ - void exitTypeModifier(KotlinParser.TypeModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedType}. - * @param ctx the parse tree - */ - void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedType}. - * @param ctx the parse tree - */ - void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#nullableType}. - * @param ctx the parse tree - */ - void enterNullableType(KotlinParser.NullableTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#nullableType}. - * @param ctx the parse tree - */ - void exitNullableType(KotlinParser.NullableTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeReference}. - * @param ctx the parse tree - */ - void enterTypeReference(KotlinParser.TypeReferenceContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeReference}. - * @param ctx the parse tree - */ - void exitTypeReference(KotlinParser.TypeReferenceContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionType}. - * @param ctx the parse tree - */ - void enterFunctionType(KotlinParser.FunctionTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionType}. - * @param ctx the parse tree - */ - void exitFunctionType(KotlinParser.FunctionTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#receiverType}. - * @param ctx the parse tree - */ - void enterReceiverType(KotlinParser.ReceiverTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#receiverType}. - * @param ctx the parse tree - */ - void exitReceiverType(KotlinParser.ReceiverTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#userType}. - * @param ctx the parse tree - */ - void enterUserType(KotlinParser.UserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#userType}. - * @param ctx the parse tree - */ - void exitUserType(KotlinParser.UserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedUserType}. - * @param ctx the parse tree - */ - void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedUserType}. - * @param ctx the parse tree - */ - void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#simpleUserType}. - * @param ctx the parse tree - */ - void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#simpleUserType}. - * @param ctx the parse tree - */ - void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionTypeParameters}. - * @param ctx the parse tree - */ - void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionTypeParameters}. - * @param ctx the parse tree - */ - void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeConstraints}. - * @param ctx the parse tree - */ - void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeConstraints}. - * @param ctx the parse tree - */ - void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeConstraint}. - * @param ctx the parse tree - */ - void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeConstraint}. - * @param ctx the parse tree - */ - void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#block}. - * @param ctx the parse tree - */ - void enterBlock(KotlinParser.BlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#block}. - * @param ctx the parse tree - */ - void exitBlock(KotlinParser.BlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#statements}. - * @param ctx the parse tree - */ - void enterStatements(KotlinParser.StatementsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#statements}. - * @param ctx the parse tree - */ - void exitStatements(KotlinParser.StatementsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#statement}. - * @param ctx the parse tree - */ - void enterStatement(KotlinParser.StatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#statement}. - * @param ctx the parse tree - */ - void exitStatement(KotlinParser.StatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#declaration}. - * @param ctx the parse tree - */ - void enterDeclaration(KotlinParser.DeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#declaration}. - * @param ctx the parse tree - */ - void exitDeclaration(KotlinParser.DeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignment}. - * @param ctx the parse tree - */ - void enterAssignment(KotlinParser.AssignmentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignment}. - * @param ctx the parse tree - */ - void exitAssignment(KotlinParser.AssignmentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#expression}. - * @param ctx the parse tree - */ - void enterExpression(KotlinParser.ExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#expression}. - * @param ctx the parse tree - */ - void exitExpression(KotlinParser.ExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#disjunction}. - * @param ctx the parse tree - */ - void enterDisjunction(KotlinParser.DisjunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#disjunction}. - * @param ctx the parse tree - */ - void exitDisjunction(KotlinParser.DisjunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#conjunction}. - * @param ctx the parse tree - */ - void enterConjunction(KotlinParser.ConjunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#conjunction}. - * @param ctx the parse tree - */ - void exitConjunction(KotlinParser.ConjunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#equality}. - * @param ctx the parse tree - */ - void enterEquality(KotlinParser.EqualityContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#equality}. - * @param ctx the parse tree - */ - void exitEquality(KotlinParser.EqualityContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#comparison}. - * @param ctx the parse tree - */ - void enterComparison(KotlinParser.ComparisonContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#comparison}. - * @param ctx the parse tree - */ - void exitComparison(KotlinParser.ComparisonContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#infixOperation}. - * @param ctx the parse tree - */ - void enterInfixOperation(KotlinParser.InfixOperationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#infixOperation}. - * @param ctx the parse tree - */ - void exitInfixOperation(KotlinParser.InfixOperationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#elvisExpression}. - * @param ctx the parse tree - */ - void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#elvisExpression}. - * @param ctx the parse tree - */ - void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#infixFunctionCall}. - * @param ctx the parse tree - */ - void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#infixFunctionCall}. - * @param ctx the parse tree - */ - void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#rangeExpression}. - * @param ctx the parse tree - */ - void enterRangeExpression(KotlinParser.RangeExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#rangeExpression}. - * @param ctx the parse tree - */ - void exitRangeExpression(KotlinParser.RangeExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#additiveExpression}. - * @param ctx the parse tree - */ - void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#additiveExpression}. - * @param ctx the parse tree - */ - void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiplicativeExpression}. - * @param ctx the parse tree - */ - void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiplicativeExpression}. - * @param ctx the parse tree - */ - void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#asExpression}. - * @param ctx the parse tree - */ - void enterAsExpression(KotlinParser.AsExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#asExpression}. - * @param ctx the parse tree - */ - void exitAsExpression(KotlinParser.AsExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. - * @param ctx the parse tree - */ - void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. - * @param ctx the parse tree - */ - void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#unaryPrefix}. - * @param ctx the parse tree - */ - void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#unaryPrefix}. - * @param ctx the parse tree - */ - void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. - * @param ctx the parse tree - */ - void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. - * @param ctx the parse tree - */ - void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. - * @param ctx the parse tree - */ - void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. - * @param ctx the parse tree - */ - void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. - * @param ctx the parse tree - */ - void enterDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. - * @param ctx the parse tree - */ - void exitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignableExpression}. - * @param ctx the parse tree - */ - void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignableExpression}. - * @param ctx the parse tree - */ - void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignableSuffix}. - * @param ctx the parse tree - */ - void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignableSuffix}. - * @param ctx the parse tree - */ - void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#indexingSuffix}. - * @param ctx the parse tree - */ - void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#indexingSuffix}. - * @param ctx the parse tree - */ - void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#navigationSuffix}. - * @param ctx the parse tree - */ - void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#navigationSuffix}. - * @param ctx the parse tree - */ - void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#callSuffix}. - * @param ctx the parse tree - */ - void enterCallSuffix(KotlinParser.CallSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#callSuffix}. - * @param ctx the parse tree - */ - void exitCallSuffix(KotlinParser.CallSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotatedLambda}. - * @param ctx the parse tree - */ - void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotatedLambda}. - * @param ctx the parse tree - */ - void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#valueArguments}. - * @param ctx the parse tree - */ - void enterValueArguments(KotlinParser.ValueArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#valueArguments}. - * @param ctx the parse tree - */ - void exitValueArguments(KotlinParser.ValueArgumentsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeArguments}. - * @param ctx the parse tree - */ - void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeArguments}. - * @param ctx the parse tree - */ - void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjection}. - * @param ctx the parse tree - */ - void enterTypeProjection(KotlinParser.TypeProjectionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjection}. - * @param ctx the parse tree - */ - void exitTypeProjection(KotlinParser.TypeProjectionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. - * @param ctx the parse tree - */ - void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. - * @param ctx the parse tree - */ - void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifier}. - * @param ctx the parse tree - */ - void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifier}. - * @param ctx the parse tree - */ - void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#valueArgument}. - * @param ctx the parse tree - */ - void enterValueArgument(KotlinParser.ValueArgumentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#valueArgument}. - * @param ctx the parse tree - */ - void exitValueArgument(KotlinParser.ValueArgumentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#primaryExpression}. - * @param ctx the parse tree - */ - void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#primaryExpression}. - * @param ctx the parse tree - */ - void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedExpression}. - * @param ctx the parse tree - */ - void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedExpression}. - * @param ctx the parse tree - */ - void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#collectionLiteral}. - * @param ctx the parse tree - */ - void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#collectionLiteral}. - * @param ctx the parse tree - */ - void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#literalConstant}. - * @param ctx the parse tree - */ - void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#literalConstant}. - * @param ctx the parse tree - */ - void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#stringLiteral}. - * @param ctx the parse tree - */ - void enterStringLiteral(KotlinParser.StringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#stringLiteral}. - * @param ctx the parse tree - */ - void exitStringLiteral(KotlinParser.StringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringLiteral}. - * @param ctx the parse tree - */ - void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringLiteral}. - * @param ctx the parse tree - */ - void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. - * @param ctx the parse tree - */ - void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. - * @param ctx the parse tree - */ - void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringContent}. - * @param ctx the parse tree - */ - void enterLineStringContent(KotlinParser.LineStringContentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringContent}. - * @param ctx the parse tree - */ - void exitLineStringContent(KotlinParser.LineStringContentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringExpression}. - * @param ctx the parse tree - */ - void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringExpression}. - * @param ctx the parse tree - */ - void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringContent}. - * @param ctx the parse tree - */ - void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringContent}. - * @param ctx the parse tree - */ - void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringExpression}. - * @param ctx the parse tree - */ - void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringExpression}. - * @param ctx the parse tree - */ - void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaLiteral}. - * @param ctx the parse tree - */ - void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaLiteral}. - * @param ctx the parse tree - */ - void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaParameters}. - * @param ctx the parse tree - */ - void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaParameters}. - * @param ctx the parse tree - */ - void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaParameter}. - * @param ctx the parse tree - */ - void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaParameter}. - * @param ctx the parse tree - */ - void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#anonymousFunction}. - * @param ctx the parse tree - */ - void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#anonymousFunction}. - * @param ctx the parse tree - */ - void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionLiteral}. - * @param ctx the parse tree - */ - void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionLiteral}. - * @param ctx the parse tree - */ - void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#objectLiteral}. - * @param ctx the parse tree - */ - void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#objectLiteral}. - * @param ctx the parse tree - */ - void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#thisExpression}. - * @param ctx the parse tree - */ - void enterThisExpression(KotlinParser.ThisExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#thisExpression}. - * @param ctx the parse tree - */ - void exitThisExpression(KotlinParser.ThisExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#superExpression}. - * @param ctx the parse tree - */ - void enterSuperExpression(KotlinParser.SuperExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#superExpression}. - * @param ctx the parse tree - */ - void exitSuperExpression(KotlinParser.SuperExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#controlStructureBody}. - * @param ctx the parse tree - */ - void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#controlStructureBody}. - * @param ctx the parse tree - */ - void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#ifExpression}. - * @param ctx the parse tree - */ - void enterIfExpression(KotlinParser.IfExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#ifExpression}. - * @param ctx the parse tree - */ - void exitIfExpression(KotlinParser.IfExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenExpression}. - * @param ctx the parse tree - */ - void enterWhenExpression(KotlinParser.WhenExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenExpression}. - * @param ctx the parse tree - */ - void exitWhenExpression(KotlinParser.WhenExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenEntry}. - * @param ctx the parse tree - */ - void enterWhenEntry(KotlinParser.WhenEntryContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenEntry}. - * @param ctx the parse tree - */ - void exitWhenEntry(KotlinParser.WhenEntryContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenCondition}. - * @param ctx the parse tree - */ - void enterWhenCondition(KotlinParser.WhenConditionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenCondition}. - * @param ctx the parse tree - */ - void exitWhenCondition(KotlinParser.WhenConditionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#rangeTest}. - * @param ctx the parse tree - */ - void enterRangeTest(KotlinParser.RangeTestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#rangeTest}. - * @param ctx the parse tree - */ - void exitRangeTest(KotlinParser.RangeTestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeTest}. - * @param ctx the parse tree - */ - void enterTypeTest(KotlinParser.TypeTestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeTest}. - * @param ctx the parse tree - */ - void exitTypeTest(KotlinParser.TypeTestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#tryExpression}. - * @param ctx the parse tree - */ - void enterTryExpression(KotlinParser.TryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#tryExpression}. - * @param ctx the parse tree - */ - void exitTryExpression(KotlinParser.TryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#catchBlock}. - * @param ctx the parse tree - */ - void enterCatchBlock(KotlinParser.CatchBlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#catchBlock}. - * @param ctx the parse tree - */ - void exitCatchBlock(KotlinParser.CatchBlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#finallyBlock}. - * @param ctx the parse tree - */ - void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#finallyBlock}. - * @param ctx the parse tree - */ - void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#loopStatement}. - * @param ctx the parse tree - */ - void enterLoopStatement(KotlinParser.LoopStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#loopStatement}. - * @param ctx the parse tree - */ - void exitLoopStatement(KotlinParser.LoopStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#forStatement}. - * @param ctx the parse tree - */ - void enterForStatement(KotlinParser.ForStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#forStatement}. - * @param ctx the parse tree - */ - void exitForStatement(KotlinParser.ForStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whileStatement}. - * @param ctx the parse tree - */ - void enterWhileStatement(KotlinParser.WhileStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whileStatement}. - * @param ctx the parse tree - */ - void exitWhileStatement(KotlinParser.WhileStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#doWhileStatement}. - * @param ctx the parse tree - */ - void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#doWhileStatement}. - * @param ctx the parse tree - */ - void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#jumpExpression}. - * @param ctx the parse tree - */ - void enterJumpExpression(KotlinParser.JumpExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#jumpExpression}. - * @param ctx the parse tree - */ - void exitJumpExpression(KotlinParser.JumpExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#callableReference}. - * @param ctx the parse tree - */ - void enterCallableReference(KotlinParser.CallableReferenceContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#callableReference}. - * @param ctx the parse tree - */ - void exitCallableReference(KotlinParser.CallableReferenceContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignmentAndOperator}. - * @param ctx the parse tree - */ - void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignmentAndOperator}. - * @param ctx the parse tree - */ - void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#equalityOperator}. - * @param ctx the parse tree - */ - void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#equalityOperator}. - * @param ctx the parse tree - */ - void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#comparisonOperator}. - * @param ctx the parse tree - */ - void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#comparisonOperator}. - * @param ctx the parse tree - */ - void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#inOperator}. - * @param ctx the parse tree - */ - void enterInOperator(KotlinParser.InOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#inOperator}. - * @param ctx the parse tree - */ - void exitInOperator(KotlinParser.InOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#isOperator}. - * @param ctx the parse tree - */ - void enterIsOperator(KotlinParser.IsOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#isOperator}. - * @param ctx the parse tree - */ - void exitIsOperator(KotlinParser.IsOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#additiveOperator}. - * @param ctx the parse tree - */ - void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#additiveOperator}. - * @param ctx the parse tree - */ - void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiplicativeOperator}. - * @param ctx the parse tree - */ - void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiplicativeOperator}. - * @param ctx the parse tree - */ - void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#asOperator}. - * @param ctx the parse tree - */ - void enterAsOperator(KotlinParser.AsOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#asOperator}. - * @param ctx the parse tree - */ - void exitAsOperator(KotlinParser.AsOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. - * @param ctx the parse tree - */ - void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. - * @param ctx the parse tree - */ - void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. - * @param ctx the parse tree - */ - void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. - * @param ctx the parse tree - */ - void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#memberAccessOperator}. - * @param ctx the parse tree - */ - void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#memberAccessOperator}. - * @param ctx the parse tree - */ - void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#modifiers}. - * @param ctx the parse tree - */ - void enterModifiers(KotlinParser.ModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#modifiers}. - * @param ctx the parse tree - */ - void exitModifiers(KotlinParser.ModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#modifier}. - * @param ctx the parse tree - */ - void enterModifier(KotlinParser.ModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#modifier}. - * @param ctx the parse tree - */ - void exitModifier(KotlinParser.ModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classModifier}. - * @param ctx the parse tree - */ - void enterClassModifier(KotlinParser.ClassModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classModifier}. - * @param ctx the parse tree - */ - void exitClassModifier(KotlinParser.ClassModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#memberModifier}. - * @param ctx the parse tree - */ - void enterMemberModifier(KotlinParser.MemberModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#memberModifier}. - * @param ctx the parse tree - */ - void exitMemberModifier(KotlinParser.MemberModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#visibilityModifier}. - * @param ctx the parse tree - */ - void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#visibilityModifier}. - * @param ctx the parse tree - */ - void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#varianceModifier}. - * @param ctx the parse tree - */ - void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#varianceModifier}. - * @param ctx the parse tree - */ - void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionModifier}. - * @param ctx the parse tree - */ - void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionModifier}. - * @param ctx the parse tree - */ - void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyModifier}. - * @param ctx the parse tree - */ - void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyModifier}. - * @param ctx the parse tree - */ - void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#inheritanceModifier}. - * @param ctx the parse tree - */ - void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#inheritanceModifier}. - * @param ctx the parse tree - */ - void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameterModifier}. - * @param ctx the parse tree - */ - void enterParameterModifier(KotlinParser.ParameterModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameterModifier}. - * @param ctx the parse tree - */ - void exitParameterModifier(KotlinParser.ParameterModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#reificationModifier}. - * @param ctx the parse tree - */ - void enterReificationModifier(KotlinParser.ReificationModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#reificationModifier}. - * @param ctx the parse tree - */ - void exitReificationModifier(KotlinParser.ReificationModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#platformModifier}. - * @param ctx the parse tree - */ - void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#platformModifier}. - * @param ctx the parse tree - */ - void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#label}. - * @param ctx the parse tree - */ - void enterLabel(KotlinParser.LabelContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#label}. - * @param ctx the parse tree - */ - void exitLabel(KotlinParser.LabelContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotation}. - * @param ctx the parse tree - */ - void enterAnnotation(KotlinParser.AnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotation}. - * @param ctx the parse tree - */ - void exitAnnotation(KotlinParser.AnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#singleAnnotation}. - * @param ctx the parse tree - */ - void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#singleAnnotation}. - * @param ctx the parse tree - */ - void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiAnnotation}. - * @param ctx the parse tree - */ - void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiAnnotation}. - * @param ctx the parse tree - */ - void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. - * @param ctx the parse tree - */ - void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. - * @param ctx the parse tree - */ - void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#unescapedAnnotation}. - * @param ctx the parse tree - */ - void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#unescapedAnnotation}. - * @param ctx the parse tree - */ - void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#simpleIdentifier}. - * @param ctx the parse tree - */ - void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#simpleIdentifier}. - * @param ctx the parse tree - */ - void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#identifier}. - * @param ctx the parse tree - */ - void enterIdentifier(KotlinParser.IdentifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#identifier}. - * @param ctx the parse tree - */ - void exitIdentifier(KotlinParser.IdentifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#shebangLine}. - * @param ctx the parse tree - */ - void enterShebangLine(KotlinParser.ShebangLineContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#shebangLine}. - * @param ctx the parse tree - */ - void exitShebangLine(KotlinParser.ShebangLineContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#quest}. - * @param ctx the parse tree - */ - void enterQuest(KotlinParser.QuestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#quest}. - * @param ctx the parse tree - */ - void exitQuest(KotlinParser.QuestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#elvis}. - * @param ctx the parse tree - */ - void enterElvis(KotlinParser.ElvisContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#elvis}. - * @param ctx the parse tree - */ - void exitElvis(KotlinParser.ElvisContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#safeNav}. - * @param ctx the parse tree - */ - void enterSafeNav(KotlinParser.SafeNavContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#safeNav}. - * @param ctx the parse tree - */ - void exitSafeNav(KotlinParser.SafeNavContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#excl}. - * @param ctx the parse tree - */ - void enterExcl(KotlinParser.ExclContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#excl}. - * @param ctx the parse tree - */ - void exitExcl(KotlinParser.ExclContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#semi}. - * @param ctx the parse tree - */ - void enterSemi(KotlinParser.SemiContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#semi}. - * @param ctx the parse tree - */ - void exitSemi(KotlinParser.SemiContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#semis}. - * @param ctx the parse tree - */ - void enterSemis(KotlinParser.SemisContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#semis}. - * @param ctx the parse tree - */ - void exitSemis(KotlinParser.SemisContext ctx); -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.interp deleted file mode 100644 index e578363..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.interp +++ /dev/null @@ -1,295 +0,0 @@ -token literal names: -null -null -null -null -'def' -'return' -'raise' -'from' -'import' -'as' -'global' -'nonlocal' -'assert' -'if' -'elif' -'else' -'while' -'for' -'in' -'try' -'finally' -'with' -'except' -'lambda' -'or' -'and' -'not' -'is' -'None' -'True' -'False' -'class' -'yield' -'del' -'pass' -'continue' -'break' -'async' -'await' -null -null -null -null -null -null -null -null -null -null -'.' -'...' -'*' -'(' -')' -',' -':' -';' -'**' -'=' -'[' -']' -'|' -'^' -'&' -'<<' -'>>' -'+' -'-' -'/' -'%' -'//' -'~' -'{' -'}' -'<' -'>' -'==' -'>=' -'<=' -'<>' -'!=' -'@' -'->' -'+=' -'-=' -'*=' -'@=' -'/=' -'%=' -'&=' -'|=' -'^=' -'<<=' -'>>=' -'**=' -'//=' -null -null -null -null - -token symbolic names: -null -STRING -NUMBER -INTEGER -DEF -RETURN -RAISE -FROM -IMPORT -AS -GLOBAL -NONLOCAL -ASSERT -IF -ELIF -ELSE -WHILE -FOR -IN -TRY -FINALLY -WITH -EXCEPT -LAMBDA -OR -AND -NOT -IS -NONE -TRUE -FALSE -CLASS -YIELD -DEL -PASS -CONTINUE -BREAK -ASYNC -AWAIT -NEWLINE -NAME -STRING_LITERAL -BYTES_LITERAL -DECIMAL_INTEGER -OCT_INTEGER -HEX_INTEGER -BIN_INTEGER -FLOAT_NUMBER -IMAG_NUMBER -DOT -ELLIPSIS -STAR -OPEN_PAREN -CLOSE_PAREN -COMMA -COLON -SEMI_COLON -POWER -ASSIGN -OPEN_BRACK -CLOSE_BRACK -OR_OP -XOR -AND_OP -LEFT_SHIFT -RIGHT_SHIFT -ADD -MINUS -DIV -MOD -IDIV -NOT_OP -OPEN_BRACE -CLOSE_BRACE -LESS_THAN -GREATER_THAN -EQUALS -GT_EQ -LT_EQ -NOT_EQ_1 -NOT_EQ_2 -AT -ARROW -ADD_ASSIGN -SUB_ASSIGN -MULT_ASSIGN -AT_ASSIGN -DIV_ASSIGN -MOD_ASSIGN -AND_ASSIGN -OR_ASSIGN -XOR_ASSIGN -LEFT_SHIFT_ASSIGN -RIGHT_SHIFT_ASSIGN -POWER_ASSIGN -IDIV_ASSIGN -SKIP_ -UNKNOWN_CHAR -INDENT -DEDENT - -rule names: -single_input -file_input -eval_input -decorator -decorators -decorated -async_funcdef -funcdef -parameters -typedargslist -tfpdef -varargslist -vfpdef -stmt -simple_stmt -small_stmt -expr_stmt -annassign -testlist_star_expr -augassign -del_stmt -pass_stmt -flow_stmt -break_stmt -continue_stmt -return_stmt -yield_stmt -raise_stmt -import_stmt -import_name -import_from -import_as_name -dotted_as_name -import_as_names -dotted_as_names -dotted_name -global_stmt -nonlocal_stmt -assert_stmt -compound_stmt -async_stmt -if_stmt -while_stmt -for_stmt -try_stmt -with_stmt -with_item -except_clause -suite -test -test_nocond -lambdef -lambdef_nocond -or_test -and_test -not_test -comparison -comp_op -star_expr -expr -xor_expr -and_expr -shift_expr -arith_expr -term -factor -power -atom_expr -atom -testlist_comp -trailer -subscriptlist -subscript -sliceop -exprlist -testlist -dictorsetmaker -classdef -arglist -argument -comp_iter -comp_for -comp_if -encoding_decl -yield_expr -yield_arg - - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 101, 1106, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 180, 10, 2, 3, 3, 3, 3, 7, 3, 184, 10, 3, 12, 3, 14, 3, 187, 11, 3, 3, 3, 3, 3, 3, 4, 3, 4, 7, 4, 193, 10, 4, 12, 4, 14, 4, 196, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 204, 10, 5, 3, 5, 5, 5, 207, 10, 5, 3, 5, 3, 5, 3, 6, 6, 6, 212, 10, 6, 13, 6, 14, 6, 213, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 220, 10, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 230, 10, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 5, 10, 237, 10, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 5, 11, 244, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 250, 10, 11, 7, 11, 252, 10, 11, 12, 11, 14, 11, 255, 11, 11, 3, 11, 3, 11, 3, 11, 5, 11, 260, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 266, 10, 11, 7, 11, 268, 10, 11, 12, 11, 14, 11, 271, 11, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 277, 10, 11, 5, 11, 279, 10, 11, 5, 11, 281, 10, 11, 3, 11, 3, 11, 3, 11, 5, 11, 286, 10, 11, 5, 11, 288, 10, 11, 5, 11, 290, 10, 11, 3, 11, 3, 11, 5, 11, 294, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 300, 10, 11, 7, 11, 302, 10, 11, 12, 11, 14, 11, 305, 11, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 311, 10, 11, 5, 11, 313, 10, 11, 5, 11, 315, 10, 11, 3, 11, 3, 11, 3, 11, 5, 11, 320, 10, 11, 5, 11, 322, 10, 11, 3, 12, 3, 12, 3, 12, 5, 12, 327, 10, 12, 3, 13, 3, 13, 3, 13, 5, 13, 332, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 338, 10, 13, 7, 13, 340, 10, 13, 12, 13, 14, 13, 343, 11, 13, 3, 13, 3, 13, 3, 13, 5, 13, 348, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 354, 10, 13, 7, 13, 356, 10, 13, 12, 13, 14, 13, 359, 11, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 365, 10, 13, 5, 13, 367, 10, 13, 5, 13, 369, 10, 13, 3, 13, 3, 13, 3, 13, 5, 13, 374, 10, 13, 5, 13, 376, 10, 13, 5, 13, 378, 10, 13, 3, 13, 3, 13, 5, 13, 382, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 388, 10, 13, 7, 13, 390, 10, 13, 12, 13, 14, 13, 393, 11, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 399, 10, 13, 5, 13, 401, 10, 13, 5, 13, 403, 10, 13, 3, 13, 3, 13, 3, 13, 5, 13, 408, 10, 13, 5, 13, 410, 10, 13, 3, 14, 3, 14, 3, 15, 3, 15, 5, 15, 416, 10, 15, 3, 16, 3, 16, 3, 16, 7, 16, 421, 10, 16, 12, 16, 14, 16, 424, 11, 16, 3, 16, 5, 16, 427, 10, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 439, 10, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 446, 10, 18, 3, 18, 3, 18, 3, 18, 5, 18, 451, 10, 18, 7, 18, 453, 10, 18, 12, 18, 14, 18, 456, 11, 18, 5, 18, 458, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 464, 10, 19, 3, 20, 3, 20, 5, 20, 468, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 473, 10, 20, 7, 20, 475, 10, 20, 12, 20, 14, 20, 478, 11, 20, 3, 20, 5, 20, 481, 10, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 495, 10, 24, 3, 25, 3, 25, 3, 26, 3, 26, 3, 27, 3, 27, 5, 27, 503, 10, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 511, 10, 29, 5, 29, 513, 10, 29, 3, 30, 3, 30, 5, 30, 517, 10, 30, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 7, 32, 524, 10, 32, 12, 32, 14, 32, 527, 11, 32, 3, 32, 3, 32, 6, 32, 531, 10, 32, 13, 32, 14, 32, 532, 5, 32, 535, 10, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 5, 32, 544, 10, 32, 3, 33, 3, 33, 3, 33, 5, 33, 549, 10, 33, 3, 34, 3, 34, 3, 34, 5, 34, 554, 10, 34, 3, 35, 3, 35, 3, 35, 7, 35, 559, 10, 35, 12, 35, 14, 35, 562, 11, 35, 3, 35, 5, 35, 565, 10, 35, 3, 36, 3, 36, 3, 36, 7, 36, 570, 10, 36, 12, 36, 14, 36, 573, 11, 36, 3, 37, 3, 37, 3, 37, 7, 37, 578, 10, 37, 12, 37, 14, 37, 581, 11, 37, 3, 38, 3, 38, 3, 38, 3, 38, 7, 38, 587, 10, 38, 12, 38, 14, 38, 590, 11, 38, 3, 39, 3, 39, 3, 39, 3, 39, 7, 39, 596, 10, 39, 12, 39, 14, 39, 599, 11, 39, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 605, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5, 41, 616, 10, 41, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 622, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 7, 43, 633, 10, 43, 12, 43, 14, 43, 636, 11, 43, 3, 43, 3, 43, 3, 43, 5, 43, 641, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 650, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 661, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 6, 46, 670, 10, 46, 13, 46, 14, 46, 671, 3, 46, 3, 46, 3, 46, 5, 46, 677, 10, 46, 3, 46, 3, 46, 3, 46, 5, 46, 682, 10, 46, 3, 46, 3, 46, 3, 46, 5, 46, 687, 10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 7, 47, 693, 10, 47, 12, 47, 14, 47, 696, 11, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 5, 48, 704, 10, 48, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 710, 10, 49, 5, 49, 712, 10, 49, 3, 50, 3, 50, 3, 50, 3, 50, 6, 50, 718, 10, 50, 13, 50, 14, 50, 719, 3, 50, 3, 50, 5, 50, 724, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 732, 10, 51, 3, 51, 5, 51, 735, 10, 51, 3, 52, 3, 52, 5, 52, 739, 10, 52, 3, 53, 3, 53, 5, 53, 743, 10, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 5, 54, 750, 10, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 7, 55, 758, 10, 55, 12, 55, 14, 55, 761, 11, 55, 3, 56, 3, 56, 3, 56, 7, 56, 766, 10, 56, 12, 56, 14, 56, 769, 11, 56, 3, 57, 3, 57, 3, 57, 5, 57, 774, 10, 57, 3, 58, 3, 58, 3, 58, 3, 58, 7, 58, 780, 10, 58, 12, 58, 14, 58, 783, 11, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 798, 10, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 806, 10, 61, 12, 61, 14, 61, 809, 11, 61, 3, 62, 3, 62, 3, 62, 7, 62, 814, 10, 62, 12, 62, 14, 62, 817, 11, 62, 3, 63, 3, 63, 3, 63, 7, 63, 822, 10, 63, 12, 63, 14, 63, 825, 11, 63, 3, 64, 3, 64, 3, 64, 7, 64, 830, 10, 64, 12, 64, 14, 64, 833, 11, 64, 3, 65, 3, 65, 3, 65, 7, 65, 838, 10, 65, 12, 65, 14, 65, 841, 11, 65, 3, 66, 3, 66, 3, 66, 7, 66, 846, 10, 66, 12, 66, 14, 66, 849, 11, 66, 3, 67, 3, 67, 3, 67, 5, 67, 854, 10, 67, 3, 68, 3, 68, 3, 68, 5, 68, 859, 10, 68, 3, 69, 5, 69, 862, 10, 69, 3, 69, 3, 69, 7, 69, 866, 10, 69, 12, 69, 14, 69, 869, 11, 69, 3, 70, 3, 70, 3, 70, 5, 70, 874, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 879, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 884, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 6, 70, 890, 10, 70, 13, 70, 14, 70, 891, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 898, 10, 70, 3, 71, 3, 71, 5, 71, 902, 10, 71, 3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 908, 10, 71, 7, 71, 910, 10, 71, 12, 71, 14, 71, 913, 11, 71, 3, 71, 5, 71, 916, 10, 71, 5, 71, 918, 10, 71, 3, 72, 3, 72, 5, 72, 922, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 931, 10, 72, 3, 73, 3, 73, 3, 73, 7, 73, 936, 10, 73, 12, 73, 14, 73, 939, 11, 73, 3, 73, 5, 73, 942, 10, 73, 3, 74, 3, 74, 5, 74, 946, 10, 74, 3, 74, 3, 74, 5, 74, 950, 10, 74, 3, 74, 5, 74, 953, 10, 74, 5, 74, 955, 10, 74, 3, 75, 3, 75, 5, 75, 959, 10, 75, 3, 76, 3, 76, 5, 76, 963, 10, 76, 3, 76, 3, 76, 3, 76, 5, 76, 968, 10, 76, 7, 76, 970, 10, 76, 12, 76, 14, 76, 973, 11, 76, 3, 76, 5, 76, 976, 10, 76, 3, 77, 3, 77, 3, 77, 7, 77, 981, 10, 77, 12, 77, 14, 77, 984, 11, 77, 3, 77, 5, 77, 987, 10, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 995, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1005, 10, 78, 7, 78, 1007, 10, 78, 12, 78, 14, 78, 1010, 11, 78, 3, 78, 5, 78, 1013, 10, 78, 5, 78, 1015, 10, 78, 3, 78, 3, 78, 5, 78, 1019, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1025, 10, 78, 7, 78, 1027, 10, 78, 12, 78, 14, 78, 1030, 11, 78, 3, 78, 5, 78, 1033, 10, 78, 5, 78, 1035, 10, 78, 5, 78, 1037, 10, 78, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1043, 10, 79, 3, 79, 5, 79, 1046, 10, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 7, 80, 1054, 10, 80, 12, 80, 14, 80, 1057, 11, 80, 3, 80, 5, 80, 1060, 10, 80, 3, 81, 3, 81, 5, 81, 1064, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1074, 10, 81, 3, 82, 3, 82, 5, 82, 1078, 10, 82, 3, 83, 5, 83, 1081, 10, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 1088, 10, 83, 3, 84, 3, 84, 3, 84, 5, 84, 1093, 10, 84, 3, 85, 3, 85, 3, 86, 3, 86, 5, 86, 1099, 10, 86, 3, 87, 3, 87, 3, 87, 5, 87, 1104, 10, 87, 3, 87, 2, 2, 88, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 2, 8, 3, 2, 85, 97, 3, 2, 51, 52, 3, 2, 66, 67, 3, 2, 68, 69, 5, 2, 53, 53, 70, 72, 83, 83, 4, 2, 68, 69, 73, 73, 2, 1231, 2, 179, 3, 2, 2, 2, 4, 185, 3, 2, 2, 2, 6, 190, 3, 2, 2, 2, 8, 199, 3, 2, 2, 2, 10, 211, 3, 2, 2, 2, 12, 215, 3, 2, 2, 2, 14, 221, 3, 2, 2, 2, 16, 224, 3, 2, 2, 2, 18, 234, 3, 2, 2, 2, 20, 321, 3, 2, 2, 2, 22, 323, 3, 2, 2, 2, 24, 409, 3, 2, 2, 2, 26, 411, 3, 2, 2, 2, 28, 415, 3, 2, 2, 2, 30, 417, 3, 2, 2, 2, 32, 438, 3, 2, 2, 2, 34, 440, 3, 2, 2, 2, 36, 459, 3, 2, 2, 2, 38, 467, 3, 2, 2, 2, 40, 482, 3, 2, 2, 2, 42, 484, 3, 2, 2, 2, 44, 487, 3, 2, 2, 2, 46, 494, 3, 2, 2, 2, 48, 496, 3, 2, 2, 2, 50, 498, 3, 2, 2, 2, 52, 500, 3, 2, 2, 2, 54, 504, 3, 2, 2, 2, 56, 506, 3, 2, 2, 2, 58, 516, 3, 2, 2, 2, 60, 518, 3, 2, 2, 2, 62, 521, 3, 2, 2, 2, 64, 545, 3, 2, 2, 2, 66, 550, 3, 2, 2, 2, 68, 555, 3, 2, 2, 2, 70, 566, 3, 2, 2, 2, 72, 574, 3, 2, 2, 2, 74, 582, 3, 2, 2, 2, 76, 591, 3, 2, 2, 2, 78, 600, 3, 2, 2, 2, 80, 615, 3, 2, 2, 2, 82, 617, 3, 2, 2, 2, 84, 623, 3, 2, 2, 2, 86, 642, 3, 2, 2, 2, 88, 651, 3, 2, 2, 2, 90, 662, 3, 2, 2, 2, 92, 688, 3, 2, 2, 2, 94, 700, 3, 2, 2, 2, 96, 705, 3, 2, 2, 2, 98, 723, 3, 2, 2, 2, 100, 734, 3, 2, 2, 2, 102, 738, 3, 2, 2, 2, 104, 740, 3, 2, 2, 2, 106, 747, 3, 2, 2, 2, 108, 754, 3, 2, 2, 2, 110, 762, 3, 2, 2, 2, 112, 773, 3, 2, 2, 2, 114, 775, 3, 2, 2, 2, 116, 797, 3, 2, 2, 2, 118, 799, 3, 2, 2, 2, 120, 802, 3, 2, 2, 2, 122, 810, 3, 2, 2, 2, 124, 818, 3, 2, 2, 2, 126, 826, 3, 2, 2, 2, 128, 834, 3, 2, 2, 2, 130, 842, 3, 2, 2, 2, 132, 853, 3, 2, 2, 2, 134, 855, 3, 2, 2, 2, 136, 861, 3, 2, 2, 2, 138, 897, 3, 2, 2, 2, 140, 901, 3, 2, 2, 2, 142, 930, 3, 2, 2, 2, 144, 932, 3, 2, 2, 2, 146, 954, 3, 2, 2, 2, 148, 956, 3, 2, 2, 2, 150, 962, 3, 2, 2, 2, 152, 977, 3, 2, 2, 2, 154, 1036, 3, 2, 2, 2, 156, 1038, 3, 2, 2, 2, 158, 1050, 3, 2, 2, 2, 160, 1073, 3, 2, 2, 2, 162, 1077, 3, 2, 2, 2, 164, 1080, 3, 2, 2, 2, 166, 1089, 3, 2, 2, 2, 168, 1094, 3, 2, 2, 2, 170, 1096, 3, 2, 2, 2, 172, 1103, 3, 2, 2, 2, 174, 180, 7, 41, 2, 2, 175, 180, 5, 30, 16, 2, 176, 177, 5, 80, 41, 2, 177, 178, 7, 41, 2, 2, 178, 180, 3, 2, 2, 2, 179, 174, 3, 2, 2, 2, 179, 175, 3, 2, 2, 2, 179, 176, 3, 2, 2, 2, 180, 3, 3, 2, 2, 2, 181, 184, 7, 41, 2, 2, 182, 184, 5, 28, 15, 2, 183, 181, 3, 2, 2, 2, 183, 182, 3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 185, 186, 3, 2, 2, 2, 186, 188, 3, 2, 2, 2, 187, 185, 3, 2, 2, 2, 188, 189, 7, 2, 2, 3, 189, 5, 3, 2, 2, 2, 190, 194, 5, 152, 77, 2, 191, 193, 7, 41, 2, 2, 192, 191, 3, 2, 2, 2, 193, 196, 3, 2, 2, 2, 194, 192, 3, 2, 2, 2, 194, 195, 3, 2, 2, 2, 195, 197, 3, 2, 2, 2, 196, 194, 3, 2, 2, 2, 197, 198, 7, 2, 2, 3, 198, 7, 3, 2, 2, 2, 199, 200, 7, 83, 2, 2, 200, 206, 5, 72, 37, 2, 201, 203, 7, 54, 2, 2, 202, 204, 5, 158, 80, 2, 203, 202, 3, 2, 2, 2, 203, 204, 3, 2, 2, 2, 204, 205, 3, 2, 2, 2, 205, 207, 7, 55, 2, 2, 206, 201, 3, 2, 2, 2, 206, 207, 3, 2, 2, 2, 207, 208, 3, 2, 2, 2, 208, 209, 7, 41, 2, 2, 209, 9, 3, 2, 2, 2, 210, 212, 5, 8, 5, 2, 211, 210, 3, 2, 2, 2, 212, 213, 3, 2, 2, 2, 213, 211, 3, 2, 2, 2, 213, 214, 3, 2, 2, 2, 214, 11, 3, 2, 2, 2, 215, 219, 5, 10, 6, 2, 216, 220, 5, 156, 79, 2, 217, 220, 5, 16, 9, 2, 218, 220, 5, 14, 8, 2, 219, 216, 3, 2, 2, 2, 219, 217, 3, 2, 2, 2, 219, 218, 3, 2, 2, 2, 220, 13, 3, 2, 2, 2, 221, 222, 7, 39, 2, 2, 222, 223, 5, 16, 9, 2, 223, 15, 3, 2, 2, 2, 224, 225, 7, 6, 2, 2, 225, 226, 7, 42, 2, 2, 226, 229, 5, 18, 10, 2, 227, 228, 7, 84, 2, 2, 228, 230, 5, 100, 51, 2, 229, 227, 3, 2, 2, 2, 229, 230, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 232, 7, 57, 2, 2, 232, 233, 5, 98, 50, 2, 233, 17, 3, 2, 2, 2, 234, 236, 7, 54, 2, 2, 235, 237, 5, 20, 11, 2, 236, 235, 3, 2, 2, 2, 236, 237, 3, 2, 2, 2, 237, 238, 3, 2, 2, 2, 238, 239, 7, 55, 2, 2, 239, 19, 3, 2, 2, 2, 240, 243, 5, 22, 12, 2, 241, 242, 7, 60, 2, 2, 242, 244, 5, 100, 51, 2, 243, 241, 3, 2, 2, 2, 243, 244, 3, 2, 2, 2, 244, 253, 3, 2, 2, 2, 245, 246, 7, 56, 2, 2, 246, 249, 5, 22, 12, 2, 247, 248, 7, 60, 2, 2, 248, 250, 5, 100, 51, 2, 249, 247, 3, 2, 2, 2, 249, 250, 3, 2, 2, 2, 250, 252, 3, 2, 2, 2, 251, 245, 3, 2, 2, 2, 252, 255, 3, 2, 2, 2, 253, 251, 3, 2, 2, 2, 253, 254, 3, 2, 2, 2, 254, 289, 3, 2, 2, 2, 255, 253, 3, 2, 2, 2, 256, 287, 7, 56, 2, 2, 257, 259, 7, 53, 2, 2, 258, 260, 5, 22, 12, 2, 259, 258, 3, 2, 2, 2, 259, 260, 3, 2, 2, 2, 260, 269, 3, 2, 2, 2, 261, 262, 7, 56, 2, 2, 262, 265, 5, 22, 12, 2, 263, 264, 7, 60, 2, 2, 264, 266, 5, 100, 51, 2, 265, 263, 3, 2, 2, 2, 265, 266, 3, 2, 2, 2, 266, 268, 3, 2, 2, 2, 267, 261, 3, 2, 2, 2, 268, 271, 3, 2, 2, 2, 269, 267, 3, 2, 2, 2, 269, 270, 3, 2, 2, 2, 270, 280, 3, 2, 2, 2, 271, 269, 3, 2, 2, 2, 272, 278, 7, 56, 2, 2, 273, 274, 7, 59, 2, 2, 274, 276, 5, 22, 12, 2, 275, 277, 7, 56, 2, 2, 276, 275, 3, 2, 2, 2, 276, 277, 3, 2, 2, 2, 277, 279, 3, 2, 2, 2, 278, 273, 3, 2, 2, 2, 278, 279, 3, 2, 2, 2, 279, 281, 3, 2, 2, 2, 280, 272, 3, 2, 2, 2, 280, 281, 3, 2, 2, 2, 281, 288, 3, 2, 2, 2, 282, 283, 7, 59, 2, 2, 283, 285, 5, 22, 12, 2, 284, 286, 7, 56, 2, 2, 285, 284, 3, 2, 2, 2, 285, 286, 3, 2, 2, 2, 286, 288, 3, 2, 2, 2, 287, 257, 3, 2, 2, 2, 287, 282, 3, 2, 2, 2, 287, 288, 3, 2, 2, 2, 288, 290, 3, 2, 2, 2, 289, 256, 3, 2, 2, 2, 289, 290, 3, 2, 2, 2, 290, 322, 3, 2, 2, 2, 291, 293, 7, 53, 2, 2, 292, 294, 5, 22, 12, 2, 293, 292, 3, 2, 2, 2, 293, 294, 3, 2, 2, 2, 294, 303, 3, 2, 2, 2, 295, 296, 7, 56, 2, 2, 296, 299, 5, 22, 12, 2, 297, 298, 7, 60, 2, 2, 298, 300, 5, 100, 51, 2, 299, 297, 3, 2, 2, 2, 299, 300, 3, 2, 2, 2, 300, 302, 3, 2, 2, 2, 301, 295, 3, 2, 2, 2, 302, 305, 3, 2, 2, 2, 303, 301, 3, 2, 2, 2, 303, 304, 3, 2, 2, 2, 304, 314, 3, 2, 2, 2, 305, 303, 3, 2, 2, 2, 306, 312, 7, 56, 2, 2, 307, 308, 7, 59, 2, 2, 308, 310, 5, 22, 12, 2, 309, 311, 7, 56, 2, 2, 310, 309, 3, 2, 2, 2, 310, 311, 3, 2, 2, 2, 311, 313, 3, 2, 2, 2, 312, 307, 3, 2, 2, 2, 312, 313, 3, 2, 2, 2, 313, 315, 3, 2, 2, 2, 314, 306, 3, 2, 2, 2, 314, 315, 3, 2, 2, 2, 315, 322, 3, 2, 2, 2, 316, 317, 7, 59, 2, 2, 317, 319, 5, 22, 12, 2, 318, 320, 7, 56, 2, 2, 319, 318, 3, 2, 2, 2, 319, 320, 3, 2, 2, 2, 320, 322, 3, 2, 2, 2, 321, 240, 3, 2, 2, 2, 321, 291, 3, 2, 2, 2, 321, 316, 3, 2, 2, 2, 322, 21, 3, 2, 2, 2, 323, 326, 7, 42, 2, 2, 324, 325, 7, 57, 2, 2, 325, 327, 5, 100, 51, 2, 326, 324, 3, 2, 2, 2, 326, 327, 3, 2, 2, 2, 327, 23, 3, 2, 2, 2, 328, 331, 5, 26, 14, 2, 329, 330, 7, 60, 2, 2, 330, 332, 5, 100, 51, 2, 331, 329, 3, 2, 2, 2, 331, 332, 3, 2, 2, 2, 332, 341, 3, 2, 2, 2, 333, 334, 7, 56, 2, 2, 334, 337, 5, 26, 14, 2, 335, 336, 7, 60, 2, 2, 336, 338, 5, 100, 51, 2, 337, 335, 3, 2, 2, 2, 337, 338, 3, 2, 2, 2, 338, 340, 3, 2, 2, 2, 339, 333, 3, 2, 2, 2, 340, 343, 3, 2, 2, 2, 341, 339, 3, 2, 2, 2, 341, 342, 3, 2, 2, 2, 342, 377, 3, 2, 2, 2, 343, 341, 3, 2, 2, 2, 344, 375, 7, 56, 2, 2, 345, 347, 7, 53, 2, 2, 346, 348, 5, 26, 14, 2, 347, 346, 3, 2, 2, 2, 347, 348, 3, 2, 2, 2, 348, 357, 3, 2, 2, 2, 349, 350, 7, 56, 2, 2, 350, 353, 5, 26, 14, 2, 351, 352, 7, 60, 2, 2, 352, 354, 5, 100, 51, 2, 353, 351, 3, 2, 2, 2, 353, 354, 3, 2, 2, 2, 354, 356, 3, 2, 2, 2, 355, 349, 3, 2, 2, 2, 356, 359, 3, 2, 2, 2, 357, 355, 3, 2, 2, 2, 357, 358, 3, 2, 2, 2, 358, 368, 3, 2, 2, 2, 359, 357, 3, 2, 2, 2, 360, 366, 7, 56, 2, 2, 361, 362, 7, 59, 2, 2, 362, 364, 5, 26, 14, 2, 363, 365, 7, 56, 2, 2, 364, 363, 3, 2, 2, 2, 364, 365, 3, 2, 2, 2, 365, 367, 3, 2, 2, 2, 366, 361, 3, 2, 2, 2, 366, 367, 3, 2, 2, 2, 367, 369, 3, 2, 2, 2, 368, 360, 3, 2, 2, 2, 368, 369, 3, 2, 2, 2, 369, 376, 3, 2, 2, 2, 370, 371, 7, 59, 2, 2, 371, 373, 5, 26, 14, 2, 372, 374, 7, 56, 2, 2, 373, 372, 3, 2, 2, 2, 373, 374, 3, 2, 2, 2, 374, 376, 3, 2, 2, 2, 375, 345, 3, 2, 2, 2, 375, 370, 3, 2, 2, 2, 375, 376, 3, 2, 2, 2, 376, 378, 3, 2, 2, 2, 377, 344, 3, 2, 2, 2, 377, 378, 3, 2, 2, 2, 378, 410, 3, 2, 2, 2, 379, 381, 7, 53, 2, 2, 380, 382, 5, 26, 14, 2, 381, 380, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 391, 3, 2, 2, 2, 383, 384, 7, 56, 2, 2, 384, 387, 5, 26, 14, 2, 385, 386, 7, 60, 2, 2, 386, 388, 5, 100, 51, 2, 387, 385, 3, 2, 2, 2, 387, 388, 3, 2, 2, 2, 388, 390, 3, 2, 2, 2, 389, 383, 3, 2, 2, 2, 390, 393, 3, 2, 2, 2, 391, 389, 3, 2, 2, 2, 391, 392, 3, 2, 2, 2, 392, 402, 3, 2, 2, 2, 393, 391, 3, 2, 2, 2, 394, 400, 7, 56, 2, 2, 395, 396, 7, 59, 2, 2, 396, 398, 5, 26, 14, 2, 397, 399, 7, 56, 2, 2, 398, 397, 3, 2, 2, 2, 398, 399, 3, 2, 2, 2, 399, 401, 3, 2, 2, 2, 400, 395, 3, 2, 2, 2, 400, 401, 3, 2, 2, 2, 401, 403, 3, 2, 2, 2, 402, 394, 3, 2, 2, 2, 402, 403, 3, 2, 2, 2, 403, 410, 3, 2, 2, 2, 404, 405, 7, 59, 2, 2, 405, 407, 5, 26, 14, 2, 406, 408, 7, 56, 2, 2, 407, 406, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 410, 3, 2, 2, 2, 409, 328, 3, 2, 2, 2, 409, 379, 3, 2, 2, 2, 409, 404, 3, 2, 2, 2, 410, 25, 3, 2, 2, 2, 411, 412, 7, 42, 2, 2, 412, 27, 3, 2, 2, 2, 413, 416, 5, 30, 16, 2, 414, 416, 5, 80, 41, 2, 415, 413, 3, 2, 2, 2, 415, 414, 3, 2, 2, 2, 416, 29, 3, 2, 2, 2, 417, 422, 5, 32, 17, 2, 418, 419, 7, 58, 2, 2, 419, 421, 5, 32, 17, 2, 420, 418, 3, 2, 2, 2, 421, 424, 3, 2, 2, 2, 422, 420, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 423, 426, 3, 2, 2, 2, 424, 422, 3, 2, 2, 2, 425, 427, 7, 58, 2, 2, 426, 425, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 429, 7, 41, 2, 2, 429, 31, 3, 2, 2, 2, 430, 439, 5, 34, 18, 2, 431, 439, 5, 42, 22, 2, 432, 439, 5, 44, 23, 2, 433, 439, 5, 46, 24, 2, 434, 439, 5, 58, 30, 2, 435, 439, 5, 74, 38, 2, 436, 439, 5, 76, 39, 2, 437, 439, 5, 78, 40, 2, 438, 430, 3, 2, 2, 2, 438, 431, 3, 2, 2, 2, 438, 432, 3, 2, 2, 2, 438, 433, 3, 2, 2, 2, 438, 434, 3, 2, 2, 2, 438, 435, 3, 2, 2, 2, 438, 436, 3, 2, 2, 2, 438, 437, 3, 2, 2, 2, 439, 33, 3, 2, 2, 2, 440, 457, 5, 38, 20, 2, 441, 458, 5, 36, 19, 2, 442, 445, 5, 40, 21, 2, 443, 446, 5, 170, 86, 2, 444, 446, 5, 152, 77, 2, 445, 443, 3, 2, 2, 2, 445, 444, 3, 2, 2, 2, 446, 458, 3, 2, 2, 2, 447, 450, 7, 60, 2, 2, 448, 451, 5, 170, 86, 2, 449, 451, 5, 38, 20, 2, 450, 448, 3, 2, 2, 2, 450, 449, 3, 2, 2, 2, 451, 453, 3, 2, 2, 2, 452, 447, 3, 2, 2, 2, 453, 456, 3, 2, 2, 2, 454, 452, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 458, 3, 2, 2, 2, 456, 454, 3, 2, 2, 2, 457, 441, 3, 2, 2, 2, 457, 442, 3, 2, 2, 2, 457, 454, 3, 2, 2, 2, 458, 35, 3, 2, 2, 2, 459, 460, 7, 57, 2, 2, 460, 463, 5, 100, 51, 2, 461, 462, 7, 60, 2, 2, 462, 464, 5, 100, 51, 2, 463, 461, 3, 2, 2, 2, 463, 464, 3, 2, 2, 2, 464, 37, 3, 2, 2, 2, 465, 468, 5, 100, 51, 2, 466, 468, 5, 118, 60, 2, 467, 465, 3, 2, 2, 2, 467, 466, 3, 2, 2, 2, 468, 476, 3, 2, 2, 2, 469, 472, 7, 56, 2, 2, 470, 473, 5, 100, 51, 2, 471, 473, 5, 118, 60, 2, 472, 470, 3, 2, 2, 2, 472, 471, 3, 2, 2, 2, 473, 475, 3, 2, 2, 2, 474, 469, 3, 2, 2, 2, 475, 478, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 476, 477, 3, 2, 2, 2, 477, 480, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 479, 481, 7, 56, 2, 2, 480, 479, 3, 2, 2, 2, 480, 481, 3, 2, 2, 2, 481, 39, 3, 2, 2, 2, 482, 483, 9, 2, 2, 2, 483, 41, 3, 2, 2, 2, 484, 485, 7, 35, 2, 2, 485, 486, 5, 150, 76, 2, 486, 43, 3, 2, 2, 2, 487, 488, 7, 36, 2, 2, 488, 45, 3, 2, 2, 2, 489, 495, 5, 48, 25, 2, 490, 495, 5, 50, 26, 2, 491, 495, 5, 52, 27, 2, 492, 495, 5, 56, 29, 2, 493, 495, 5, 54, 28, 2, 494, 489, 3, 2, 2, 2, 494, 490, 3, 2, 2, 2, 494, 491, 3, 2, 2, 2, 494, 492, 3, 2, 2, 2, 494, 493, 3, 2, 2, 2, 495, 47, 3, 2, 2, 2, 496, 497, 7, 38, 2, 2, 497, 49, 3, 2, 2, 2, 498, 499, 7, 37, 2, 2, 499, 51, 3, 2, 2, 2, 500, 502, 7, 7, 2, 2, 501, 503, 5, 152, 77, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 53, 3, 2, 2, 2, 504, 505, 5, 170, 86, 2, 505, 55, 3, 2, 2, 2, 506, 512, 7, 8, 2, 2, 507, 510, 5, 100, 51, 2, 508, 509, 7, 9, 2, 2, 509, 511, 5, 100, 51, 2, 510, 508, 3, 2, 2, 2, 510, 511, 3, 2, 2, 2, 511, 513, 3, 2, 2, 2, 512, 507, 3, 2, 2, 2, 512, 513, 3, 2, 2, 2, 513, 57, 3, 2, 2, 2, 514, 517, 5, 60, 31, 2, 515, 517, 5, 62, 32, 2, 516, 514, 3, 2, 2, 2, 516, 515, 3, 2, 2, 2, 517, 59, 3, 2, 2, 2, 518, 519, 7, 10, 2, 2, 519, 520, 5, 70, 36, 2, 520, 61, 3, 2, 2, 2, 521, 534, 7, 9, 2, 2, 522, 524, 9, 3, 2, 2, 523, 522, 3, 2, 2, 2, 524, 527, 3, 2, 2, 2, 525, 523, 3, 2, 2, 2, 525, 526, 3, 2, 2, 2, 526, 528, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 528, 535, 5, 72, 37, 2, 529, 531, 9, 3, 2, 2, 530, 529, 3, 2, 2, 2, 531, 532, 3, 2, 2, 2, 532, 530, 3, 2, 2, 2, 532, 533, 3, 2, 2, 2, 533, 535, 3, 2, 2, 2, 534, 525, 3, 2, 2, 2, 534, 530, 3, 2, 2, 2, 535, 536, 3, 2, 2, 2, 536, 543, 7, 10, 2, 2, 537, 544, 7, 53, 2, 2, 538, 539, 7, 54, 2, 2, 539, 540, 5, 68, 35, 2, 540, 541, 7, 55, 2, 2, 541, 544, 3, 2, 2, 2, 542, 544, 5, 68, 35, 2, 543, 537, 3, 2, 2, 2, 543, 538, 3, 2, 2, 2, 543, 542, 3, 2, 2, 2, 544, 63, 3, 2, 2, 2, 545, 548, 7, 42, 2, 2, 546, 547, 7, 11, 2, 2, 547, 549, 7, 42, 2, 2, 548, 546, 3, 2, 2, 2, 548, 549, 3, 2, 2, 2, 549, 65, 3, 2, 2, 2, 550, 553, 5, 72, 37, 2, 551, 552, 7, 11, 2, 2, 552, 554, 7, 42, 2, 2, 553, 551, 3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 67, 3, 2, 2, 2, 555, 560, 5, 64, 33, 2, 556, 557, 7, 56, 2, 2, 557, 559, 5, 64, 33, 2, 558, 556, 3, 2, 2, 2, 559, 562, 3, 2, 2, 2, 560, 558, 3, 2, 2, 2, 560, 561, 3, 2, 2, 2, 561, 564, 3, 2, 2, 2, 562, 560, 3, 2, 2, 2, 563, 565, 7, 56, 2, 2, 564, 563, 3, 2, 2, 2, 564, 565, 3, 2, 2, 2, 565, 69, 3, 2, 2, 2, 566, 571, 5, 66, 34, 2, 567, 568, 7, 56, 2, 2, 568, 570, 5, 66, 34, 2, 569, 567, 3, 2, 2, 2, 570, 573, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572, 71, 3, 2, 2, 2, 573, 571, 3, 2, 2, 2, 574, 579, 7, 42, 2, 2, 575, 576, 7, 51, 2, 2, 576, 578, 7, 42, 2, 2, 577, 575, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 579, 580, 3, 2, 2, 2, 580, 73, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 582, 583, 7, 12, 2, 2, 583, 588, 7, 42, 2, 2, 584, 585, 7, 56, 2, 2, 585, 587, 7, 42, 2, 2, 586, 584, 3, 2, 2, 2, 587, 590, 3, 2, 2, 2, 588, 586, 3, 2, 2, 2, 588, 589, 3, 2, 2, 2, 589, 75, 3, 2, 2, 2, 590, 588, 3, 2, 2, 2, 591, 592, 7, 13, 2, 2, 592, 597, 7, 42, 2, 2, 593, 594, 7, 56, 2, 2, 594, 596, 7, 42, 2, 2, 595, 593, 3, 2, 2, 2, 596, 599, 3, 2, 2, 2, 597, 595, 3, 2, 2, 2, 597, 598, 3, 2, 2, 2, 598, 77, 3, 2, 2, 2, 599, 597, 3, 2, 2, 2, 600, 601, 7, 14, 2, 2, 601, 604, 5, 100, 51, 2, 602, 603, 7, 56, 2, 2, 603, 605, 5, 100, 51, 2, 604, 602, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 79, 3, 2, 2, 2, 606, 616, 5, 84, 43, 2, 607, 616, 5, 86, 44, 2, 608, 616, 5, 88, 45, 2, 609, 616, 5, 90, 46, 2, 610, 616, 5, 92, 47, 2, 611, 616, 5, 16, 9, 2, 612, 616, 5, 156, 79, 2, 613, 616, 5, 12, 7, 2, 614, 616, 5, 82, 42, 2, 615, 606, 3, 2, 2, 2, 615, 607, 3, 2, 2, 2, 615, 608, 3, 2, 2, 2, 615, 609, 3, 2, 2, 2, 615, 610, 3, 2, 2, 2, 615, 611, 3, 2, 2, 2, 615, 612, 3, 2, 2, 2, 615, 613, 3, 2, 2, 2, 615, 614, 3, 2, 2, 2, 616, 81, 3, 2, 2, 2, 617, 621, 7, 39, 2, 2, 618, 622, 5, 16, 9, 2, 619, 622, 5, 92, 47, 2, 620, 622, 5, 88, 45, 2, 621, 618, 3, 2, 2, 2, 621, 619, 3, 2, 2, 2, 621, 620, 3, 2, 2, 2, 622, 83, 3, 2, 2, 2, 623, 624, 7, 15, 2, 2, 624, 625, 5, 100, 51, 2, 625, 626, 7, 57, 2, 2, 626, 634, 5, 98, 50, 2, 627, 628, 7, 16, 2, 2, 628, 629, 5, 100, 51, 2, 629, 630, 7, 57, 2, 2, 630, 631, 5, 98, 50, 2, 631, 633, 3, 2, 2, 2, 632, 627, 3, 2, 2, 2, 633, 636, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 634, 635, 3, 2, 2, 2, 635, 640, 3, 2, 2, 2, 636, 634, 3, 2, 2, 2, 637, 638, 7, 17, 2, 2, 638, 639, 7, 57, 2, 2, 639, 641, 5, 98, 50, 2, 640, 637, 3, 2, 2, 2, 640, 641, 3, 2, 2, 2, 641, 85, 3, 2, 2, 2, 642, 643, 7, 18, 2, 2, 643, 644, 5, 100, 51, 2, 644, 645, 7, 57, 2, 2, 645, 649, 5, 98, 50, 2, 646, 647, 7, 17, 2, 2, 647, 648, 7, 57, 2, 2, 648, 650, 5, 98, 50, 2, 649, 646, 3, 2, 2, 2, 649, 650, 3, 2, 2, 2, 650, 87, 3, 2, 2, 2, 651, 652, 7, 19, 2, 2, 652, 653, 5, 150, 76, 2, 653, 654, 7, 20, 2, 2, 654, 655, 5, 152, 77, 2, 655, 656, 7, 57, 2, 2, 656, 660, 5, 98, 50, 2, 657, 658, 7, 17, 2, 2, 658, 659, 7, 57, 2, 2, 659, 661, 5, 98, 50, 2, 660, 657, 3, 2, 2, 2, 660, 661, 3, 2, 2, 2, 661, 89, 3, 2, 2, 2, 662, 663, 7, 21, 2, 2, 663, 664, 7, 57, 2, 2, 664, 686, 5, 98, 50, 2, 665, 666, 5, 96, 49, 2, 666, 667, 7, 57, 2, 2, 667, 668, 5, 98, 50, 2, 668, 670, 3, 2, 2, 2, 669, 665, 3, 2, 2, 2, 670, 671, 3, 2, 2, 2, 671, 669, 3, 2, 2, 2, 671, 672, 3, 2, 2, 2, 672, 676, 3, 2, 2, 2, 673, 674, 7, 17, 2, 2, 674, 675, 7, 57, 2, 2, 675, 677, 5, 98, 50, 2, 676, 673, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 681, 3, 2, 2, 2, 678, 679, 7, 22, 2, 2, 679, 680, 7, 57, 2, 2, 680, 682, 5, 98, 50, 2, 681, 678, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 687, 3, 2, 2, 2, 683, 684, 7, 22, 2, 2, 684, 685, 7, 57, 2, 2, 685, 687, 5, 98, 50, 2, 686, 669, 3, 2, 2, 2, 686, 683, 3, 2, 2, 2, 687, 91, 3, 2, 2, 2, 688, 689, 7, 23, 2, 2, 689, 694, 5, 94, 48, 2, 690, 691, 7, 56, 2, 2, 691, 693, 5, 94, 48, 2, 692, 690, 3, 2, 2, 2, 693, 696, 3, 2, 2, 2, 694, 692, 3, 2, 2, 2, 694, 695, 3, 2, 2, 2, 695, 697, 3, 2, 2, 2, 696, 694, 3, 2, 2, 2, 697, 698, 7, 57, 2, 2, 698, 699, 5, 98, 50, 2, 699, 93, 3, 2, 2, 2, 700, 703, 5, 100, 51, 2, 701, 702, 7, 11, 2, 2, 702, 704, 5, 120, 61, 2, 703, 701, 3, 2, 2, 2, 703, 704, 3, 2, 2, 2, 704, 95, 3, 2, 2, 2, 705, 711, 7, 24, 2, 2, 706, 709, 5, 100, 51, 2, 707, 708, 7, 11, 2, 2, 708, 710, 7, 42, 2, 2, 709, 707, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 712, 3, 2, 2, 2, 711, 706, 3, 2, 2, 2, 711, 712, 3, 2, 2, 2, 712, 97, 3, 2, 2, 2, 713, 724, 5, 30, 16, 2, 714, 715, 7, 41, 2, 2, 715, 717, 7, 100, 2, 2, 716, 718, 5, 28, 15, 2, 717, 716, 3, 2, 2, 2, 718, 719, 3, 2, 2, 2, 719, 717, 3, 2, 2, 2, 719, 720, 3, 2, 2, 2, 720, 721, 3, 2, 2, 2, 721, 722, 7, 101, 2, 2, 722, 724, 3, 2, 2, 2, 723, 713, 3, 2, 2, 2, 723, 714, 3, 2, 2, 2, 724, 99, 3, 2, 2, 2, 725, 731, 5, 108, 55, 2, 726, 727, 7, 15, 2, 2, 727, 728, 5, 108, 55, 2, 728, 729, 7, 17, 2, 2, 729, 730, 5, 100, 51, 2, 730, 732, 3, 2, 2, 2, 731, 726, 3, 2, 2, 2, 731, 732, 3, 2, 2, 2, 732, 735, 3, 2, 2, 2, 733, 735, 5, 104, 53, 2, 734, 725, 3, 2, 2, 2, 734, 733, 3, 2, 2, 2, 735, 101, 3, 2, 2, 2, 736, 739, 5, 108, 55, 2, 737, 739, 5, 106, 54, 2, 738, 736, 3, 2, 2, 2, 738, 737, 3, 2, 2, 2, 739, 103, 3, 2, 2, 2, 740, 742, 7, 25, 2, 2, 741, 743, 5, 24, 13, 2, 742, 741, 3, 2, 2, 2, 742, 743, 3, 2, 2, 2, 743, 744, 3, 2, 2, 2, 744, 745, 7, 57, 2, 2, 745, 746, 5, 100, 51, 2, 746, 105, 3, 2, 2, 2, 747, 749, 7, 25, 2, 2, 748, 750, 5, 24, 13, 2, 749, 748, 3, 2, 2, 2, 749, 750, 3, 2, 2, 2, 750, 751, 3, 2, 2, 2, 751, 752, 7, 57, 2, 2, 752, 753, 5, 102, 52, 2, 753, 107, 3, 2, 2, 2, 754, 759, 5, 110, 56, 2, 755, 756, 7, 26, 2, 2, 756, 758, 5, 110, 56, 2, 757, 755, 3, 2, 2, 2, 758, 761, 3, 2, 2, 2, 759, 757, 3, 2, 2, 2, 759, 760, 3, 2, 2, 2, 760, 109, 3, 2, 2, 2, 761, 759, 3, 2, 2, 2, 762, 767, 5, 112, 57, 2, 763, 764, 7, 27, 2, 2, 764, 766, 5, 112, 57, 2, 765, 763, 3, 2, 2, 2, 766, 769, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 767, 768, 3, 2, 2, 2, 768, 111, 3, 2, 2, 2, 769, 767, 3, 2, 2, 2, 770, 771, 7, 28, 2, 2, 771, 774, 5, 112, 57, 2, 772, 774, 5, 114, 58, 2, 773, 770, 3, 2, 2, 2, 773, 772, 3, 2, 2, 2, 774, 113, 3, 2, 2, 2, 775, 781, 5, 120, 61, 2, 776, 777, 5, 116, 59, 2, 777, 778, 5, 120, 61, 2, 778, 780, 3, 2, 2, 2, 779, 776, 3, 2, 2, 2, 780, 783, 3, 2, 2, 2, 781, 779, 3, 2, 2, 2, 781, 782, 3, 2, 2, 2, 782, 115, 3, 2, 2, 2, 783, 781, 3, 2, 2, 2, 784, 798, 7, 76, 2, 2, 785, 798, 7, 77, 2, 2, 786, 798, 7, 78, 2, 2, 787, 798, 7, 79, 2, 2, 788, 798, 7, 80, 2, 2, 789, 798, 7, 81, 2, 2, 790, 798, 7, 82, 2, 2, 791, 798, 7, 20, 2, 2, 792, 793, 7, 28, 2, 2, 793, 798, 7, 20, 2, 2, 794, 798, 7, 29, 2, 2, 795, 796, 7, 29, 2, 2, 796, 798, 7, 28, 2, 2, 797, 784, 3, 2, 2, 2, 797, 785, 3, 2, 2, 2, 797, 786, 3, 2, 2, 2, 797, 787, 3, 2, 2, 2, 797, 788, 3, 2, 2, 2, 797, 789, 3, 2, 2, 2, 797, 790, 3, 2, 2, 2, 797, 791, 3, 2, 2, 2, 797, 792, 3, 2, 2, 2, 797, 794, 3, 2, 2, 2, 797, 795, 3, 2, 2, 2, 798, 117, 3, 2, 2, 2, 799, 800, 7, 53, 2, 2, 800, 801, 5, 120, 61, 2, 801, 119, 3, 2, 2, 2, 802, 807, 5, 122, 62, 2, 803, 804, 7, 63, 2, 2, 804, 806, 5, 122, 62, 2, 805, 803, 3, 2, 2, 2, 806, 809, 3, 2, 2, 2, 807, 805, 3, 2, 2, 2, 807, 808, 3, 2, 2, 2, 808, 121, 3, 2, 2, 2, 809, 807, 3, 2, 2, 2, 810, 815, 5, 124, 63, 2, 811, 812, 7, 64, 2, 2, 812, 814, 5, 124, 63, 2, 813, 811, 3, 2, 2, 2, 814, 817, 3, 2, 2, 2, 815, 813, 3, 2, 2, 2, 815, 816, 3, 2, 2, 2, 816, 123, 3, 2, 2, 2, 817, 815, 3, 2, 2, 2, 818, 823, 5, 126, 64, 2, 819, 820, 7, 65, 2, 2, 820, 822, 5, 126, 64, 2, 821, 819, 3, 2, 2, 2, 822, 825, 3, 2, 2, 2, 823, 821, 3, 2, 2, 2, 823, 824, 3, 2, 2, 2, 824, 125, 3, 2, 2, 2, 825, 823, 3, 2, 2, 2, 826, 831, 5, 128, 65, 2, 827, 828, 9, 4, 2, 2, 828, 830, 5, 128, 65, 2, 829, 827, 3, 2, 2, 2, 830, 833, 3, 2, 2, 2, 831, 829, 3, 2, 2, 2, 831, 832, 3, 2, 2, 2, 832, 127, 3, 2, 2, 2, 833, 831, 3, 2, 2, 2, 834, 839, 5, 130, 66, 2, 835, 836, 9, 5, 2, 2, 836, 838, 5, 130, 66, 2, 837, 835, 3, 2, 2, 2, 838, 841, 3, 2, 2, 2, 839, 837, 3, 2, 2, 2, 839, 840, 3, 2, 2, 2, 840, 129, 3, 2, 2, 2, 841, 839, 3, 2, 2, 2, 842, 847, 5, 132, 67, 2, 843, 844, 9, 6, 2, 2, 844, 846, 5, 132, 67, 2, 845, 843, 3, 2, 2, 2, 846, 849, 3, 2, 2, 2, 847, 845, 3, 2, 2, 2, 847, 848, 3, 2, 2, 2, 848, 131, 3, 2, 2, 2, 849, 847, 3, 2, 2, 2, 850, 851, 9, 7, 2, 2, 851, 854, 5, 132, 67, 2, 852, 854, 5, 134, 68, 2, 853, 850, 3, 2, 2, 2, 853, 852, 3, 2, 2, 2, 854, 133, 3, 2, 2, 2, 855, 858, 5, 136, 69, 2, 856, 857, 7, 59, 2, 2, 857, 859, 5, 132, 67, 2, 858, 856, 3, 2, 2, 2, 858, 859, 3, 2, 2, 2, 859, 135, 3, 2, 2, 2, 860, 862, 7, 40, 2, 2, 861, 860, 3, 2, 2, 2, 861, 862, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 867, 5, 138, 70, 2, 864, 866, 5, 142, 72, 2, 865, 864, 3, 2, 2, 2, 866, 869, 3, 2, 2, 2, 867, 865, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 137, 3, 2, 2, 2, 869, 867, 3, 2, 2, 2, 870, 873, 7, 54, 2, 2, 871, 874, 5, 170, 86, 2, 872, 874, 5, 140, 71, 2, 873, 871, 3, 2, 2, 2, 873, 872, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 875, 3, 2, 2, 2, 875, 898, 7, 55, 2, 2, 876, 878, 7, 61, 2, 2, 877, 879, 5, 140, 71, 2, 878, 877, 3, 2, 2, 2, 878, 879, 3, 2, 2, 2, 879, 880, 3, 2, 2, 2, 880, 898, 7, 62, 2, 2, 881, 883, 7, 74, 2, 2, 882, 884, 5, 154, 78, 2, 883, 882, 3, 2, 2, 2, 883, 884, 3, 2, 2, 2, 884, 885, 3, 2, 2, 2, 885, 898, 7, 75, 2, 2, 886, 898, 7, 42, 2, 2, 887, 898, 7, 4, 2, 2, 888, 890, 7, 3, 2, 2, 889, 888, 3, 2, 2, 2, 890, 891, 3, 2, 2, 2, 891, 889, 3, 2, 2, 2, 891, 892, 3, 2, 2, 2, 892, 898, 3, 2, 2, 2, 893, 898, 7, 52, 2, 2, 894, 898, 7, 30, 2, 2, 895, 898, 7, 31, 2, 2, 896, 898, 7, 32, 2, 2, 897, 870, 3, 2, 2, 2, 897, 876, 3, 2, 2, 2, 897, 881, 3, 2, 2, 2, 897, 886, 3, 2, 2, 2, 897, 887, 3, 2, 2, 2, 897, 889, 3, 2, 2, 2, 897, 893, 3, 2, 2, 2, 897, 894, 3, 2, 2, 2, 897, 895, 3, 2, 2, 2, 897, 896, 3, 2, 2, 2, 898, 139, 3, 2, 2, 2, 899, 902, 5, 100, 51, 2, 900, 902, 5, 118, 60, 2, 901, 899, 3, 2, 2, 2, 901, 900, 3, 2, 2, 2, 902, 917, 3, 2, 2, 2, 903, 918, 5, 164, 83, 2, 904, 907, 7, 56, 2, 2, 905, 908, 5, 100, 51, 2, 906, 908, 5, 118, 60, 2, 907, 905, 3, 2, 2, 2, 907, 906, 3, 2, 2, 2, 908, 910, 3, 2, 2, 2, 909, 904, 3, 2, 2, 2, 910, 913, 3, 2, 2, 2, 911, 909, 3, 2, 2, 2, 911, 912, 3, 2, 2, 2, 912, 915, 3, 2, 2, 2, 913, 911, 3, 2, 2, 2, 914, 916, 7, 56, 2, 2, 915, 914, 3, 2, 2, 2, 915, 916, 3, 2, 2, 2, 916, 918, 3, 2, 2, 2, 917, 903, 3, 2, 2, 2, 917, 911, 3, 2, 2, 2, 918, 141, 3, 2, 2, 2, 919, 921, 7, 54, 2, 2, 920, 922, 5, 158, 80, 2, 921, 920, 3, 2, 2, 2, 921, 922, 3, 2, 2, 2, 922, 923, 3, 2, 2, 2, 923, 931, 7, 55, 2, 2, 924, 925, 7, 61, 2, 2, 925, 926, 5, 144, 73, 2, 926, 927, 7, 62, 2, 2, 927, 931, 3, 2, 2, 2, 928, 929, 7, 51, 2, 2, 929, 931, 7, 42, 2, 2, 930, 919, 3, 2, 2, 2, 930, 924, 3, 2, 2, 2, 930, 928, 3, 2, 2, 2, 931, 143, 3, 2, 2, 2, 932, 937, 5, 146, 74, 2, 933, 934, 7, 56, 2, 2, 934, 936, 5, 146, 74, 2, 935, 933, 3, 2, 2, 2, 936, 939, 3, 2, 2, 2, 937, 935, 3, 2, 2, 2, 937, 938, 3, 2, 2, 2, 938, 941, 3, 2, 2, 2, 939, 937, 3, 2, 2, 2, 940, 942, 7, 56, 2, 2, 941, 940, 3, 2, 2, 2, 941, 942, 3, 2, 2, 2, 942, 145, 3, 2, 2, 2, 943, 955, 5, 100, 51, 2, 944, 946, 5, 100, 51, 2, 945, 944, 3, 2, 2, 2, 945, 946, 3, 2, 2, 2, 946, 947, 3, 2, 2, 2, 947, 949, 7, 57, 2, 2, 948, 950, 5, 100, 51, 2, 949, 948, 3, 2, 2, 2, 949, 950, 3, 2, 2, 2, 950, 952, 3, 2, 2, 2, 951, 953, 5, 148, 75, 2, 952, 951, 3, 2, 2, 2, 952, 953, 3, 2, 2, 2, 953, 955, 3, 2, 2, 2, 954, 943, 3, 2, 2, 2, 954, 945, 3, 2, 2, 2, 955, 147, 3, 2, 2, 2, 956, 958, 7, 57, 2, 2, 957, 959, 5, 100, 51, 2, 958, 957, 3, 2, 2, 2, 958, 959, 3, 2, 2, 2, 959, 149, 3, 2, 2, 2, 960, 963, 5, 120, 61, 2, 961, 963, 5, 118, 60, 2, 962, 960, 3, 2, 2, 2, 962, 961, 3, 2, 2, 2, 963, 971, 3, 2, 2, 2, 964, 967, 7, 56, 2, 2, 965, 968, 5, 120, 61, 2, 966, 968, 5, 118, 60, 2, 967, 965, 3, 2, 2, 2, 967, 966, 3, 2, 2, 2, 968, 970, 3, 2, 2, 2, 969, 964, 3, 2, 2, 2, 970, 973, 3, 2, 2, 2, 971, 969, 3, 2, 2, 2, 971, 972, 3, 2, 2, 2, 972, 975, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 974, 976, 7, 56, 2, 2, 975, 974, 3, 2, 2, 2, 975, 976, 3, 2, 2, 2, 976, 151, 3, 2, 2, 2, 977, 982, 5, 100, 51, 2, 978, 979, 7, 56, 2, 2, 979, 981, 5, 100, 51, 2, 980, 978, 3, 2, 2, 2, 981, 984, 3, 2, 2, 2, 982, 980, 3, 2, 2, 2, 982, 983, 3, 2, 2, 2, 983, 986, 3, 2, 2, 2, 984, 982, 3, 2, 2, 2, 985, 987, 7, 56, 2, 2, 986, 985, 3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 153, 3, 2, 2, 2, 988, 989, 5, 100, 51, 2, 989, 990, 7, 57, 2, 2, 990, 991, 5, 100, 51, 2, 991, 995, 3, 2, 2, 2, 992, 993, 7, 59, 2, 2, 993, 995, 5, 120, 61, 2, 994, 988, 3, 2, 2, 2, 994, 992, 3, 2, 2, 2, 995, 1014, 3, 2, 2, 2, 996, 1015, 5, 164, 83, 2, 997, 1004, 7, 56, 2, 2, 998, 999, 5, 100, 51, 2, 999, 1000, 7, 57, 2, 2, 1000, 1001, 5, 100, 51, 2, 1001, 1005, 3, 2, 2, 2, 1002, 1003, 7, 59, 2, 2, 1003, 1005, 5, 120, 61, 2, 1004, 998, 3, 2, 2, 2, 1004, 1002, 3, 2, 2, 2, 1005, 1007, 3, 2, 2, 2, 1006, 997, 3, 2, 2, 2, 1007, 1010, 3, 2, 2, 2, 1008, 1006, 3, 2, 2, 2, 1008, 1009, 3, 2, 2, 2, 1009, 1012, 3, 2, 2, 2, 1010, 1008, 3, 2, 2, 2, 1011, 1013, 7, 56, 2, 2, 1012, 1011, 3, 2, 2, 2, 1012, 1013, 3, 2, 2, 2, 1013, 1015, 3, 2, 2, 2, 1014, 996, 3, 2, 2, 2, 1014, 1008, 3, 2, 2, 2, 1015, 1037, 3, 2, 2, 2, 1016, 1019, 5, 100, 51, 2, 1017, 1019, 5, 118, 60, 2, 1018, 1016, 3, 2, 2, 2, 1018, 1017, 3, 2, 2, 2, 1019, 1034, 3, 2, 2, 2, 1020, 1035, 5, 164, 83, 2, 1021, 1024, 7, 56, 2, 2, 1022, 1025, 5, 100, 51, 2, 1023, 1025, 5, 118, 60, 2, 1024, 1022, 3, 2, 2, 2, 1024, 1023, 3, 2, 2, 2, 1025, 1027, 3, 2, 2, 2, 1026, 1021, 3, 2, 2, 2, 1027, 1030, 3, 2, 2, 2, 1028, 1026, 3, 2, 2, 2, 1028, 1029, 3, 2, 2, 2, 1029, 1032, 3, 2, 2, 2, 1030, 1028, 3, 2, 2, 2, 1031, 1033, 7, 56, 2, 2, 1032, 1031, 3, 2, 2, 2, 1032, 1033, 3, 2, 2, 2, 1033, 1035, 3, 2, 2, 2, 1034, 1020, 3, 2, 2, 2, 1034, 1028, 3, 2, 2, 2, 1035, 1037, 3, 2, 2, 2, 1036, 994, 3, 2, 2, 2, 1036, 1018, 3, 2, 2, 2, 1037, 155, 3, 2, 2, 2, 1038, 1039, 7, 33, 2, 2, 1039, 1045, 7, 42, 2, 2, 1040, 1042, 7, 54, 2, 2, 1041, 1043, 5, 158, 80, 2, 1042, 1041, 3, 2, 2, 2, 1042, 1043, 3, 2, 2, 2, 1043, 1044, 3, 2, 2, 2, 1044, 1046, 7, 55, 2, 2, 1045, 1040, 3, 2, 2, 2, 1045, 1046, 3, 2, 2, 2, 1046, 1047, 3, 2, 2, 2, 1047, 1048, 7, 57, 2, 2, 1048, 1049, 5, 98, 50, 2, 1049, 157, 3, 2, 2, 2, 1050, 1055, 5, 160, 81, 2, 1051, 1052, 7, 56, 2, 2, 1052, 1054, 5, 160, 81, 2, 1053, 1051, 3, 2, 2, 2, 1054, 1057, 3, 2, 2, 2, 1055, 1053, 3, 2, 2, 2, 1055, 1056, 3, 2, 2, 2, 1056, 1059, 3, 2, 2, 2, 1057, 1055, 3, 2, 2, 2, 1058, 1060, 7, 56, 2, 2, 1059, 1058, 3, 2, 2, 2, 1059, 1060, 3, 2, 2, 2, 1060, 159, 3, 2, 2, 2, 1061, 1063, 5, 100, 51, 2, 1062, 1064, 5, 164, 83, 2, 1063, 1062, 3, 2, 2, 2, 1063, 1064, 3, 2, 2, 2, 1064, 1074, 3, 2, 2, 2, 1065, 1066, 5, 100, 51, 2, 1066, 1067, 7, 60, 2, 2, 1067, 1068, 5, 100, 51, 2, 1068, 1074, 3, 2, 2, 2, 1069, 1070, 7, 59, 2, 2, 1070, 1074, 5, 100, 51, 2, 1071, 1072, 7, 53, 2, 2, 1072, 1074, 5, 100, 51, 2, 1073, 1061, 3, 2, 2, 2, 1073, 1065, 3, 2, 2, 2, 1073, 1069, 3, 2, 2, 2, 1073, 1071, 3, 2, 2, 2, 1074, 161, 3, 2, 2, 2, 1075, 1078, 5, 164, 83, 2, 1076, 1078, 5, 166, 84, 2, 1077, 1075, 3, 2, 2, 2, 1077, 1076, 3, 2, 2, 2, 1078, 163, 3, 2, 2, 2, 1079, 1081, 7, 39, 2, 2, 1080, 1079, 3, 2, 2, 2, 1080, 1081, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 1083, 7, 19, 2, 2, 1083, 1084, 5, 150, 76, 2, 1084, 1085, 7, 20, 2, 2, 1085, 1087, 5, 108, 55, 2, 1086, 1088, 5, 162, 82, 2, 1087, 1086, 3, 2, 2, 2, 1087, 1088, 3, 2, 2, 2, 1088, 165, 3, 2, 2, 2, 1089, 1090, 7, 15, 2, 2, 1090, 1092, 5, 102, 52, 2, 1091, 1093, 5, 162, 82, 2, 1092, 1091, 3, 2, 2, 2, 1092, 1093, 3, 2, 2, 2, 1093, 167, 3, 2, 2, 2, 1094, 1095, 7, 42, 2, 2, 1095, 169, 3, 2, 2, 2, 1096, 1098, 7, 34, 2, 2, 1097, 1099, 5, 172, 87, 2, 1098, 1097, 3, 2, 2, 2, 1098, 1099, 3, 2, 2, 2, 1099, 171, 3, 2, 2, 2, 1100, 1101, 7, 9, 2, 2, 1101, 1104, 5, 100, 51, 2, 1102, 1104, 5, 152, 77, 2, 1103, 1100, 3, 2, 2, 2, 1103, 1102, 3, 2, 2, 2, 1104, 173, 3, 2, 2, 2, 168, 179, 183, 185, 194, 203, 206, 213, 219, 229, 236, 243, 249, 253, 259, 265, 269, 276, 278, 280, 285, 287, 289, 293, 299, 303, 310, 312, 314, 319, 321, 326, 331, 337, 341, 347, 353, 357, 364, 366, 368, 373, 375, 377, 381, 387, 391, 398, 400, 402, 407, 409, 415, 422, 426, 438, 445, 450, 454, 457, 463, 467, 472, 476, 480, 494, 502, 510, 512, 516, 525, 532, 534, 543, 548, 553, 560, 564, 571, 579, 588, 597, 604, 615, 621, 634, 640, 649, 660, 671, 676, 681, 686, 694, 703, 709, 711, 719, 723, 731, 734, 738, 742, 749, 759, 767, 773, 781, 797, 807, 815, 823, 831, 839, 847, 853, 858, 861, 867, 873, 878, 883, 891, 897, 901, 907, 911, 915, 917, 921, 930, 937, 941, 945, 949, 952, 954, 958, 962, 967, 971, 975, 982, 986, 994, 1004, 1008, 1012, 1014, 1018, 1024, 1028, 1032, 1034, 1036, 1042, 1045, 1055, 1059, 1063, 1073, 1077, 1080, 1087, 1092, 1098, 1103] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.tokens b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.tokens deleted file mode 100644 index 40925d2..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3.tokens +++ /dev/null @@ -1,181 +0,0 @@ -STRING=1 -NUMBER=2 -INTEGER=3 -DEF=4 -RETURN=5 -RAISE=6 -FROM=7 -IMPORT=8 -AS=9 -GLOBAL=10 -NONLOCAL=11 -ASSERT=12 -IF=13 -ELIF=14 -ELSE=15 -WHILE=16 -FOR=17 -IN=18 -TRY=19 -FINALLY=20 -WITH=21 -EXCEPT=22 -LAMBDA=23 -OR=24 -AND=25 -NOT=26 -IS=27 -NONE=28 -TRUE=29 -FALSE=30 -CLASS=31 -YIELD=32 -DEL=33 -PASS=34 -CONTINUE=35 -BREAK=36 -ASYNC=37 -AWAIT=38 -NEWLINE=39 -NAME=40 -STRING_LITERAL=41 -BYTES_LITERAL=42 -DECIMAL_INTEGER=43 -OCT_INTEGER=44 -HEX_INTEGER=45 -BIN_INTEGER=46 -FLOAT_NUMBER=47 -IMAG_NUMBER=48 -DOT=49 -ELLIPSIS=50 -STAR=51 -OPEN_PAREN=52 -CLOSE_PAREN=53 -COMMA=54 -COLON=55 -SEMI_COLON=56 -POWER=57 -ASSIGN=58 -OPEN_BRACK=59 -CLOSE_BRACK=60 -OR_OP=61 -XOR=62 -AND_OP=63 -LEFT_SHIFT=64 -RIGHT_SHIFT=65 -ADD=66 -MINUS=67 -DIV=68 -MOD=69 -IDIV=70 -NOT_OP=71 -OPEN_BRACE=72 -CLOSE_BRACE=73 -LESS_THAN=74 -GREATER_THAN=75 -EQUALS=76 -GT_EQ=77 -LT_EQ=78 -NOT_EQ_1=79 -NOT_EQ_2=80 -AT=81 -ARROW=82 -ADD_ASSIGN=83 -SUB_ASSIGN=84 -MULT_ASSIGN=85 -AT_ASSIGN=86 -DIV_ASSIGN=87 -MOD_ASSIGN=88 -AND_ASSIGN=89 -OR_ASSIGN=90 -XOR_ASSIGN=91 -LEFT_SHIFT_ASSIGN=92 -RIGHT_SHIFT_ASSIGN=93 -POWER_ASSIGN=94 -IDIV_ASSIGN=95 -SKIP_=96 -UNKNOWN_CHAR=97 -INDENT=98 -DEDENT=99 -'def'=4 -'return'=5 -'raise'=6 -'from'=7 -'import'=8 -'as'=9 -'global'=10 -'nonlocal'=11 -'assert'=12 -'if'=13 -'elif'=14 -'else'=15 -'while'=16 -'for'=17 -'in'=18 -'try'=19 -'finally'=20 -'with'=21 -'except'=22 -'lambda'=23 -'or'=24 -'and'=25 -'not'=26 -'is'=27 -'None'=28 -'True'=29 -'False'=30 -'class'=31 -'yield'=32 -'del'=33 -'pass'=34 -'continue'=35 -'break'=36 -'async'=37 -'await'=38 -'.'=49 -'...'=50 -'*'=51 -'('=52 -')'=53 -','=54 -':'=55 -';'=56 -'**'=57 -'='=58 -'['=59 -']'=60 -'|'=61 -'^'=62 -'&'=63 -'<<'=64 -'>>'=65 -'+'=66 -'-'=67 -'/'=68 -'%'=69 -'//'=70 -'~'=71 -'{'=72 -'}'=73 -'<'=74 -'>'=75 -'=='=76 -'>='=77 -'<='=78 -'<>'=79 -'!='=80 -'@'=81 -'->'=82 -'+='=83 -'-='=84 -'*='=85 -'@='=86 -'/='=87 -'%='=88 -'&='=89 -'|='=90 -'^='=91 -'<<='=92 -'>>='=93 -'**='=94 -'//='=95 diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3BaseListener.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3BaseListener.java deleted file mode 100644 index a579a60..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3BaseListener.java +++ /dev/null @@ -1,1596 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.python;// Generated from Python3.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.tree.ErrorNode; -import org.antlr.v4.runtime.tree.TerminalNode; - -/** - * This class provides an empty implementation of {@link Python3Listener}, - * which can be extended to create a listener which only needs to handle a subset - * of the available methods. - */ -public class Python3BaseListener implements Python3Listener { - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSingle_input(Python3Parser.Single_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSingle_input(Python3Parser.Single_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterFile_input(Python3Parser.File_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitFile_input(Python3Parser.File_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterEval_input(Python3Parser.Eval_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitEval_input(Python3Parser.Eval_inputContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDecorator(Python3Parser.DecoratorContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDecorator(Python3Parser.DecoratorContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDecorators(Python3Parser.DecoratorsContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDecorators(Python3Parser.DecoratorsContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDecorated(Python3Parser.DecoratedContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDecorated(Python3Parser.DecoratedContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAsync_funcdef(Python3Parser.Async_funcdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAsync_funcdef(Python3Parser.Async_funcdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterFuncdef(Python3Parser.FuncdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitFuncdef(Python3Parser.FuncdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterParameters(Python3Parser.ParametersContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitParameters(Python3Parser.ParametersContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTypedargslist(Python3Parser.TypedargslistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTypedargslist(Python3Parser.TypedargslistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTfpdef(Python3Parser.TfpdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTfpdef(Python3Parser.TfpdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterVarargslist(Python3Parser.VarargslistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitVarargslist(Python3Parser.VarargslistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterVfpdef(Python3Parser.VfpdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitVfpdef(Python3Parser.VfpdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterStmt(Python3Parser.StmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitStmt(Python3Parser.StmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSimple_stmt(Python3Parser.Simple_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSimple_stmt(Python3Parser.Simple_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSmall_stmt(Python3Parser.Small_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSmall_stmt(Python3Parser.Small_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterExpr_stmt(Python3Parser.Expr_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitExpr_stmt(Python3Parser.Expr_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAnnassign(Python3Parser.AnnassignContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAnnassign(Python3Parser.AnnassignContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTestlist_star_expr(Python3Parser.Testlist_star_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTestlist_star_expr(Python3Parser.Testlist_star_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAugassign(Python3Parser.AugassignContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAugassign(Python3Parser.AugassignContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDel_stmt(Python3Parser.Del_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDel_stmt(Python3Parser.Del_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterPass_stmt(Python3Parser.Pass_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitPass_stmt(Python3Parser.Pass_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterFlow_stmt(Python3Parser.Flow_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitFlow_stmt(Python3Parser.Flow_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterBreak_stmt(Python3Parser.Break_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitBreak_stmt(Python3Parser.Break_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterContinue_stmt(Python3Parser.Continue_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitContinue_stmt(Python3Parser.Continue_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterReturn_stmt(Python3Parser.Return_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitReturn_stmt(Python3Parser.Return_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterYield_stmt(Python3Parser.Yield_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitYield_stmt(Python3Parser.Yield_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterRaise_stmt(Python3Parser.Raise_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitRaise_stmt(Python3Parser.Raise_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterImport_stmt(Python3Parser.Import_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitImport_stmt(Python3Parser.Import_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterImport_name(Python3Parser.Import_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitImport_name(Python3Parser.Import_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterImport_from(Python3Parser.Import_fromContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitImport_from(Python3Parser.Import_fromContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterImport_as_name(Python3Parser.Import_as_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitImport_as_name(Python3Parser.Import_as_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDotted_as_name(Python3Parser.Dotted_as_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDotted_as_name(Python3Parser.Dotted_as_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterImport_as_names(Python3Parser.Import_as_namesContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitImport_as_names(Python3Parser.Import_as_namesContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDotted_as_names(Python3Parser.Dotted_as_namesContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDotted_as_names(Python3Parser.Dotted_as_namesContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDotted_name(Python3Parser.Dotted_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDotted_name(Python3Parser.Dotted_nameContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterGlobal_stmt(Python3Parser.Global_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitGlobal_stmt(Python3Parser.Global_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterNonlocal_stmt(Python3Parser.Nonlocal_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitNonlocal_stmt(Python3Parser.Nonlocal_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAssert_stmt(Python3Parser.Assert_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAssert_stmt(Python3Parser.Assert_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterCompound_stmt(Python3Parser.Compound_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitCompound_stmt(Python3Parser.Compound_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAsync_stmt(Python3Parser.Async_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAsync_stmt(Python3Parser.Async_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterIf_stmt(Python3Parser.If_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitIf_stmt(Python3Parser.If_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterWhile_stmt(Python3Parser.While_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitWhile_stmt(Python3Parser.While_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterFor_stmt(Python3Parser.For_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitFor_stmt(Python3Parser.For_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTry_stmt(Python3Parser.Try_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTry_stmt(Python3Parser.Try_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterWith_stmt(Python3Parser.With_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitWith_stmt(Python3Parser.With_stmtContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterWith_item(Python3Parser.With_itemContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitWith_item(Python3Parser.With_itemContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterExcept_clause(Python3Parser.Except_clauseContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitExcept_clause(Python3Parser.Except_clauseContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSuite(Python3Parser.SuiteContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSuite(Python3Parser.SuiteContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTest(Python3Parser.TestContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTest(Python3Parser.TestContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTest_nocond(Python3Parser.Test_nocondContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTest_nocond(Python3Parser.Test_nocondContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterLambdef(Python3Parser.LambdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitLambdef(Python3Parser.LambdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterLambdef_nocond(Python3Parser.Lambdef_nocondContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitLambdef_nocond(Python3Parser.Lambdef_nocondContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterOr_test(Python3Parser.Or_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitOr_test(Python3Parser.Or_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAnd_test(Python3Parser.And_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAnd_test(Python3Parser.And_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterNot_test(Python3Parser.Not_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitNot_test(Python3Parser.Not_testContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterComparison(Python3Parser.ComparisonContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitComparison(Python3Parser.ComparisonContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterComp_op(Python3Parser.Comp_opContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitComp_op(Python3Parser.Comp_opContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterStar_expr(Python3Parser.Star_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitStar_expr(Python3Parser.Star_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterExpr(Python3Parser.ExprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitExpr(Python3Parser.ExprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterXor_expr(Python3Parser.Xor_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitXor_expr(Python3Parser.Xor_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAnd_expr(Python3Parser.And_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAnd_expr(Python3Parser.And_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterShift_expr(Python3Parser.Shift_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitShift_expr(Python3Parser.Shift_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterArith_expr(Python3Parser.Arith_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitArith_expr(Python3Parser.Arith_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTerm(Python3Parser.TermContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTerm(Python3Parser.TermContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterFactor(Python3Parser.FactorContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitFactor(Python3Parser.FactorContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterPower(Python3Parser.PowerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitPower(Python3Parser.PowerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAtom_expr(Python3Parser.Atom_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAtom_expr(Python3Parser.Atom_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterAtom(Python3Parser.AtomContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitAtom(Python3Parser.AtomContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTestlist_comp(Python3Parser.Testlist_compContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTestlist_comp(Python3Parser.Testlist_compContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTrailer(Python3Parser.TrailerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTrailer(Python3Parser.TrailerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSubscriptlist(Python3Parser.SubscriptlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSubscriptlist(Python3Parser.SubscriptlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSubscript(Python3Parser.SubscriptContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSubscript(Python3Parser.SubscriptContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterSliceop(Python3Parser.SliceopContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitSliceop(Python3Parser.SliceopContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterExprlist(Python3Parser.ExprlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitExprlist(Python3Parser.ExprlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterTestlist(Python3Parser.TestlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitTestlist(Python3Parser.TestlistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterDictorsetmaker(Python3Parser.DictorsetmakerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitDictorsetmaker(Python3Parser.DictorsetmakerContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterClassdef(Python3Parser.ClassdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitClassdef(Python3Parser.ClassdefContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterArglist(Python3Parser.ArglistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitArglist(Python3Parser.ArglistContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterArgument(Python3Parser.ArgumentContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitArgument(Python3Parser.ArgumentContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterComp_iter(Python3Parser.Comp_iterContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitComp_iter(Python3Parser.Comp_iterContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterComp_for(Python3Parser.Comp_forContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitComp_for(Python3Parser.Comp_forContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterComp_if(Python3Parser.Comp_ifContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitComp_if(Python3Parser.Comp_ifContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterEncoding_decl(Python3Parser.Encoding_declContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitEncoding_decl(Python3Parser.Encoding_declContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterYield_expr(Python3Parser.Yield_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitYield_expr(Python3Parser.Yield_exprContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterYield_arg(Python3Parser.Yield_argContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitYield_arg(Python3Parser.Yield_argContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void enterEveryRule(ParserRuleContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void exitEveryRule(ParserRuleContext ctx) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void visitTerminal(TerminalNode node) { - } - - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override - public void visitErrorNode(ErrorNode node) { - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.interp b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.interp deleted file mode 100644 index e0659d8..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.interp +++ /dev/null @@ -1,335 +0,0 @@ -token literal names: -null -null -null -null -'def' -'return' -'raise' -'from' -'import' -'as' -'global' -'nonlocal' -'assert' -'if' -'elif' -'else' -'while' -'for' -'in' -'try' -'finally' -'with' -'except' -'lambda' -'or' -'and' -'not' -'is' -'None' -'True' -'False' -'class' -'yield' -'del' -'pass' -'continue' -'break' -'async' -'await' -null -null -null -null -null -null -null -null -null -null -'.' -'...' -'*' -'(' -')' -',' -':' -';' -'**' -'=' -'[' -']' -'|' -'^' -'&' -'<<' -'>>' -'+' -'-' -'/' -'%' -'//' -'~' -'{' -'}' -'<' -'>' -'==' -'>=' -'<=' -'<>' -'!=' -'@' -'->' -'+=' -'-=' -'*=' -'@=' -'/=' -'%=' -'&=' -'|=' -'^=' -'<<=' -'>>=' -'**=' -'//=' -null -null - -token symbolic names: -null -STRING -NUMBER -INTEGER -DEF -RETURN -RAISE -FROM -IMPORT -AS -GLOBAL -NONLOCAL -ASSERT -IF -ELIF -ELSE -WHILE -FOR -IN -TRY -FINALLY -WITH -EXCEPT -LAMBDA -OR -AND -NOT -IS -NONE -TRUE -FALSE -CLASS -YIELD -DEL -PASS -CONTINUE -BREAK -ASYNC -AWAIT -NEWLINE -NAME -STRING_LITERAL -BYTES_LITERAL -DECIMAL_INTEGER -OCT_INTEGER -HEX_INTEGER -BIN_INTEGER -FLOAT_NUMBER -IMAG_NUMBER -DOT -ELLIPSIS -STAR -OPEN_PAREN -CLOSE_PAREN -COMMA -COLON -SEMI_COLON -POWER -ASSIGN -OPEN_BRACK -CLOSE_BRACK -OR_OP -XOR -AND_OP -LEFT_SHIFT -RIGHT_SHIFT -ADD -MINUS -DIV -MOD -IDIV -NOT_OP -OPEN_BRACE -CLOSE_BRACE -LESS_THAN -GREATER_THAN -EQUALS -GT_EQ -LT_EQ -NOT_EQ_1 -NOT_EQ_2 -AT -ARROW -ADD_ASSIGN -SUB_ASSIGN -MULT_ASSIGN -AT_ASSIGN -DIV_ASSIGN -MOD_ASSIGN -AND_ASSIGN -OR_ASSIGN -XOR_ASSIGN -LEFT_SHIFT_ASSIGN -RIGHT_SHIFT_ASSIGN -POWER_ASSIGN -IDIV_ASSIGN -SKIP_ -UNKNOWN_CHAR - -rule names: -STRING -NUMBER -INTEGER -DEF -RETURN -RAISE -FROM -IMPORT -AS -GLOBAL -NONLOCAL -ASSERT -IF -ELIF -ELSE -WHILE -FOR -IN -TRY -FINALLY -WITH -EXCEPT -LAMBDA -OR -AND -NOT -IS -NONE -TRUE -FALSE -CLASS -YIELD -DEL -PASS -CONTINUE -BREAK -ASYNC -AWAIT -NEWLINE -NAME -STRING_LITERAL -BYTES_LITERAL -DECIMAL_INTEGER -OCT_INTEGER -HEX_INTEGER -BIN_INTEGER -FLOAT_NUMBER -IMAG_NUMBER -DOT -ELLIPSIS -STAR -OPEN_PAREN -CLOSE_PAREN -COMMA -COLON -SEMI_COLON -POWER -ASSIGN -OPEN_BRACK -CLOSE_BRACK -OR_OP -XOR -AND_OP -LEFT_SHIFT -RIGHT_SHIFT -ADD -MINUS -DIV -MOD -IDIV -NOT_OP -OPEN_BRACE -CLOSE_BRACE -LESS_THAN -GREATER_THAN -EQUALS -GT_EQ -LT_EQ -NOT_EQ_1 -NOT_EQ_2 -AT -ARROW -ADD_ASSIGN -SUB_ASSIGN -MULT_ASSIGN -AT_ASSIGN -DIV_ASSIGN -MOD_ASSIGN -AND_ASSIGN -OR_ASSIGN -XOR_ASSIGN -LEFT_SHIFT_ASSIGN -RIGHT_SHIFT_ASSIGN -POWER_ASSIGN -IDIV_ASSIGN -SKIP_ -UNKNOWN_CHAR -SHORT_STRING -LONG_STRING -LONG_STRING_ITEM -LONG_STRING_CHAR -STRING_ESCAPE_SEQ -NON_ZERO_DIGIT -DIGIT -OCT_DIGIT -HEX_DIGIT -BIN_DIGIT -POINT_FLOAT -EXPONENT_FLOAT -INT_PART -FRACTION -EXPONENT -SHORT_BYTES -LONG_BYTES -LONG_BYTES_ITEM -SHORT_BYTES_CHAR_NO_SINGLE_QUOTE -SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE -LONG_BYTES_CHAR -BYTES_ESCAPE_SEQ -SPACES -COMMENT -LINE_JOINING -ID_START -ID_CONTINUE - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE - -atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 99, 883, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 3, 2, 3, 2, 5, 2, 254, 10, 2, 3, 3, 3, 3, 3, 3, 5, 3, 259, 10, 3, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 265, 10, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 5, 40, 460, 10, 40, 3, 40, 3, 40, 5, 40, 464, 10, 40, 3, 40, 5, 40, 467, 10, 40, 5, 40, 469, 10, 40, 3, 40, 3, 40, 3, 41, 3, 41, 7, 41, 475, 10, 41, 12, 41, 14, 41, 478, 11, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 485, 10, 42, 3, 42, 3, 42, 5, 42, 489, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 496, 10, 43, 3, 43, 3, 43, 5, 43, 500, 10, 43, 3, 44, 3, 44, 7, 44, 504, 10, 44, 12, 44, 14, 44, 507, 11, 44, 3, 44, 6, 44, 510, 10, 44, 13, 44, 14, 44, 511, 5, 44, 514, 10, 44, 3, 45, 3, 45, 3, 45, 6, 45, 519, 10, 45, 13, 45, 14, 45, 520, 3, 46, 3, 46, 3, 46, 6, 46, 526, 10, 46, 13, 46, 14, 46, 527, 3, 47, 3, 47, 3, 47, 6, 47, 533, 10, 47, 13, 47, 14, 47, 534, 3, 48, 3, 48, 5, 48, 539, 10, 48, 3, 49, 3, 49, 5, 49, 543, 10, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 56, 3, 56, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 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, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 5, 97, 679, 10, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 7, 99, 688, 10, 99, 12, 99, 14, 99, 691, 11, 99, 3, 99, 3, 99, 3, 99, 3, 99, 7, 99, 697, 10, 99, 12, 99, 14, 99, 700, 11, 99, 3, 99, 5, 99, 703, 10, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 7, 100, 710, 10, 100, 12, 100, 14, 100, 713, 11, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 7, 100, 723, 10, 100, 12, 100, 14, 100, 726, 11, 100, 3, 100, 3, 100, 3, 100, 5, 100, 731, 10, 100, 3, 101, 3, 101, 5, 101, 735, 10, 101, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 5, 103, 743, 10, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 106, 3, 106, 3, 107, 3, 107, 3, 108, 3, 108, 3, 109, 5, 109, 756, 10, 109, 3, 109, 3, 109, 3, 109, 3, 109, 5, 109, 762, 10, 109, 3, 110, 3, 110, 5, 110, 766, 10, 110, 3, 110, 3, 110, 3, 111, 6, 111, 771, 10, 111, 13, 111, 14, 111, 772, 3, 112, 3, 112, 6, 112, 777, 10, 112, 13, 112, 14, 112, 778, 3, 113, 3, 113, 5, 113, 783, 10, 113, 3, 113, 6, 113, 786, 10, 113, 13, 113, 14, 113, 787, 3, 114, 3, 114, 3, 114, 7, 114, 793, 10, 114, 12, 114, 14, 114, 796, 11, 114, 3, 114, 3, 114, 3, 114, 3, 114, 7, 114, 802, 10, 114, 12, 114, 14, 114, 805, 11, 114, 3, 114, 5, 114, 808, 10, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 7, 115, 815, 10, 115, 12, 115, 14, 115, 818, 11, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 7, 115, 828, 10, 115, 12, 115, 14, 115, 831, 11, 115, 3, 115, 3, 115, 3, 115, 5, 115, 836, 10, 115, 3, 116, 3, 116, 5, 116, 840, 10, 116, 3, 117, 5, 117, 843, 10, 117, 3, 118, 5, 118, 846, 10, 118, 3, 119, 5, 119, 849, 10, 119, 3, 120, 3, 120, 3, 120, 3, 121, 6, 121, 855, 10, 121, 13, 121, 14, 121, 856, 3, 122, 3, 122, 7, 122, 861, 10, 122, 12, 122, 14, 122, 864, 11, 122, 3, 123, 3, 123, 5, 123, 868, 10, 123, 3, 123, 5, 123, 871, 10, 123, 3, 123, 3, 123, 5, 123, 875, 10, 123, 3, 124, 5, 124, 878, 10, 124, 3, 125, 3, 125, 5, 125, 882, 10, 125, 6, 711, 724, 816, 829, 2, 126, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 79, 41, 81, 42, 83, 43, 85, 44, 87, 45, 89, 46, 91, 47, 93, 48, 95, 49, 97, 50, 99, 51, 101, 52, 103, 53, 105, 54, 107, 55, 109, 56, 111, 57, 113, 58, 115, 59, 117, 60, 119, 61, 121, 62, 123, 63, 125, 64, 127, 65, 129, 66, 131, 67, 133, 68, 135, 69, 137, 70, 139, 71, 141, 72, 143, 73, 145, 74, 147, 75, 149, 76, 151, 77, 153, 78, 155, 79, 157, 80, 159, 81, 161, 82, 163, 83, 165, 84, 167, 85, 169, 86, 171, 87, 173, 88, 175, 89, 177, 90, 179, 91, 181, 92, 183, 93, 185, 94, 187, 95, 189, 96, 191, 97, 193, 98, 195, 99, 197, 2, 199, 2, 201, 2, 203, 2, 205, 2, 207, 2, 209, 2, 211, 2, 213, 2, 215, 2, 217, 2, 219, 2, 221, 2, 223, 2, 225, 2, 227, 2, 229, 2, 231, 2, 233, 2, 235, 2, 237, 2, 239, 2, 241, 2, 243, 2, 245, 2, 247, 2, 249, 2, 3, 2, 27, 8, 2, 72, 72, 84, 84, 87, 87, 104, 104, 116, 116, 119, 119, 4, 2, 72, 72, 104, 104, 4, 2, 84, 84, 116, 116, 4, 2, 68, 68, 100, 100, 4, 2, 81, 81, 113, 113, 4, 2, 90, 90, 122, 122, 4, 2, 76, 76, 108, 108, 6, 2, 12, 12, 14, 15, 41, 41, 94, 94, 6, 2, 12, 12, 14, 15, 36, 36, 94, 94, 3, 2, 94, 94, 3, 2, 51, 59, 3, 2, 50, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 3, 2, 50, 51, 4, 2, 71, 71, 103, 103, 4, 2, 45, 45, 47, 47, 7, 2, 2, 11, 13, 14, 16, 40, 42, 93, 95, 129, 7, 2, 2, 11, 13, 14, 16, 35, 37, 93, 95, 129, 4, 2, 2, 93, 95, 129, 3, 2, 2, 129, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 14, 15, 297, 2, 67, 92, 97, 97, 99, 124, 172, 172, 183, 183, 188, 188, 194, 216, 218, 248, 250, 579, 594, 707, 712, 723, 738, 742, 752, 752, 892, 892, 904, 904, 906, 908, 910, 910, 912, 931, 933, 976, 978, 1015, 1017, 1155, 1164, 1232, 1234, 1275, 1282, 1297, 1331, 1368, 1371, 1371, 1379, 1417, 1490, 1516, 1522, 1524, 1571, 1596, 1602, 1612, 1648, 1649, 1651, 1749, 1751, 1751, 1767, 1768, 1776, 1777, 1788, 1790, 1793, 1793, 1810, 1810, 1812, 1841, 1871, 1903, 1922, 1959, 1971, 1971, 2310, 2363, 2367, 2367, 2386, 2386, 2394, 2403, 2431, 2431, 2439, 2446, 2449, 2450, 2453, 2474, 2476, 2482, 2484, 2484, 2488, 2491, 2495, 2495, 2512, 2512, 2526, 2527, 2529, 2531, 2546, 2547, 2567, 2572, 2577, 2578, 2581, 2602, 2604, 2610, 2612, 2613, 2615, 2616, 2618, 2619, 2651, 2654, 2656, 2656, 2676, 2678, 2695, 2703, 2705, 2707, 2709, 2730, 2732, 2738, 2740, 2741, 2743, 2747, 2751, 2751, 2770, 2770, 2786, 2787, 2823, 2830, 2833, 2834, 2837, 2858, 2860, 2866, 2868, 2869, 2871, 2875, 2879, 2879, 2910, 2911, 2913, 2915, 2931, 2931, 2949, 2949, 2951, 2956, 2960, 2962, 2964, 2967, 2971, 2972, 2974, 2974, 2976, 2977, 2981, 2982, 2986, 2988, 2992, 3003, 3079, 3086, 3088, 3090, 3092, 3114, 3116, 3125, 3127, 3131, 3170, 3171, 3207, 3214, 3216, 3218, 3220, 3242, 3244, 3253, 3255, 3259, 3263, 3263, 3296, 3296, 3298, 3299, 3335, 3342, 3344, 3346, 3348, 3370, 3372, 3387, 3426, 3427, 3463, 3480, 3484, 3507, 3509, 3517, 3519, 3519, 3522, 3528, 3587, 3634, 3636, 3637, 3650, 3656, 3715, 3716, 3718, 3718, 3721, 3722, 3724, 3724, 3727, 3727, 3734, 3737, 3739, 3745, 3747, 3749, 3751, 3751, 3753, 3753, 3756, 3757, 3759, 3762, 3764, 3765, 3775, 3775, 3778, 3782, 3784, 3784, 3806, 3807, 3842, 3842, 3906, 3913, 3915, 3948, 3978, 3981, 4098, 4131, 4133, 4137, 4139, 4140, 4178, 4183, 4258, 4295, 4306, 4348, 4350, 4350, 4354, 4443, 4449, 4516, 4522, 4603, 4610, 4682, 4684, 4687, 4690, 4696, 4698, 4698, 4700, 4703, 4706, 4746, 4748, 4751, 4754, 4786, 4788, 4791, 4794, 4800, 4802, 4802, 4804, 4807, 4810, 4824, 4826, 4882, 4884, 4887, 4890, 4956, 4994, 5009, 5026, 5110, 5123, 5742, 5745, 5752, 5763, 5788, 5794, 5868, 5872, 5874, 5890, 5902, 5904, 5907, 5922, 5939, 5954, 5971, 5986, 5998, 6000, 6002, 6018, 6069, 6105, 6105, 6110, 6110, 6178, 6265, 6274, 6314, 6402, 6430, 6482, 6511, 6514, 6518, 6530, 6571, 6595, 6601, 6658, 6680, 7426, 7617, 7682, 7837, 7842, 7931, 7938, 7959, 7962, 7967, 7970, 8007, 8010, 8015, 8018, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8033, 8063, 8066, 8118, 8120, 8126, 8128, 8128, 8132, 8134, 8136, 8142, 8146, 8149, 8152, 8157, 8162, 8174, 8180, 8182, 8184, 8190, 8307, 8307, 8321, 8321, 8338, 8342, 8452, 8452, 8457, 8457, 8460, 8469, 8471, 8471, 8474, 8479, 8486, 8486, 8488, 8488, 8490, 8490, 8492, 8499, 8501, 8507, 8510, 8513, 8519, 8523, 8546, 8581, 11266, 11312, 11314, 11360, 11394, 11494, 11522, 11559, 11570, 11623, 11633, 11633, 11650, 11672, 11682, 11688, 11690, 11696, 11698, 11704, 11706, 11712, 11714, 11720, 11722, 11728, 11730, 11736, 11738, 11744, 12295, 12297, 12323, 12331, 12339, 12343, 12346, 12350, 12355, 12440, 12445, 12449, 12451, 12540, 12542, 12545, 12551, 12590, 12595, 12688, 12706, 12729, 12786, 12801, 13314, 19895, 19970, 40893, 40962, 42126, 43010, 43011, 43013, 43015, 43017, 43020, 43022, 43044, 44034, 55205, 63746, 64047, 64050, 64108, 64114, 64219, 64258, 64264, 64277, 64281, 64287, 64287, 64289, 64298, 64300, 64312, 64314, 64318, 64320, 64320, 64322, 64323, 64325, 64326, 64328, 64435, 64469, 64831, 64850, 64913, 64916, 64969, 65010, 65021, 65138, 65142, 65144, 65278, 65315, 65340, 65347, 65372, 65384, 65472, 65476, 65481, 65484, 65489, 65492, 65497, 65500, 65502, 150, 2, 50, 59, 770, 881, 1157, 1160, 1427, 1467, 1469, 1471, 1473, 1473, 1475, 1476, 1478, 1479, 1481, 1481, 1554, 1559, 1613, 1632, 1634, 1643, 1650, 1650, 1752, 1758, 1761, 1766, 1769, 1770, 1772, 1775, 1778, 1787, 1811, 1811, 1842, 1868, 1960, 1970, 2307, 2309, 2366, 2366, 2368, 2383, 2387, 2390, 2404, 2405, 2408, 2417, 2435, 2437, 2494, 2494, 2496, 2502, 2505, 2506, 2509, 2511, 2521, 2521, 2532, 2533, 2536, 2545, 2563, 2565, 2622, 2622, 2624, 2628, 2633, 2634, 2637, 2639, 2664, 2675, 2691, 2693, 2750, 2750, 2752, 2759, 2761, 2763, 2765, 2767, 2788, 2789, 2792, 2801, 2819, 2821, 2878, 2878, 2880, 2885, 2889, 2890, 2893, 2895, 2904, 2905, 2920, 2929, 2948, 2948, 3008, 3012, 3016, 3018, 3020, 3023, 3033, 3033, 3048, 3057, 3075, 3077, 3136, 3142, 3144, 3146, 3148, 3151, 3159, 3160, 3176, 3185, 3204, 3205, 3262, 3262, 3264, 3270, 3272, 3274, 3276, 3279, 3287, 3288, 3304, 3313, 3332, 3333, 3392, 3397, 3400, 3402, 3404, 3407, 3417, 3417, 3432, 3441, 3460, 3461, 3532, 3532, 3537, 3542, 3544, 3544, 3546, 3553, 3572, 3573, 3635, 3635, 3638, 3644, 3657, 3664, 3666, 3675, 3763, 3763, 3766, 3771, 3773, 3774, 3786, 3791, 3794, 3803, 3866, 3867, 3874, 3883, 3895, 3895, 3897, 3897, 3899, 3899, 3904, 3905, 3955, 3974, 3976, 3977, 3986, 3993, 3995, 4030, 4040, 4040, 4142, 4148, 4152, 4155, 4162, 4171, 4184, 4187, 4961, 4961, 4971, 4979, 5908, 5910, 5940, 5942, 5972, 5973, 6004, 6005, 6072, 6101, 6111, 6111, 6114, 6123, 6157, 6159, 6162, 6171, 6315, 6315, 6434, 6445, 6450, 6461, 6472, 6481, 6578, 6594, 6602, 6603, 6610, 6619, 6681, 6685, 7618, 7621, 8257, 8258, 8278, 8278, 8402, 8414, 8419, 8419, 8423, 8429, 12332, 12337, 12443, 12444, 43012, 43012, 43016, 43016, 43021, 43021, 43045, 43049, 64288, 64288, 65026, 65041, 65058, 65061, 65077, 65078, 65103, 65105, 65298, 65307, 65345, 65345, 2, 915, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 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, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 3, 253, 3, 2, 2, 2, 5, 258, 3, 2, 2, 2, 7, 264, 3, 2, 2, 2, 9, 266, 3, 2, 2, 2, 11, 270, 3, 2, 2, 2, 13, 277, 3, 2, 2, 2, 15, 283, 3, 2, 2, 2, 17, 288, 3, 2, 2, 2, 19, 295, 3, 2, 2, 2, 21, 298, 3, 2, 2, 2, 23, 305, 3, 2, 2, 2, 25, 314, 3, 2, 2, 2, 27, 321, 3, 2, 2, 2, 29, 324, 3, 2, 2, 2, 31, 329, 3, 2, 2, 2, 33, 334, 3, 2, 2, 2, 35, 340, 3, 2, 2, 2, 37, 344, 3, 2, 2, 2, 39, 347, 3, 2, 2, 2, 41, 351, 3, 2, 2, 2, 43, 359, 3, 2, 2, 2, 45, 364, 3, 2, 2, 2, 47, 371, 3, 2, 2, 2, 49, 378, 3, 2, 2, 2, 51, 381, 3, 2, 2, 2, 53, 385, 3, 2, 2, 2, 55, 389, 3, 2, 2, 2, 57, 392, 3, 2, 2, 2, 59, 397, 3, 2, 2, 2, 61, 402, 3, 2, 2, 2, 63, 408, 3, 2, 2, 2, 65, 414, 3, 2, 2, 2, 67, 420, 3, 2, 2, 2, 69, 424, 3, 2, 2, 2, 71, 429, 3, 2, 2, 2, 73, 438, 3, 2, 2, 2, 75, 444, 3, 2, 2, 2, 77, 450, 3, 2, 2, 2, 79, 468, 3, 2, 2, 2, 81, 472, 3, 2, 2, 2, 83, 484, 3, 2, 2, 2, 85, 495, 3, 2, 2, 2, 87, 513, 3, 2, 2, 2, 89, 515, 3, 2, 2, 2, 91, 522, 3, 2, 2, 2, 93, 529, 3, 2, 2, 2, 95, 538, 3, 2, 2, 2, 97, 542, 3, 2, 2, 2, 99, 546, 3, 2, 2, 2, 101, 548, 3, 2, 2, 2, 103, 552, 3, 2, 2, 2, 105, 554, 3, 2, 2, 2, 107, 557, 3, 2, 2, 2, 109, 560, 3, 2, 2, 2, 111, 562, 3, 2, 2, 2, 113, 564, 3, 2, 2, 2, 115, 566, 3, 2, 2, 2, 117, 569, 3, 2, 2, 2, 119, 571, 3, 2, 2, 2, 121, 574, 3, 2, 2, 2, 123, 577, 3, 2, 2, 2, 125, 579, 3, 2, 2, 2, 127, 581, 3, 2, 2, 2, 129, 583, 3, 2, 2, 2, 131, 586, 3, 2, 2, 2, 133, 589, 3, 2, 2, 2, 135, 591, 3, 2, 2, 2, 137, 593, 3, 2, 2, 2, 139, 595, 3, 2, 2, 2, 141, 597, 3, 2, 2, 2, 143, 600, 3, 2, 2, 2, 145, 602, 3, 2, 2, 2, 147, 605, 3, 2, 2, 2, 149, 608, 3, 2, 2, 2, 151, 610, 3, 2, 2, 2, 153, 612, 3, 2, 2, 2, 155, 615, 3, 2, 2, 2, 157, 618, 3, 2, 2, 2, 159, 621, 3, 2, 2, 2, 161, 624, 3, 2, 2, 2, 163, 627, 3, 2, 2, 2, 165, 629, 3, 2, 2, 2, 167, 632, 3, 2, 2, 2, 169, 635, 3, 2, 2, 2, 171, 638, 3, 2, 2, 2, 173, 641, 3, 2, 2, 2, 175, 644, 3, 2, 2, 2, 177, 647, 3, 2, 2, 2, 179, 650, 3, 2, 2, 2, 181, 653, 3, 2, 2, 2, 183, 656, 3, 2, 2, 2, 185, 659, 3, 2, 2, 2, 187, 663, 3, 2, 2, 2, 189, 667, 3, 2, 2, 2, 191, 671, 3, 2, 2, 2, 193, 678, 3, 2, 2, 2, 195, 682, 3, 2, 2, 2, 197, 702, 3, 2, 2, 2, 199, 730, 3, 2, 2, 2, 201, 734, 3, 2, 2, 2, 203, 736, 3, 2, 2, 2, 205, 742, 3, 2, 2, 2, 207, 744, 3, 2, 2, 2, 209, 746, 3, 2, 2, 2, 211, 748, 3, 2, 2, 2, 213, 750, 3, 2, 2, 2, 215, 752, 3, 2, 2, 2, 217, 761, 3, 2, 2, 2, 219, 765, 3, 2, 2, 2, 221, 770, 3, 2, 2, 2, 223, 774, 3, 2, 2, 2, 225, 780, 3, 2, 2, 2, 227, 807, 3, 2, 2, 2, 229, 835, 3, 2, 2, 2, 231, 839, 3, 2, 2, 2, 233, 842, 3, 2, 2, 2, 235, 845, 3, 2, 2, 2, 237, 848, 3, 2, 2, 2, 239, 850, 3, 2, 2, 2, 241, 854, 3, 2, 2, 2, 243, 858, 3, 2, 2, 2, 245, 865, 3, 2, 2, 2, 247, 877, 3, 2, 2, 2, 249, 881, 3, 2, 2, 2, 251, 254, 5, 83, 42, 2, 252, 254, 5, 85, 43, 2, 253, 251, 3, 2, 2, 2, 253, 252, 3, 2, 2, 2, 254, 4, 3, 2, 2, 2, 255, 259, 5, 7, 4, 2, 256, 259, 5, 95, 48, 2, 257, 259, 5, 97, 49, 2, 258, 255, 3, 2, 2, 2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2, 259, 6, 3, 2, 2, 2, 260, 265, 5, 87, 44, 2, 261, 265, 5, 89, 45, 2, 262, 265, 5, 91, 46, 2, 263, 265, 5, 93, 47, 2, 264, 260, 3, 2, 2, 2, 264, 261, 3, 2, 2, 2, 264, 262, 3, 2, 2, 2, 264, 263, 3, 2, 2, 2, 265, 8, 3, 2, 2, 2, 266, 267, 7, 102, 2, 2, 267, 268, 7, 103, 2, 2, 268, 269, 7, 104, 2, 2, 269, 10, 3, 2, 2, 2, 270, 271, 7, 116, 2, 2, 271, 272, 7, 103, 2, 2, 272, 273, 7, 118, 2, 2, 273, 274, 7, 119, 2, 2, 274, 275, 7, 116, 2, 2, 275, 276, 7, 112, 2, 2, 276, 12, 3, 2, 2, 2, 277, 278, 7, 116, 2, 2, 278, 279, 7, 99, 2, 2, 279, 280, 7, 107, 2, 2, 280, 281, 7, 117, 2, 2, 281, 282, 7, 103, 2, 2, 282, 14, 3, 2, 2, 2, 283, 284, 7, 104, 2, 2, 284, 285, 7, 116, 2, 2, 285, 286, 7, 113, 2, 2, 286, 287, 7, 111, 2, 2, 287, 16, 3, 2, 2, 2, 288, 289, 7, 107, 2, 2, 289, 290, 7, 111, 2, 2, 290, 291, 7, 114, 2, 2, 291, 292, 7, 113, 2, 2, 292, 293, 7, 116, 2, 2, 293, 294, 7, 118, 2, 2, 294, 18, 3, 2, 2, 2, 295, 296, 7, 99, 2, 2, 296, 297, 7, 117, 2, 2, 297, 20, 3, 2, 2, 2, 298, 299, 7, 105, 2, 2, 299, 300, 7, 110, 2, 2, 300, 301, 7, 113, 2, 2, 301, 302, 7, 100, 2, 2, 302, 303, 7, 99, 2, 2, 303, 304, 7, 110, 2, 2, 304, 22, 3, 2, 2, 2, 305, 306, 7, 112, 2, 2, 306, 307, 7, 113, 2, 2, 307, 308, 7, 112, 2, 2, 308, 309, 7, 110, 2, 2, 309, 310, 7, 113, 2, 2, 310, 311, 7, 101, 2, 2, 311, 312, 7, 99, 2, 2, 312, 313, 7, 110, 2, 2, 313, 24, 3, 2, 2, 2, 314, 315, 7, 99, 2, 2, 315, 316, 7, 117, 2, 2, 316, 317, 7, 117, 2, 2, 317, 318, 7, 103, 2, 2, 318, 319, 7, 116, 2, 2, 319, 320, 7, 118, 2, 2, 320, 26, 3, 2, 2, 2, 321, 322, 7, 107, 2, 2, 322, 323, 7, 104, 2, 2, 323, 28, 3, 2, 2, 2, 324, 325, 7, 103, 2, 2, 325, 326, 7, 110, 2, 2, 326, 327, 7, 107, 2, 2, 327, 328, 7, 104, 2, 2, 328, 30, 3, 2, 2, 2, 329, 330, 7, 103, 2, 2, 330, 331, 7, 110, 2, 2, 331, 332, 7, 117, 2, 2, 332, 333, 7, 103, 2, 2, 333, 32, 3, 2, 2, 2, 334, 335, 7, 121, 2, 2, 335, 336, 7, 106, 2, 2, 336, 337, 7, 107, 2, 2, 337, 338, 7, 110, 2, 2, 338, 339, 7, 103, 2, 2, 339, 34, 3, 2, 2, 2, 340, 341, 7, 104, 2, 2, 341, 342, 7, 113, 2, 2, 342, 343, 7, 116, 2, 2, 343, 36, 3, 2, 2, 2, 344, 345, 7, 107, 2, 2, 345, 346, 7, 112, 2, 2, 346, 38, 3, 2, 2, 2, 347, 348, 7, 118, 2, 2, 348, 349, 7, 116, 2, 2, 349, 350, 7, 123, 2, 2, 350, 40, 3, 2, 2, 2, 351, 352, 7, 104, 2, 2, 352, 353, 7, 107, 2, 2, 353, 354, 7, 112, 2, 2, 354, 355, 7, 99, 2, 2, 355, 356, 7, 110, 2, 2, 356, 357, 7, 110, 2, 2, 357, 358, 7, 123, 2, 2, 358, 42, 3, 2, 2, 2, 359, 360, 7, 121, 2, 2, 360, 361, 7, 107, 2, 2, 361, 362, 7, 118, 2, 2, 362, 363, 7, 106, 2, 2, 363, 44, 3, 2, 2, 2, 364, 365, 7, 103, 2, 2, 365, 366, 7, 122, 2, 2, 366, 367, 7, 101, 2, 2, 367, 368, 7, 103, 2, 2, 368, 369, 7, 114, 2, 2, 369, 370, 7, 118, 2, 2, 370, 46, 3, 2, 2, 2, 371, 372, 7, 110, 2, 2, 372, 373, 7, 99, 2, 2, 373, 374, 7, 111, 2, 2, 374, 375, 7, 100, 2, 2, 375, 376, 7, 102, 2, 2, 376, 377, 7, 99, 2, 2, 377, 48, 3, 2, 2, 2, 378, 379, 7, 113, 2, 2, 379, 380, 7, 116, 2, 2, 380, 50, 3, 2, 2, 2, 381, 382, 7, 99, 2, 2, 382, 383, 7, 112, 2, 2, 383, 384, 7, 102, 2, 2, 384, 52, 3, 2, 2, 2, 385, 386, 7, 112, 2, 2, 386, 387, 7, 113, 2, 2, 387, 388, 7, 118, 2, 2, 388, 54, 3, 2, 2, 2, 389, 390, 7, 107, 2, 2, 390, 391, 7, 117, 2, 2, 391, 56, 3, 2, 2, 2, 392, 393, 7, 80, 2, 2, 393, 394, 7, 113, 2, 2, 394, 395, 7, 112, 2, 2, 395, 396, 7, 103, 2, 2, 396, 58, 3, 2, 2, 2, 397, 398, 7, 86, 2, 2, 398, 399, 7, 116, 2, 2, 399, 400, 7, 119, 2, 2, 400, 401, 7, 103, 2, 2, 401, 60, 3, 2, 2, 2, 402, 403, 7, 72, 2, 2, 403, 404, 7, 99, 2, 2, 404, 405, 7, 110, 2, 2, 405, 406, 7, 117, 2, 2, 406, 407, 7, 103, 2, 2, 407, 62, 3, 2, 2, 2, 408, 409, 7, 101, 2, 2, 409, 410, 7, 110, 2, 2, 410, 411, 7, 99, 2, 2, 411, 412, 7, 117, 2, 2, 412, 413, 7, 117, 2, 2, 413, 64, 3, 2, 2, 2, 414, 415, 7, 123, 2, 2, 415, 416, 7, 107, 2, 2, 416, 417, 7, 103, 2, 2, 417, 418, 7, 110, 2, 2, 418, 419, 7, 102, 2, 2, 419, 66, 3, 2, 2, 2, 420, 421, 7, 102, 2, 2, 421, 422, 7, 103, 2, 2, 422, 423, 7, 110, 2, 2, 423, 68, 3, 2, 2, 2, 424, 425, 7, 114, 2, 2, 425, 426, 7, 99, 2, 2, 426, 427, 7, 117, 2, 2, 427, 428, 7, 117, 2, 2, 428, 70, 3, 2, 2, 2, 429, 430, 7, 101, 2, 2, 430, 431, 7, 113, 2, 2, 431, 432, 7, 112, 2, 2, 432, 433, 7, 118, 2, 2, 433, 434, 7, 107, 2, 2, 434, 435, 7, 112, 2, 2, 435, 436, 7, 119, 2, 2, 436, 437, 7, 103, 2, 2, 437, 72, 3, 2, 2, 2, 438, 439, 7, 100, 2, 2, 439, 440, 7, 116, 2, 2, 440, 441, 7, 103, 2, 2, 441, 442, 7, 99, 2, 2, 442, 443, 7, 109, 2, 2, 443, 74, 3, 2, 2, 2, 444, 445, 7, 99, 2, 2, 445, 446, 7, 117, 2, 2, 446, 447, 7, 123, 2, 2, 447, 448, 7, 112, 2, 2, 448, 449, 7, 101, 2, 2, 449, 76, 3, 2, 2, 2, 450, 451, 7, 99, 2, 2, 451, 452, 7, 121, 2, 2, 452, 453, 7, 99, 2, 2, 453, 454, 7, 107, 2, 2, 454, 455, 7, 118, 2, 2, 455, 78, 3, 2, 2, 2, 456, 457, 6, 40, 2, 2, 457, 469, 5, 241, 121, 2, 458, 460, 7, 15, 2, 2, 459, 458, 3, 2, 2, 2, 459, 460, 3, 2, 2, 2, 460, 461, 3, 2, 2, 2, 461, 464, 7, 12, 2, 2, 462, 464, 4, 14, 15, 2, 463, 459, 3, 2, 2, 2, 463, 462, 3, 2, 2, 2, 464, 466, 3, 2, 2, 2, 465, 467, 5, 241, 121, 2, 466, 465, 3, 2, 2, 2, 466, 467, 3, 2, 2, 2, 467, 469, 3, 2, 2, 2, 468, 456, 3, 2, 2, 2, 468, 463, 3, 2, 2, 2, 469, 470, 3, 2, 2, 2, 470, 471, 8, 40, 2, 2, 471, 80, 3, 2, 2, 2, 472, 476, 5, 247, 124, 2, 473, 475, 5, 249, 125, 2, 474, 473, 3, 2, 2, 2, 475, 478, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 476, 477, 3, 2, 2, 2, 477, 82, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 479, 485, 9, 2, 2, 2, 480, 481, 9, 3, 2, 2, 481, 485, 9, 4, 2, 2, 482, 483, 9, 4, 2, 2, 483, 485, 9, 3, 2, 2, 484, 479, 3, 2, 2, 2, 484, 480, 3, 2, 2, 2, 484, 482, 3, 2, 2, 2, 484, 485, 3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 489, 5, 197, 99, 2, 487, 489, 5, 199, 100, 2, 488, 486, 3, 2, 2, 2, 488, 487, 3, 2, 2, 2, 489, 84, 3, 2, 2, 2, 490, 496, 9, 5, 2, 2, 491, 492, 9, 5, 2, 2, 492, 496, 9, 4, 2, 2, 493, 494, 9, 4, 2, 2, 494, 496, 9, 5, 2, 2, 495, 490, 3, 2, 2, 2, 495, 491, 3, 2, 2, 2, 495, 493, 3, 2, 2, 2, 496, 499, 3, 2, 2, 2, 497, 500, 5, 227, 114, 2, 498, 500, 5, 229, 115, 2, 499, 497, 3, 2, 2, 2, 499, 498, 3, 2, 2, 2, 500, 86, 3, 2, 2, 2, 501, 505, 5, 207, 104, 2, 502, 504, 5, 209, 105, 2, 503, 502, 3, 2, 2, 2, 504, 507, 3, 2, 2, 2, 505, 503, 3, 2, 2, 2, 505, 506, 3, 2, 2, 2, 506, 514, 3, 2, 2, 2, 507, 505, 3, 2, 2, 2, 508, 510, 7, 50, 2, 2, 509, 508, 3, 2, 2, 2, 510, 511, 3, 2, 2, 2, 511, 509, 3, 2, 2, 2, 511, 512, 3, 2, 2, 2, 512, 514, 3, 2, 2, 2, 513, 501, 3, 2, 2, 2, 513, 509, 3, 2, 2, 2, 514, 88, 3, 2, 2, 2, 515, 516, 7, 50, 2, 2, 516, 518, 9, 6, 2, 2, 517, 519, 5, 211, 106, 2, 518, 517, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 518, 3, 2, 2, 2, 520, 521, 3, 2, 2, 2, 521, 90, 3, 2, 2, 2, 522, 523, 7, 50, 2, 2, 523, 525, 9, 7, 2, 2, 524, 526, 5, 213, 107, 2, 525, 524, 3, 2, 2, 2, 526, 527, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 527, 528, 3, 2, 2, 2, 528, 92, 3, 2, 2, 2, 529, 530, 7, 50, 2, 2, 530, 532, 9, 5, 2, 2, 531, 533, 5, 215, 108, 2, 532, 531, 3, 2, 2, 2, 533, 534, 3, 2, 2, 2, 534, 532, 3, 2, 2, 2, 534, 535, 3, 2, 2, 2, 535, 94, 3, 2, 2, 2, 536, 539, 5, 217, 109, 2, 537, 539, 5, 219, 110, 2, 538, 536, 3, 2, 2, 2, 538, 537, 3, 2, 2, 2, 539, 96, 3, 2, 2, 2, 540, 543, 5, 95, 48, 2, 541, 543, 5, 221, 111, 2, 542, 540, 3, 2, 2, 2, 542, 541, 3, 2, 2, 2, 543, 544, 3, 2, 2, 2, 544, 545, 9, 8, 2, 2, 545, 98, 3, 2, 2, 2, 546, 547, 7, 48, 2, 2, 547, 100, 3, 2, 2, 2, 548, 549, 7, 48, 2, 2, 549, 550, 7, 48, 2, 2, 550, 551, 7, 48, 2, 2, 551, 102, 3, 2, 2, 2, 552, 553, 7, 44, 2, 2, 553, 104, 3, 2, 2, 2, 554, 555, 7, 42, 2, 2, 555, 556, 8, 53, 3, 2, 556, 106, 3, 2, 2, 2, 557, 558, 7, 43, 2, 2, 558, 559, 8, 54, 4, 2, 559, 108, 3, 2, 2, 2, 560, 561, 7, 46, 2, 2, 561, 110, 3, 2, 2, 2, 562, 563, 7, 60, 2, 2, 563, 112, 3, 2, 2, 2, 564, 565, 7, 61, 2, 2, 565, 114, 3, 2, 2, 2, 566, 567, 7, 44, 2, 2, 567, 568, 7, 44, 2, 2, 568, 116, 3, 2, 2, 2, 569, 570, 7, 63, 2, 2, 570, 118, 3, 2, 2, 2, 571, 572, 7, 93, 2, 2, 572, 573, 8, 60, 5, 2, 573, 120, 3, 2, 2, 2, 574, 575, 7, 95, 2, 2, 575, 576, 8, 61, 6, 2, 576, 122, 3, 2, 2, 2, 577, 578, 7, 126, 2, 2, 578, 124, 3, 2, 2, 2, 579, 580, 7, 96, 2, 2, 580, 126, 3, 2, 2, 2, 581, 582, 7, 40, 2, 2, 582, 128, 3, 2, 2, 2, 583, 584, 7, 62, 2, 2, 584, 585, 7, 62, 2, 2, 585, 130, 3, 2, 2, 2, 586, 587, 7, 64, 2, 2, 587, 588, 7, 64, 2, 2, 588, 132, 3, 2, 2, 2, 589, 590, 7, 45, 2, 2, 590, 134, 3, 2, 2, 2, 591, 592, 7, 47, 2, 2, 592, 136, 3, 2, 2, 2, 593, 594, 7, 49, 2, 2, 594, 138, 3, 2, 2, 2, 595, 596, 7, 39, 2, 2, 596, 140, 3, 2, 2, 2, 597, 598, 7, 49, 2, 2, 598, 599, 7, 49, 2, 2, 599, 142, 3, 2, 2, 2, 600, 601, 7, 128, 2, 2, 601, 144, 3, 2, 2, 2, 602, 603, 7, 125, 2, 2, 603, 604, 8, 73, 7, 2, 604, 146, 3, 2, 2, 2, 605, 606, 7, 127, 2, 2, 606, 607, 8, 74, 8, 2, 607, 148, 3, 2, 2, 2, 608, 609, 7, 62, 2, 2, 609, 150, 3, 2, 2, 2, 610, 611, 7, 64, 2, 2, 611, 152, 3, 2, 2, 2, 612, 613, 7, 63, 2, 2, 613, 614, 7, 63, 2, 2, 614, 154, 3, 2, 2, 2, 615, 616, 7, 64, 2, 2, 616, 617, 7, 63, 2, 2, 617, 156, 3, 2, 2, 2, 618, 619, 7, 62, 2, 2, 619, 620, 7, 63, 2, 2, 620, 158, 3, 2, 2, 2, 621, 622, 7, 62, 2, 2, 622, 623, 7, 64, 2, 2, 623, 160, 3, 2, 2, 2, 624, 625, 7, 35, 2, 2, 625, 626, 7, 63, 2, 2, 626, 162, 3, 2, 2, 2, 627, 628, 7, 66, 2, 2, 628, 164, 3, 2, 2, 2, 629, 630, 7, 47, 2, 2, 630, 631, 7, 64, 2, 2, 631, 166, 3, 2, 2, 2, 632, 633, 7, 45, 2, 2, 633, 634, 7, 63, 2, 2, 634, 168, 3, 2, 2, 2, 635, 636, 7, 47, 2, 2, 636, 637, 7, 63, 2, 2, 637, 170, 3, 2, 2, 2, 638, 639, 7, 44, 2, 2, 639, 640, 7, 63, 2, 2, 640, 172, 3, 2, 2, 2, 641, 642, 7, 66, 2, 2, 642, 643, 7, 63, 2, 2, 643, 174, 3, 2, 2, 2, 644, 645, 7, 49, 2, 2, 645, 646, 7, 63, 2, 2, 646, 176, 3, 2, 2, 2, 647, 648, 7, 39, 2, 2, 648, 649, 7, 63, 2, 2, 649, 178, 3, 2, 2, 2, 650, 651, 7, 40, 2, 2, 651, 652, 7, 63, 2, 2, 652, 180, 3, 2, 2, 2, 653, 654, 7, 126, 2, 2, 654, 655, 7, 63, 2, 2, 655, 182, 3, 2, 2, 2, 656, 657, 7, 96, 2, 2, 657, 658, 7, 63, 2, 2, 658, 184, 3, 2, 2, 2, 659, 660, 7, 62, 2, 2, 660, 661, 7, 62, 2, 2, 661, 662, 7, 63, 2, 2, 662, 186, 3, 2, 2, 2, 663, 664, 7, 64, 2, 2, 664, 665, 7, 64, 2, 2, 665, 666, 7, 63, 2, 2, 666, 188, 3, 2, 2, 2, 667, 668, 7, 44, 2, 2, 668, 669, 7, 44, 2, 2, 669, 670, 7, 63, 2, 2, 670, 190, 3, 2, 2, 2, 671, 672, 7, 49, 2, 2, 672, 673, 7, 49, 2, 2, 673, 674, 7, 63, 2, 2, 674, 192, 3, 2, 2, 2, 675, 679, 5, 241, 121, 2, 676, 679, 5, 243, 122, 2, 677, 679, 5, 245, 123, 2, 678, 675, 3, 2, 2, 2, 678, 676, 3, 2, 2, 2, 678, 677, 3, 2, 2, 2, 679, 680, 3, 2, 2, 2, 680, 681, 8, 97, 9, 2, 681, 194, 3, 2, 2, 2, 682, 683, 11, 2, 2, 2, 683, 196, 3, 2, 2, 2, 684, 689, 7, 41, 2, 2, 685, 688, 5, 205, 103, 2, 686, 688, 10, 9, 2, 2, 687, 685, 3, 2, 2, 2, 687, 686, 3, 2, 2, 2, 688, 691, 3, 2, 2, 2, 689, 687, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 692, 3, 2, 2, 2, 691, 689, 3, 2, 2, 2, 692, 703, 7, 41, 2, 2, 693, 698, 7, 36, 2, 2, 694, 697, 5, 205, 103, 2, 695, 697, 10, 10, 2, 2, 696, 694, 3, 2, 2, 2, 696, 695, 3, 2, 2, 2, 697, 700, 3, 2, 2, 2, 698, 696, 3, 2, 2, 2, 698, 699, 3, 2, 2, 2, 699, 701, 3, 2, 2, 2, 700, 698, 3, 2, 2, 2, 701, 703, 7, 36, 2, 2, 702, 684, 3, 2, 2, 2, 702, 693, 3, 2, 2, 2, 703, 198, 3, 2, 2, 2, 704, 705, 7, 41, 2, 2, 705, 706, 7, 41, 2, 2, 706, 707, 7, 41, 2, 2, 707, 711, 3, 2, 2, 2, 708, 710, 5, 201, 101, 2, 709, 708, 3, 2, 2, 2, 710, 713, 3, 2, 2, 2, 711, 712, 3, 2, 2, 2, 711, 709, 3, 2, 2, 2, 712, 714, 3, 2, 2, 2, 713, 711, 3, 2, 2, 2, 714, 715, 7, 41, 2, 2, 715, 716, 7, 41, 2, 2, 716, 731, 7, 41, 2, 2, 717, 718, 7, 36, 2, 2, 718, 719, 7, 36, 2, 2, 719, 720, 7, 36, 2, 2, 720, 724, 3, 2, 2, 2, 721, 723, 5, 201, 101, 2, 722, 721, 3, 2, 2, 2, 723, 726, 3, 2, 2, 2, 724, 725, 3, 2, 2, 2, 724, 722, 3, 2, 2, 2, 725, 727, 3, 2, 2, 2, 726, 724, 3, 2, 2, 2, 727, 728, 7, 36, 2, 2, 728, 729, 7, 36, 2, 2, 729, 731, 7, 36, 2, 2, 730, 704, 3, 2, 2, 2, 730, 717, 3, 2, 2, 2, 731, 200, 3, 2, 2, 2, 732, 735, 5, 203, 102, 2, 733, 735, 5, 205, 103, 2, 734, 732, 3, 2, 2, 2, 734, 733, 3, 2, 2, 2, 735, 202, 3, 2, 2, 2, 736, 737, 10, 11, 2, 2, 737, 204, 3, 2, 2, 2, 738, 739, 7, 94, 2, 2, 739, 743, 11, 2, 2, 2, 740, 741, 7, 94, 2, 2, 741, 743, 5, 79, 40, 2, 742, 738, 3, 2, 2, 2, 742, 740, 3, 2, 2, 2, 743, 206, 3, 2, 2, 2, 744, 745, 9, 12, 2, 2, 745, 208, 3, 2, 2, 2, 746, 747, 9, 13, 2, 2, 747, 210, 3, 2, 2, 2, 748, 749, 9, 14, 2, 2, 749, 212, 3, 2, 2, 2, 750, 751, 9, 15, 2, 2, 751, 214, 3, 2, 2, 2, 752, 753, 9, 16, 2, 2, 753, 216, 3, 2, 2, 2, 754, 756, 5, 221, 111, 2, 755, 754, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 757, 3, 2, 2, 2, 757, 762, 5, 223, 112, 2, 758, 759, 5, 221, 111, 2, 759, 760, 7, 48, 2, 2, 760, 762, 3, 2, 2, 2, 761, 755, 3, 2, 2, 2, 761, 758, 3, 2, 2, 2, 762, 218, 3, 2, 2, 2, 763, 766, 5, 221, 111, 2, 764, 766, 5, 217, 109, 2, 765, 763, 3, 2, 2, 2, 765, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 768, 5, 225, 113, 2, 768, 220, 3, 2, 2, 2, 769, 771, 5, 209, 105, 2, 770, 769, 3, 2, 2, 2, 771, 772, 3, 2, 2, 2, 772, 770, 3, 2, 2, 2, 772, 773, 3, 2, 2, 2, 773, 222, 3, 2, 2, 2, 774, 776, 7, 48, 2, 2, 775, 777, 5, 209, 105, 2, 776, 775, 3, 2, 2, 2, 777, 778, 3, 2, 2, 2, 778, 776, 3, 2, 2, 2, 778, 779, 3, 2, 2, 2, 779, 224, 3, 2, 2, 2, 780, 782, 9, 17, 2, 2, 781, 783, 9, 18, 2, 2, 782, 781, 3, 2, 2, 2, 782, 783, 3, 2, 2, 2, 783, 785, 3, 2, 2, 2, 784, 786, 5, 209, 105, 2, 785, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 785, 3, 2, 2, 2, 787, 788, 3, 2, 2, 2, 788, 226, 3, 2, 2, 2, 789, 794, 7, 41, 2, 2, 790, 793, 5, 233, 117, 2, 791, 793, 5, 239, 120, 2, 792, 790, 3, 2, 2, 2, 792, 791, 3, 2, 2, 2, 793, 796, 3, 2, 2, 2, 794, 792, 3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 797, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 808, 7, 41, 2, 2, 798, 803, 7, 36, 2, 2, 799, 802, 5, 235, 118, 2, 800, 802, 5, 239, 120, 2, 801, 799, 3, 2, 2, 2, 801, 800, 3, 2, 2, 2, 802, 805, 3, 2, 2, 2, 803, 801, 3, 2, 2, 2, 803, 804, 3, 2, 2, 2, 804, 806, 3, 2, 2, 2, 805, 803, 3, 2, 2, 2, 806, 808, 7, 36, 2, 2, 807, 789, 3, 2, 2, 2, 807, 798, 3, 2, 2, 2, 808, 228, 3, 2, 2, 2, 809, 810, 7, 41, 2, 2, 810, 811, 7, 41, 2, 2, 811, 812, 7, 41, 2, 2, 812, 816, 3, 2, 2, 2, 813, 815, 5, 231, 116, 2, 814, 813, 3, 2, 2, 2, 815, 818, 3, 2, 2, 2, 816, 817, 3, 2, 2, 2, 816, 814, 3, 2, 2, 2, 817, 819, 3, 2, 2, 2, 818, 816, 3, 2, 2, 2, 819, 820, 7, 41, 2, 2, 820, 821, 7, 41, 2, 2, 821, 836, 7, 41, 2, 2, 822, 823, 7, 36, 2, 2, 823, 824, 7, 36, 2, 2, 824, 825, 7, 36, 2, 2, 825, 829, 3, 2, 2, 2, 826, 828, 5, 231, 116, 2, 827, 826, 3, 2, 2, 2, 828, 831, 3, 2, 2, 2, 829, 830, 3, 2, 2, 2, 829, 827, 3, 2, 2, 2, 830, 832, 3, 2, 2, 2, 831, 829, 3, 2, 2, 2, 832, 833, 7, 36, 2, 2, 833, 834, 7, 36, 2, 2, 834, 836, 7, 36, 2, 2, 835, 809, 3, 2, 2, 2, 835, 822, 3, 2, 2, 2, 836, 230, 3, 2, 2, 2, 837, 840, 5, 237, 119, 2, 838, 840, 5, 239, 120, 2, 839, 837, 3, 2, 2, 2, 839, 838, 3, 2, 2, 2, 840, 232, 3, 2, 2, 2, 841, 843, 9, 19, 2, 2, 842, 841, 3, 2, 2, 2, 843, 234, 3, 2, 2, 2, 844, 846, 9, 20, 2, 2, 845, 844, 3, 2, 2, 2, 846, 236, 3, 2, 2, 2, 847, 849, 9, 21, 2, 2, 848, 847, 3, 2, 2, 2, 849, 238, 3, 2, 2, 2, 850, 851, 7, 94, 2, 2, 851, 852, 9, 22, 2, 2, 852, 240, 3, 2, 2, 2, 853, 855, 9, 23, 2, 2, 854, 853, 3, 2, 2, 2, 855, 856, 3, 2, 2, 2, 856, 854, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 242, 3, 2, 2, 2, 858, 862, 7, 37, 2, 2, 859, 861, 10, 24, 2, 2, 860, 859, 3, 2, 2, 2, 861, 864, 3, 2, 2, 2, 862, 860, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 244, 3, 2, 2, 2, 864, 862, 3, 2, 2, 2, 865, 867, 7, 94, 2, 2, 866, 868, 5, 241, 121, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 874, 3, 2, 2, 2, 869, 871, 7, 15, 2, 2, 870, 869, 3, 2, 2, 2, 870, 871, 3, 2, 2, 2, 871, 872, 3, 2, 2, 2, 872, 875, 7, 12, 2, 2, 873, 875, 4, 14, 15, 2, 874, 870, 3, 2, 2, 2, 874, 873, 3, 2, 2, 2, 875, 246, 3, 2, 2, 2, 876, 878, 9, 25, 2, 2, 877, 876, 3, 2, 2, 2, 878, 248, 3, 2, 2, 2, 879, 882, 5, 247, 124, 2, 880, 882, 9, 26, 2, 2, 881, 879, 3, 2, 2, 2, 881, 880, 3, 2, 2, 2, 882, 250, 3, 2, 2, 2, 60, 2, 253, 258, 264, 459, 463, 466, 468, 476, 484, 488, 495, 499, 505, 511, 513, 520, 527, 534, 538, 542, 678, 687, 689, 696, 698, 702, 711, 724, 730, 734, 742, 755, 761, 765, 772, 778, 782, 787, 792, 794, 801, 803, 807, 816, 829, 835, 839, 842, 845, 848, 856, 862, 867, 870, 874, 877, 881, 10, 3, 40, 2, 3, 53, 3, 3, 54, 4, 3, 60, 5, 3, 61, 6, 3, 73, 7, 3, 74, 8, 8, 2, 2] \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.java deleted file mode 100644 index 552f263..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.java +++ /dev/null @@ -1,803 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.python;// Generated from Python3.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CommonToken; -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.RuleContext; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.LexerATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class Python3Lexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - STRING = 1, NUMBER = 2, INTEGER = 3, DEF = 4, RETURN = 5, RAISE = 6, FROM = 7, IMPORT = 8, - AS = 9, GLOBAL = 10, NONLOCAL = 11, ASSERT = 12, IF = 13, ELIF = 14, ELSE = 15, WHILE = 16, - FOR = 17, IN = 18, TRY = 19, FINALLY = 20, WITH = 21, EXCEPT = 22, LAMBDA = 23, OR = 24, - AND = 25, NOT = 26, IS = 27, NONE = 28, TRUE = 29, FALSE = 30, CLASS = 31, YIELD = 32, - DEL = 33, PASS = 34, CONTINUE = 35, BREAK = 36, ASYNC = 37, AWAIT = 38, NEWLINE = 39, - NAME = 40, STRING_LITERAL = 41, BYTES_LITERAL = 42, DECIMAL_INTEGER = 43, OCT_INTEGER = 44, - HEX_INTEGER = 45, BIN_INTEGER = 46, FLOAT_NUMBER = 47, IMAG_NUMBER = 48, DOT = 49, - ELLIPSIS = 50, STAR = 51, OPEN_PAREN = 52, CLOSE_PAREN = 53, COMMA = 54, COLON = 55, - SEMI_COLON = 56, POWER = 57, ASSIGN = 58, OPEN_BRACK = 59, CLOSE_BRACK = 60, OR_OP = 61, - XOR = 62, AND_OP = 63, LEFT_SHIFT = 64, RIGHT_SHIFT = 65, ADD = 66, MINUS = 67, DIV = 68, - MOD = 69, IDIV = 70, NOT_OP = 71, OPEN_BRACE = 72, CLOSE_BRACE = 73, LESS_THAN = 74, - GREATER_THAN = 75, EQUALS = 76, GT_EQ = 77, LT_EQ = 78, NOT_EQ_1 = 79, NOT_EQ_2 = 80, - AT = 81, ARROW = 82, ADD_ASSIGN = 83, SUB_ASSIGN = 84, MULT_ASSIGN = 85, AT_ASSIGN = 86, - DIV_ASSIGN = 87, MOD_ASSIGN = 88, AND_ASSIGN = 89, OR_ASSIGN = 90, XOR_ASSIGN = 91, - LEFT_SHIFT_ASSIGN = 92, RIGHT_SHIFT_ASSIGN = 93, POWER_ASSIGN = 94, IDIV_ASSIGN = 95, - SKIP_ = 96, UNKNOWN_CHAR = 97; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; - - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - private static String[] makeRuleNames() { - return new String[]{ - "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", "IMPORT", - "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE", - "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", "AND", - "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", "PASS", - "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", - "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", - "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", - "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", - "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", - "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", - "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", - "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", - "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", - "SKIP_", "UNKNOWN_CHAR", "SHORT_STRING", "LONG_STRING", "LONG_STRING_ITEM", - "LONG_STRING_CHAR", "STRING_ESCAPE_SEQ", "NON_ZERO_DIGIT", "DIGIT", "OCT_DIGIT", - "HEX_DIGIT", "BIN_DIGIT", "POINT_FLOAT", "EXPONENT_FLOAT", "INT_PART", - "FRACTION", "EXPONENT", "SHORT_BYTES", "LONG_BYTES", "LONG_BYTES_ITEM", - "SHORT_BYTES_CHAR_NO_SINGLE_QUOTE", "SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE", - "LONG_BYTES_CHAR", "BYTES_ESCAPE_SEQ", "SPACES", "COMMENT", "LINE_JOINING", - "ID_START", "ID_CONTINUE" - }; - } - - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[]{ - null, null, null, null, "'def'", "'return'", "'raise'", "'from'", "'import'", - "'as'", "'global'", "'nonlocal'", "'assert'", "'if'", "'elif'", "'else'", - "'while'", "'for'", "'in'", "'try'", "'finally'", "'with'", "'except'", - "'lambda'", "'or'", "'and'", "'not'", "'is'", "'None'", "'True'", "'False'", - "'class'", "'yield'", "'del'", "'pass'", "'continue'", "'break'", "'async'", - "'await'", null, null, null, null, null, null, null, null, null, null, - "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='", - "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'", - "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", "'<='", - "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", "'/='", - "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[]{ - null, "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", - "IMPORT", "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", - "WHILE", "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", - "AND", "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", - "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", - "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", - "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", - "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", - "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", - "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", - "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", - "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", - "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", - "SKIP_", "UNKNOWN_CHAR" - }; - } - - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - - // A queue where extra tokens are pushed on (see the NEWLINE lexer rule). - private java.util.LinkedList tokens = new java.util.LinkedList<>(); - // The stack that keeps track of the indentation level. - private java.util.Stack indents = new java.util.Stack<>(); - // The amount of opened braces, brackets and parenthesis. - private int opened = 0; - // The most recently produced token. - private Token lastToken = null; - - @Override - public void emit(Token t) { - super.setToken(t); - tokens.offer(t); - } - - @Override - public Token nextToken() { - // Check if the end-of-file is ahead and there are still some DEDENTS expected. - if (_input.LA(1) == EOF && !this.indents.isEmpty()) { - // Remove any trailing EOF tokens from our buffer. - for (int i = tokens.size() - 1; i >= 0; i--) { - if (tokens.get(i).getType() == EOF) { - tokens.remove(i); - } - } - - // First emit an extra line break that serves as the end of the statement. - this.emit(commonToken(Python3Parser.NEWLINE, "\n")); - - // Now emit as much DEDENT tokens as needed. - while (!indents.isEmpty()) { - this.emit(createDedent()); - indents.pop(); - } - - // Put the EOF back on the token stream. - this.emit(commonToken(Python3Parser.EOF, "")); - } - - Token next = super.nextToken(); - - if (next.getChannel() == Token.DEFAULT_CHANNEL) { - // Keep track of the last token on the default channel. - this.lastToken = next; - } - - return tokens.isEmpty() ? next : tokens.poll(); - } - - private Token createDedent() { - CommonToken dedent = commonToken(Python3Parser.DEDENT, ""); - dedent.setLine(this.lastToken.getLine()); - return dedent; - } - - private CommonToken commonToken(int type, String text) { - int stop = this.getCharIndex() - 1; - int start = text.isEmpty() ? stop : stop - text.length() + 1; - return new CommonToken(this._tokenFactorySourcePair, type, DEFAULT_TOKEN_CHANNEL, start, stop); - } - - // Calculates the indentation of the provided spaces, taking the - // following rules into account: - // - // "Tabs are replaced (from left to right) by one to eight spaces - // such that the total number of characters up to and including - // the replacement is a multiple of eight [...]" - // - // -- https://docs.python.org/3.1/reference/lexical_analysis.html#indentation - static int getIndentationCount(String spaces) { - int count = 0; - for (char ch : spaces.toCharArray()) { - switch (ch) { - case '\t': - count += 8 - (count % 8); - break; - default: - // A normal space char. - count++; - } - } - - return count; - } - - boolean atStartOfInput() { - return super.getCharPositionInLine() == 0 && super.getLine() == 1; - } - - - public Python3Lexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "Python3.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public String[] getChannelNames() { - return channelNames; - } - - @Override - public String[] getModeNames() { - return modeNames; - } - - @Override - public ATN getATN() { - return _ATN; - } - - @Override - public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { - switch (ruleIndex) { - case 38: - NEWLINE_action((RuleContext) _localctx, actionIndex); - break; - case 51: - OPEN_PAREN_action((RuleContext) _localctx, actionIndex); - break; - case 52: - CLOSE_PAREN_action((RuleContext) _localctx, actionIndex); - break; - case 58: - OPEN_BRACK_action((RuleContext) _localctx, actionIndex); - break; - case 59: - CLOSE_BRACK_action((RuleContext) _localctx, actionIndex); - break; - case 71: - OPEN_BRACE_action((RuleContext) _localctx, actionIndex); - break; - case 72: - CLOSE_BRACE_action((RuleContext) _localctx, actionIndex); - break; - } - } - - private void NEWLINE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 0: - - String newLine = getText().replaceAll("[^\r\n\f]+", ""); - String spaces = getText().replaceAll("[\r\n\f]+", ""); - - // Strip newlines inside open clauses except if we are near EOF. We keep NEWLINEs near EOF to - // satisfy the final newline needed by the single_put rule used by the REPL. - int next = _input.LA(1); - int nextnext = _input.LA(2); - if (opened > 0 || (nextnext != -1 && (next == '\r' || next == '\n' || next == '\f' || next == '#'))) { - // If we're inside a list or on a blank line, ignore all indents, - // dedents and line breaks. - skip(); - } else { - emit(commonToken(NEWLINE, newLine)); - int indent = getIndentationCount(spaces); - int previous = indents.isEmpty() ? 0 : indents.peek(); - if (indent == previous) { - // skip indents of the same size as the present indent-size - skip(); - } else if (indent > previous) { - indents.push(indent); - emit(commonToken(Python3Parser.INDENT, spaces)); - } else { - // Possibly emit more than 1 DEDENT token. - while (!indents.isEmpty() && indents.peek() > indent) { - this.emit(createDedent()); - indents.pop(); - } - } - } - - break; - } - } - - private void OPEN_PAREN_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 1: - opened++; - break; - } - } - - private void CLOSE_PAREN_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 2: - opened--; - break; - } - } - - private void OPEN_BRACK_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 3: - opened++; - break; - } - } - - private void CLOSE_BRACK_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 4: - opened--; - break; - } - } - - private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 5: - opened++; - break; - } - } - - private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 6: - opened--; - break; - } - } - - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 38: - return NEWLINE_sempred((RuleContext) _localctx, predIndex); - } - return true; - } - - private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return atStartOfInput(); - } - return true; - } - - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2c\u0373\b\1\4\2\t" + - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13" + - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31" + - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!" + - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4" + - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t" + - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=" + - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I" + - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT" + - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4" + - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t" + - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4" + - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\3\2\3\2\5\2\u00fe\n\2\3\3\3\3" + - "\3\3\5\3\u0103\n\3\3\4\3\4\3\4\3\4\5\4\u0109\n\4\3\5\3\5\3\5\3\5\3\6\3" + - "\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t" + - "\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13" + - "\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16" + - "\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21" + - "\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24" + - "\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26" + - "\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30" + - "\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3\34\3\34" + - "\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37" + - "\3\37\3\37\3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3#\3#\3" + - "#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3" + - "&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\5(\u01cc\n(\3(\3(\5(\u01d0\n(\3(\5" + - "(\u01d3\n(\5(\u01d5\n(\3(\3(\3)\3)\7)\u01db\n)\f)\16)\u01de\13)\3*\3*" + - "\3*\3*\3*\5*\u01e5\n*\3*\3*\5*\u01e9\n*\3+\3+\3+\3+\3+\5+\u01f0\n+\3+" + - "\3+\5+\u01f4\n+\3,\3,\7,\u01f8\n,\f,\16,\u01fb\13,\3,\6,\u01fe\n,\r,\16" + - ",\u01ff\5,\u0202\n,\3-\3-\3-\6-\u0207\n-\r-\16-\u0208\3.\3.\3.\6.\u020e" + - "\n.\r.\16.\u020f\3/\3/\3/\6/\u0215\n/\r/\16/\u0216\3\60\3\60\5\60\u021b" + - "\n\60\3\61\3\61\5\61\u021f\n\61\3\61\3\61\3\62\3\62\3\63\3\63\3\63\3\63" + - "\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\38\38\39\39\3:\3:\3" + - ":\3;\3;\3<\3<\3<\3=\3=\3=\3>\3>\3?\3?\3@\3@\3A\3A\3A\3B\3B\3B\3C\3C\3" + - "D\3D\3E\3E\3F\3F\3G\3G\3G\3H\3H\3I\3I\3I\3J\3J\3J\3K\3K\3L\3L\3M\3M\3" + - "M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3S\3S\3S\3T\3T\3T\3U\3U\3" + - "U\3V\3V\3V\3W\3W\3W\3X\3X\3X\3Y\3Y\3Y\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`\3a\3a\3a\5a\u02a7\na\3" + - "a\3a\3b\3b\3c\3c\3c\7c\u02b0\nc\fc\16c\u02b3\13c\3c\3c\3c\3c\7c\u02b9" + - "\nc\fc\16c\u02bc\13c\3c\5c\u02bf\nc\3d\3d\3d\3d\3d\7d\u02c6\nd\fd\16d" + - "\u02c9\13d\3d\3d\3d\3d\3d\3d\3d\3d\7d\u02d3\nd\fd\16d\u02d6\13d\3d\3d" + - "\3d\5d\u02db\nd\3e\3e\5e\u02df\ne\3f\3f\3g\3g\3g\3g\5g\u02e7\ng\3h\3h" + - "\3i\3i\3j\3j\3k\3k\3l\3l\3m\5m\u02f4\nm\3m\3m\3m\3m\5m\u02fa\nm\3n\3n" + - "\5n\u02fe\nn\3n\3n\3o\6o\u0303\no\ro\16o\u0304\3p\3p\6p\u0309\np\rp\16" + - "p\u030a\3q\3q\5q\u030f\nq\3q\6q\u0312\nq\rq\16q\u0313\3r\3r\3r\7r\u0319" + - "\nr\fr\16r\u031c\13r\3r\3r\3r\3r\7r\u0322\nr\fr\16r\u0325\13r\3r\5r\u0328" + - "\nr\3s\3s\3s\3s\3s\7s\u032f\ns\fs\16s\u0332\13s\3s\3s\3s\3s\3s\3s\3s\3" + - "s\7s\u033c\ns\fs\16s\u033f\13s\3s\3s\3s\5s\u0344\ns\3t\3t\5t\u0348\nt" + - "\3u\5u\u034b\nu\3v\5v\u034e\nv\3w\5w\u0351\nw\3x\3x\3x\3y\6y\u0357\ny" + - "\ry\16y\u0358\3z\3z\7z\u035d\nz\fz\16z\u0360\13z\3{\3{\5{\u0364\n{\3{" + - "\5{\u0367\n{\3{\3{\5{\u036b\n{\3|\5|\u036e\n|\3}\3}\5}\u0372\n}\6\u02c7" + - "\u02d4\u0330\u033d\2~\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27" + - "\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33" + - "\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63" + - "e\64g\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089" + - "F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009d" + - "P\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1" + - "Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5" + - "\2\u00c7\2\u00c9\2\u00cb\2\u00cd\2\u00cf\2\u00d1\2\u00d3\2\u00d5\2\u00d7" + - "\2\u00d9\2\u00db\2\u00dd\2\u00df\2\u00e1\2\u00e3\2\u00e5\2\u00e7\2\u00e9" + - "\2\u00eb\2\u00ed\2\u00ef\2\u00f1\2\u00f3\2\u00f5\2\u00f7\2\u00f9\2\3\2" + - "\33\b\2HHTTWWhhttww\4\2HHhh\4\2TTtt\4\2DDdd\4\2QQqq\4\2ZZzz\4\2LLll\6" + - "\2\f\f\16\17))^^\6\2\f\f\16\17$$^^\3\2^^\3\2\63;\3\2\62;\3\2\629\5\2\62" + - ";CHch\3\2\62\63\4\2GGgg\4\2--//\7\2\2\13\r\16\20(*]_\u0081\7\2\2\13\r" + - "\16\20#%]_\u0081\4\2\2]_\u0081\3\2\2\u0081\4\2\13\13\"\"\4\2\f\f\16\17" + - "\u0129\2C\\aac|\u00ac\u00ac\u00b7\u00b7\u00bc\u00bc\u00c2\u00d8\u00da" + - "\u00f8\u00fa\u0243\u0252\u02c3\u02c8\u02d3\u02e2\u02e6\u02f0\u02f0\u037c" + - "\u037c\u0388\u0388\u038a\u038c\u038e\u038e\u0390\u03a3\u03a5\u03d0\u03d2" + - "\u03f7\u03f9\u0483\u048c\u04d0\u04d2\u04fb\u0502\u0511\u0533\u0558\u055b" + - "\u055b\u0563\u0589\u05d2\u05ec\u05f2\u05f4\u0623\u063c\u0642\u064c\u0670" + - "\u0671\u0673\u06d5\u06d7\u06d7\u06e7\u06e8\u06f0\u06f1\u06fc\u06fe\u0701" + - "\u0701\u0712\u0712\u0714\u0731\u074f\u076f\u0782\u07a7\u07b3\u07b3\u0906" + - "\u093b\u093f\u093f\u0952\u0952\u095a\u0963\u097f\u097f\u0987\u098e\u0991" + - "\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0" + - "\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15" + - "\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60" + - "\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4" + - "\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11" + - "\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e" + - "\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94" + - "\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0" + - "\u0bbb\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c62" + - "\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf" + - "\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d2a\u0d2c" + - "\u0d3b\u0d62\u0d63\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2" + - "\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e48\u0e83\u0e84\u0e86\u0e86\u0e89" + - "\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7" + - "\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2" + - "\u0ec6\u0ec8\u0ec8\u0ede\u0edf\u0f02\u0f02\u0f42\u0f49\u0f4b\u0f6c\u0f8a" + - "\u0f8d\u1002\u1023\u1025\u1029\u102b\u102c\u1052\u1057\u10a2\u10c7\u10d2" + - "\u10fc\u10fe\u10fe\u1102\u115b\u1161\u11a4\u11aa\u11fb\u1202\u124a\u124c" + - "\u124f\u1252\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292" + - "\u12b2\u12b4\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da" + - "\u1312\u1314\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671" + - "\u1678\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710\u1713\u1722" + - "\u1733\u1742\u1753\u1762\u176e\u1770\u1772\u1782\u17b5\u17d9\u17d9\u17de" + - "\u17de\u1822\u1879\u1882\u18aa\u1902\u191e\u1952\u196f\u1972\u1976\u1982" + - "\u19ab\u19c3\u19c9\u1a02\u1a18\u1d02\u1dc1\u1e02\u1e9d\u1ea2\u1efb\u1f02" + - "\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a\u1f4f\u1f52\u1f59\u1f5b\u1f5b\u1f5d" + - "\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0\u1fc4" + - "\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8\u1fdd\u1fe2\u1fee\u1ff4\u1ff6\u1ff8" + - "\u1ffe\u2073\u2073\u2081\u2081\u2092\u2096\u2104\u2104\u2109\u2109\u210c" + - "\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128\u2128\u212a\u212a\u212c" + - "\u2133\u2135\u213b\u213e\u2141\u2147\u214b\u2162\u2185\u2c02\u2c30\u2c32" + - "\u2c60\u2c82\u2ce6\u2d02\u2d27\u2d32\u2d67\u2d71\u2d71\u2d82\u2d98\u2da2" + - "\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2" + - "\u2dd8\u2dda\u2de0\u3007\u3009\u3023\u302b\u3033\u3037\u303a\u303e\u3043" + - "\u3098\u309d\u30a1\u30a3\u30fc\u30fe\u3101\u3107\u312e\u3133\u3190\u31a2" + - "\u31b9\u31f2\u3201\u3402\u4db7\u4e02\u9fbd\ua002\ua48e\ua802\ua803\ua805" + - "\ua807\ua809\ua80c\ua80e\ua824\uac02\ud7a5\uf902\ufa2f\ufa32\ufa6c\ufa72" + - "\ufadb\ufb02\ufb08\ufb15\ufb19\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a" + - "\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52" + - "\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff23\uff3c\uff43" + - "\uff5c\uff68\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0096" + - "\2\62;\u0302\u0371\u0485\u0488\u0593\u05bb\u05bd\u05bf\u05c1\u05c1\u05c3" + - "\u05c4\u05c6\u05c7\u05c9\u05c9\u0612\u0617\u064d\u0660\u0662\u066b\u0672" + - "\u0672\u06d8\u06de\u06e1\u06e6\u06e9\u06ea\u06ec\u06ef\u06f2\u06fb\u0713" + - "\u0713\u0732\u074c\u07a8\u07b2\u0903\u0905\u093e\u093e\u0940\u094f\u0953" + - "\u0956\u0964\u0965\u0968\u0971\u0983\u0985\u09be\u09be\u09c0\u09c6\u09c9" + - "\u09ca\u09cd\u09cf\u09d9\u09d9\u09e4\u09e5\u09e8\u09f1\u0a03\u0a05\u0a3e" + - "\u0a3e\u0a40\u0a44\u0a49\u0a4a\u0a4d\u0a4f\u0a68\u0a73\u0a83\u0a85\u0abe" + - "\u0abe\u0ac0\u0ac7\u0ac9\u0acb\u0acd\u0acf\u0ae4\u0ae5\u0ae8\u0af1\u0b03" + - "\u0b05\u0b3e\u0b3e\u0b40\u0b45\u0b49\u0b4a\u0b4d\u0b4f\u0b58\u0b59\u0b68" + - "\u0b71\u0b84\u0b84\u0bc0\u0bc4\u0bc8\u0bca\u0bcc\u0bcf\u0bd9\u0bd9\u0be8" + - "\u0bf1\u0c03\u0c05\u0c40\u0c46\u0c48\u0c4a\u0c4c\u0c4f\u0c57\u0c58\u0c68" + - "\u0c71\u0c84\u0c85\u0cbe\u0cbe\u0cc0\u0cc6\u0cc8\u0cca\u0ccc\u0ccf\u0cd7" + - "\u0cd8\u0ce8\u0cf1\u0d04\u0d05\u0d40\u0d45\u0d48\u0d4a\u0d4c\u0d4f\u0d59" + - "\u0d59\u0d68\u0d71\u0d84\u0d85\u0dcc\u0dcc\u0dd1\u0dd6\u0dd8\u0dd8\u0dda" + - "\u0de1\u0df4\u0df5\u0e33\u0e33\u0e36\u0e3c\u0e49\u0e50\u0e52\u0e5b\u0eb3" + - "\u0eb3\u0eb6\u0ebb\u0ebd\u0ebe\u0eca\u0ecf\u0ed2\u0edb\u0f1a\u0f1b\u0f22" + - "\u0f2b\u0f37\u0f37\u0f39\u0f39\u0f3b\u0f3b\u0f40\u0f41\u0f73\u0f86\u0f88" + - "\u0f89\u0f92\u0f99\u0f9b\u0fbe\u0fc8\u0fc8\u102e\u1034\u1038\u103b\u1042" + - "\u104b\u1058\u105b\u1361\u1361\u136b\u1373\u1714\u1716\u1734\u1736\u1754" + - "\u1755\u1774\u1775\u17b8\u17d5\u17df\u17df\u17e2\u17eb\u180d\u180f\u1812" + - "\u181b\u18ab\u18ab\u1922\u192d\u1932\u193d\u1948\u1951\u19b2\u19c2\u19ca" + - "\u19cb\u19d2\u19db\u1a19\u1a1d\u1dc2\u1dc5\u2041\u2042\u2056\u2056\u20d2" + - "\u20de\u20e3\u20e3\u20e7\u20ed\u302c\u3031\u309b\u309c\ua804\ua804\ua808" + - "\ua808\ua80d\ua80d\ua825\ua829\ufb20\ufb20\ufe02\ufe11\ufe22\ufe25\ufe35" + - "\ufe36\ufe4f\ufe51\uff12\uff1b\uff41\uff41\2\u0393\2\3\3\2\2\2\2\5\3\2" + - "\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21" + - "\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2" + - "\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3" + - "\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3" + - "\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3" + - "\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2" + - "\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2" + - "Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3" + - "\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2" + - "\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2" + - "\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3" + - "\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2" + - "\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099" + - "\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2" + - "\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab" + - "\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2" + - "\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd" + - "\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\3\u00fd\3\2\2" + - "\2\5\u0102\3\2\2\2\7\u0108\3\2\2\2\t\u010a\3\2\2\2\13\u010e\3\2\2\2\r" + - "\u0115\3\2\2\2\17\u011b\3\2\2\2\21\u0120\3\2\2\2\23\u0127\3\2\2\2\25\u012a" + - "\3\2\2\2\27\u0131\3\2\2\2\31\u013a\3\2\2\2\33\u0141\3\2\2\2\35\u0144\3" + - "\2\2\2\37\u0149\3\2\2\2!\u014e\3\2\2\2#\u0154\3\2\2\2%\u0158\3\2\2\2\'" + - "\u015b\3\2\2\2)\u015f\3\2\2\2+\u0167\3\2\2\2-\u016c\3\2\2\2/\u0173\3\2" + - "\2\2\61\u017a\3\2\2\2\63\u017d\3\2\2\2\65\u0181\3\2\2\2\67\u0185\3\2\2" + - "\29\u0188\3\2\2\2;\u018d\3\2\2\2=\u0192\3\2\2\2?\u0198\3\2\2\2A\u019e" + - "\3\2\2\2C\u01a4\3\2\2\2E\u01a8\3\2\2\2G\u01ad\3\2\2\2I\u01b6\3\2\2\2K" + - "\u01bc\3\2\2\2M\u01c2\3\2\2\2O\u01d4\3\2\2\2Q\u01d8\3\2\2\2S\u01e4\3\2" + - "\2\2U\u01ef\3\2\2\2W\u0201\3\2\2\2Y\u0203\3\2\2\2[\u020a\3\2\2\2]\u0211" + - "\3\2\2\2_\u021a\3\2\2\2a\u021e\3\2\2\2c\u0222\3\2\2\2e\u0224\3\2\2\2g" + - "\u0228\3\2\2\2i\u022a\3\2\2\2k\u022d\3\2\2\2m\u0230\3\2\2\2o\u0232\3\2" + - "\2\2q\u0234\3\2\2\2s\u0236\3\2\2\2u\u0239\3\2\2\2w\u023b\3\2\2\2y\u023e" + - "\3\2\2\2{\u0241\3\2\2\2}\u0243\3\2\2\2\177\u0245\3\2\2\2\u0081\u0247\3" + - "\2\2\2\u0083\u024a\3\2\2\2\u0085\u024d\3\2\2\2\u0087\u024f\3\2\2\2\u0089" + - "\u0251\3\2\2\2\u008b\u0253\3\2\2\2\u008d\u0255\3\2\2\2\u008f\u0258\3\2" + - "\2\2\u0091\u025a\3\2\2\2\u0093\u025d\3\2\2\2\u0095\u0260\3\2\2\2\u0097" + - "\u0262\3\2\2\2\u0099\u0264\3\2\2\2\u009b\u0267\3\2\2\2\u009d\u026a\3\2" + - "\2\2\u009f\u026d\3\2\2\2\u00a1\u0270\3\2\2\2\u00a3\u0273\3\2\2\2\u00a5" + - "\u0275\3\2\2\2\u00a7\u0278\3\2\2\2\u00a9\u027b\3\2\2\2\u00ab\u027e\3\2" + - "\2\2\u00ad\u0281\3\2\2\2\u00af\u0284\3\2\2\2\u00b1\u0287\3\2\2\2\u00b3" + - "\u028a\3\2\2\2\u00b5\u028d\3\2\2\2\u00b7\u0290\3\2\2\2\u00b9\u0293\3\2" + - "\2\2\u00bb\u0297\3\2\2\2\u00bd\u029b\3\2\2\2\u00bf\u029f\3\2\2\2\u00c1" + - "\u02a6\3\2\2\2\u00c3\u02aa\3\2\2\2\u00c5\u02be\3\2\2\2\u00c7\u02da\3\2" + - "\2\2\u00c9\u02de\3\2\2\2\u00cb\u02e0\3\2\2\2\u00cd\u02e6\3\2\2\2\u00cf" + - "\u02e8\3\2\2\2\u00d1\u02ea\3\2\2\2\u00d3\u02ec\3\2\2\2\u00d5\u02ee\3\2" + - "\2\2\u00d7\u02f0\3\2\2\2\u00d9\u02f9\3\2\2\2\u00db\u02fd\3\2\2\2\u00dd" + - "\u0302\3\2\2\2\u00df\u0306\3\2\2\2\u00e1\u030c\3\2\2\2\u00e3\u0327\3\2" + - "\2\2\u00e5\u0343\3\2\2\2\u00e7\u0347\3\2\2\2\u00e9\u034a\3\2\2\2\u00eb" + - "\u034d\3\2\2\2\u00ed\u0350\3\2\2\2\u00ef\u0352\3\2\2\2\u00f1\u0356\3\2" + - "\2\2\u00f3\u035a\3\2\2\2\u00f5\u0361\3\2\2\2\u00f7\u036d\3\2\2\2\u00f9" + - "\u0371\3\2\2\2\u00fb\u00fe\5S*\2\u00fc\u00fe\5U+\2\u00fd\u00fb\3\2\2\2" + - "\u00fd\u00fc\3\2\2\2\u00fe\4\3\2\2\2\u00ff\u0103\5\7\4\2\u0100\u0103\5" + - "_\60\2\u0101\u0103\5a\61\2\u0102\u00ff\3\2\2\2\u0102\u0100\3\2\2\2\u0102" + - "\u0101\3\2\2\2\u0103\6\3\2\2\2\u0104\u0109\5W,\2\u0105\u0109\5Y-\2\u0106" + - "\u0109\5[.\2\u0107\u0109\5]/\2\u0108\u0104\3\2\2\2\u0108\u0105\3\2\2\2" + - "\u0108\u0106\3\2\2\2\u0108\u0107\3\2\2\2\u0109\b\3\2\2\2\u010a\u010b\7" + - "f\2\2\u010b\u010c\7g\2\2\u010c\u010d\7h\2\2\u010d\n\3\2\2\2\u010e\u010f" + - "\7t\2\2\u010f\u0110\7g\2\2\u0110\u0111\7v\2\2\u0111\u0112\7w\2\2\u0112" + - "\u0113\7t\2\2\u0113\u0114\7p\2\2\u0114\f\3\2\2\2\u0115\u0116\7t\2\2\u0116" + - "\u0117\7c\2\2\u0117\u0118\7k\2\2\u0118\u0119\7u\2\2\u0119\u011a\7g\2\2" + - "\u011a\16\3\2\2\2\u011b\u011c\7h\2\2\u011c\u011d\7t\2\2\u011d\u011e\7" + - "q\2\2\u011e\u011f\7o\2\2\u011f\20\3\2\2\2\u0120\u0121\7k\2\2\u0121\u0122" + - "\7o\2\2\u0122\u0123\7r\2\2\u0123\u0124\7q\2\2\u0124\u0125\7t\2\2\u0125" + - "\u0126\7v\2\2\u0126\22\3\2\2\2\u0127\u0128\7c\2\2\u0128\u0129\7u\2\2\u0129" + - "\24\3\2\2\2\u012a\u012b\7i\2\2\u012b\u012c\7n\2\2\u012c\u012d\7q\2\2\u012d" + - "\u012e\7d\2\2\u012e\u012f\7c\2\2\u012f\u0130\7n\2\2\u0130\26\3\2\2\2\u0131" + - "\u0132\7p\2\2\u0132\u0133\7q\2\2\u0133\u0134\7p\2\2\u0134\u0135\7n\2\2" + - "\u0135\u0136\7q\2\2\u0136\u0137\7e\2\2\u0137\u0138\7c\2\2\u0138\u0139" + - "\7n\2\2\u0139\30\3\2\2\2\u013a\u013b\7c\2\2\u013b\u013c\7u\2\2\u013c\u013d" + - "\7u\2\2\u013d\u013e\7g\2\2\u013e\u013f\7t\2\2\u013f\u0140\7v\2\2\u0140" + - "\32\3\2\2\2\u0141\u0142\7k\2\2\u0142\u0143\7h\2\2\u0143\34\3\2\2\2\u0144" + - "\u0145\7g\2\2\u0145\u0146\7n\2\2\u0146\u0147\7k\2\2\u0147\u0148\7h\2\2" + - "\u0148\36\3\2\2\2\u0149\u014a\7g\2\2\u014a\u014b\7n\2\2\u014b\u014c\7" + - "u\2\2\u014c\u014d\7g\2\2\u014d \3\2\2\2\u014e\u014f\7y\2\2\u014f\u0150" + - "\7j\2\2\u0150\u0151\7k\2\2\u0151\u0152\7n\2\2\u0152\u0153\7g\2\2\u0153" + - "\"\3\2\2\2\u0154\u0155\7h\2\2\u0155\u0156\7q\2\2\u0156\u0157\7t\2\2\u0157" + - "$\3\2\2\2\u0158\u0159\7k\2\2\u0159\u015a\7p\2\2\u015a&\3\2\2\2\u015b\u015c" + - "\7v\2\2\u015c\u015d\7t\2\2\u015d\u015e\7{\2\2\u015e(\3\2\2\2\u015f\u0160" + - "\7h\2\2\u0160\u0161\7k\2\2\u0161\u0162\7p\2\2\u0162\u0163\7c\2\2\u0163" + - "\u0164\7n\2\2\u0164\u0165\7n\2\2\u0165\u0166\7{\2\2\u0166*\3\2\2\2\u0167" + - "\u0168\7y\2\2\u0168\u0169\7k\2\2\u0169\u016a\7v\2\2\u016a\u016b\7j\2\2" + - "\u016b,\3\2\2\2\u016c\u016d\7g\2\2\u016d\u016e\7z\2\2\u016e\u016f\7e\2" + - "\2\u016f\u0170\7g\2\2\u0170\u0171\7r\2\2\u0171\u0172\7v\2\2\u0172.\3\2" + - "\2\2\u0173\u0174\7n\2\2\u0174\u0175\7c\2\2\u0175\u0176\7o\2\2\u0176\u0177" + - "\7d\2\2\u0177\u0178\7f\2\2\u0178\u0179\7c\2\2\u0179\60\3\2\2\2\u017a\u017b" + - "\7q\2\2\u017b\u017c\7t\2\2\u017c\62\3\2\2\2\u017d\u017e\7c\2\2\u017e\u017f" + - "\7p\2\2\u017f\u0180\7f\2\2\u0180\64\3\2\2\2\u0181\u0182\7p\2\2\u0182\u0183" + - "\7q\2\2\u0183\u0184\7v\2\2\u0184\66\3\2\2\2\u0185\u0186\7k\2\2\u0186\u0187" + - "\7u\2\2\u01878\3\2\2\2\u0188\u0189\7P\2\2\u0189\u018a\7q\2\2\u018a\u018b" + - "\7p\2\2\u018b\u018c\7g\2\2\u018c:\3\2\2\2\u018d\u018e\7V\2\2\u018e\u018f" + - "\7t\2\2\u018f\u0190\7w\2\2\u0190\u0191\7g\2\2\u0191<\3\2\2\2\u0192\u0193" + - "\7H\2\2\u0193\u0194\7c\2\2\u0194\u0195\7n\2\2\u0195\u0196\7u\2\2\u0196" + - "\u0197\7g\2\2\u0197>\3\2\2\2\u0198\u0199\7e\2\2\u0199\u019a\7n\2\2\u019a" + - "\u019b\7c\2\2\u019b\u019c\7u\2\2\u019c\u019d\7u\2\2\u019d@\3\2\2\2\u019e" + - "\u019f\7{\2\2\u019f\u01a0\7k\2\2\u01a0\u01a1\7g\2\2\u01a1\u01a2\7n\2\2" + - "\u01a2\u01a3\7f\2\2\u01a3B\3\2\2\2\u01a4\u01a5\7f\2\2\u01a5\u01a6\7g\2" + - "\2\u01a6\u01a7\7n\2\2\u01a7D\3\2\2\2\u01a8\u01a9\7r\2\2\u01a9\u01aa\7" + - "c\2\2\u01aa\u01ab\7u\2\2\u01ab\u01ac\7u\2\2\u01acF\3\2\2\2\u01ad\u01ae" + - "\7e\2\2\u01ae\u01af\7q\2\2\u01af\u01b0\7p\2\2\u01b0\u01b1\7v\2\2\u01b1" + - "\u01b2\7k\2\2\u01b2\u01b3\7p\2\2\u01b3\u01b4\7w\2\2\u01b4\u01b5\7g\2\2" + - "\u01b5H\3\2\2\2\u01b6\u01b7\7d\2\2\u01b7\u01b8\7t\2\2\u01b8\u01b9\7g\2" + - "\2\u01b9\u01ba\7c\2\2\u01ba\u01bb\7m\2\2\u01bbJ\3\2\2\2\u01bc\u01bd\7" + - "c\2\2\u01bd\u01be\7u\2\2\u01be\u01bf\7{\2\2\u01bf\u01c0\7p\2\2\u01c0\u01c1" + - "\7e\2\2\u01c1L\3\2\2\2\u01c2\u01c3\7c\2\2\u01c3\u01c4\7y\2\2\u01c4\u01c5" + - "\7c\2\2\u01c5\u01c6\7k\2\2\u01c6\u01c7\7v\2\2\u01c7N\3\2\2\2\u01c8\u01c9" + - "\6(\2\2\u01c9\u01d5\5\u00f1y\2\u01ca\u01cc\7\17\2\2\u01cb\u01ca\3\2\2" + - "\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0\7\f\2\2\u01ce\u01d0" + - "\4\16\17\2\u01cf\u01cb\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d2\3\2\2\2" + - "\u01d1\u01d3\5\u00f1y\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3" + - "\u01d5\3\2\2\2\u01d4\u01c8\3\2\2\2\u01d4\u01cf\3\2\2\2\u01d5\u01d6\3\2" + - "\2\2\u01d6\u01d7\b(\2\2\u01d7P\3\2\2\2\u01d8\u01dc\5\u00f7|\2\u01d9\u01db" + - "\5\u00f9}\2\u01da\u01d9\3\2\2\2\u01db\u01de\3\2\2\2\u01dc\u01da\3\2\2" + - "\2\u01dc\u01dd\3\2\2\2\u01ddR\3\2\2\2\u01de\u01dc\3\2\2\2\u01df\u01e5" + - "\t\2\2\2\u01e0\u01e1\t\3\2\2\u01e1\u01e5\t\4\2\2\u01e2\u01e3\t\4\2\2\u01e3" + - "\u01e5\t\3\2\2\u01e4\u01df\3\2\2\2\u01e4\u01e0\3\2\2\2\u01e4\u01e2\3\2" + - "\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e8\3\2\2\2\u01e6\u01e9\5\u00c5c\2\u01e7" + - "\u01e9\5\u00c7d\2\u01e8\u01e6\3\2\2\2\u01e8\u01e7\3\2\2\2\u01e9T\3\2\2" + - "\2\u01ea\u01f0\t\5\2\2\u01eb\u01ec\t\5\2\2\u01ec\u01f0\t\4\2\2\u01ed\u01ee" + - "\t\4\2\2\u01ee\u01f0\t\5\2\2\u01ef\u01ea\3\2\2\2\u01ef\u01eb\3\2\2\2\u01ef" + - "\u01ed\3\2\2\2\u01f0\u01f3\3\2\2\2\u01f1\u01f4\5\u00e3r\2\u01f2\u01f4" + - "\5\u00e5s\2\u01f3\u01f1\3\2\2\2\u01f3\u01f2\3\2\2\2\u01f4V\3\2\2\2\u01f5" + - "\u01f9\5\u00cfh\2\u01f6\u01f8\5\u00d1i\2\u01f7\u01f6\3\2\2\2\u01f8\u01fb" + - "\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u0202\3\2\2\2\u01fb" + - "\u01f9\3\2\2\2\u01fc\u01fe\7\62\2\2\u01fd\u01fc\3\2\2\2\u01fe\u01ff\3" + - "\2\2\2\u01ff\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0202\3\2\2\2\u0201" + - "\u01f5\3\2\2\2\u0201\u01fd\3\2\2\2\u0202X\3\2\2\2\u0203\u0204\7\62\2\2" + - "\u0204\u0206\t\6\2\2\u0205\u0207\5\u00d3j\2\u0206\u0205\3\2\2\2\u0207" + - "\u0208\3\2\2\2\u0208\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209Z\3\2\2\2" + - "\u020a\u020b\7\62\2\2\u020b\u020d\t\7\2\2\u020c\u020e\5\u00d5k\2\u020d" + - "\u020c\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2" + - "\2\2\u0210\\\3\2\2\2\u0211\u0212\7\62\2\2\u0212\u0214\t\5\2\2\u0213\u0215" + - "\5\u00d7l\2\u0214\u0213\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0214\3\2\2" + - "\2\u0216\u0217\3\2\2\2\u0217^\3\2\2\2\u0218\u021b\5\u00d9m\2\u0219\u021b" + - "\5\u00dbn\2\u021a\u0218\3\2\2\2\u021a\u0219\3\2\2\2\u021b`\3\2\2\2\u021c" + - "\u021f\5_\60\2\u021d\u021f\5\u00ddo\2\u021e\u021c\3\2\2\2\u021e\u021d" + - "\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\t\b\2\2\u0221b\3\2\2\2\u0222" + - "\u0223\7\60\2\2\u0223d\3\2\2\2\u0224\u0225\7\60\2\2\u0225\u0226\7\60\2" + - "\2\u0226\u0227\7\60\2\2\u0227f\3\2\2\2\u0228\u0229\7,\2\2\u0229h\3\2\2" + - "\2\u022a\u022b\7*\2\2\u022b\u022c\b\65\3\2\u022cj\3\2\2\2\u022d\u022e" + - "\7+\2\2\u022e\u022f\b\66\4\2\u022fl\3\2\2\2\u0230\u0231\7.\2\2\u0231n" + - "\3\2\2\2\u0232\u0233\7<\2\2\u0233p\3\2\2\2\u0234\u0235\7=\2\2\u0235r\3" + - "\2\2\2\u0236\u0237\7,\2\2\u0237\u0238\7,\2\2\u0238t\3\2\2\2\u0239\u023a" + - "\7?\2\2\u023av\3\2\2\2\u023b\u023c\7]\2\2\u023c\u023d\b<\5\2\u023dx\3" + - "\2\2\2\u023e\u023f\7_\2\2\u023f\u0240\b=\6\2\u0240z\3\2\2\2\u0241\u0242" + - "\7~\2\2\u0242|\3\2\2\2\u0243\u0244\7`\2\2\u0244~\3\2\2\2\u0245\u0246\7" + - "(\2\2\u0246\u0080\3\2\2\2\u0247\u0248\7>\2\2\u0248\u0249\7>\2\2\u0249" + - "\u0082\3\2\2\2\u024a\u024b\7@\2\2\u024b\u024c\7@\2\2\u024c\u0084\3\2\2" + - "\2\u024d\u024e\7-\2\2\u024e\u0086\3\2\2\2\u024f\u0250\7/\2\2\u0250\u0088" + - "\3\2\2\2\u0251\u0252\7\61\2\2\u0252\u008a\3\2\2\2\u0253\u0254\7\'\2\2" + - "\u0254\u008c\3\2\2\2\u0255\u0256\7\61\2\2\u0256\u0257\7\61\2\2\u0257\u008e" + - "\3\2\2\2\u0258\u0259\7\u0080\2\2\u0259\u0090\3\2\2\2\u025a\u025b\7}\2" + - "\2\u025b\u025c\bI\7\2\u025c\u0092\3\2\2\2\u025d\u025e\7\177\2\2\u025e" + - "\u025f\bJ\b\2\u025f\u0094\3\2\2\2\u0260\u0261\7>\2\2\u0261\u0096\3\2\2" + - "\2\u0262\u0263\7@\2\2\u0263\u0098\3\2\2\2\u0264\u0265\7?\2\2\u0265\u0266" + - "\7?\2\2\u0266\u009a\3\2\2\2\u0267\u0268\7@\2\2\u0268\u0269\7?\2\2\u0269" + - "\u009c\3\2\2\2\u026a\u026b\7>\2\2\u026b\u026c\7?\2\2\u026c\u009e\3\2\2" + - "\2\u026d\u026e\7>\2\2\u026e\u026f\7@\2\2\u026f\u00a0\3\2\2\2\u0270\u0271" + - "\7#\2\2\u0271\u0272\7?\2\2\u0272\u00a2\3\2\2\2\u0273\u0274\7B\2\2\u0274" + - "\u00a4\3\2\2\2\u0275\u0276\7/\2\2\u0276\u0277\7@\2\2\u0277\u00a6\3\2\2" + - "\2\u0278\u0279\7-\2\2\u0279\u027a\7?\2\2\u027a\u00a8\3\2\2\2\u027b\u027c" + - "\7/\2\2\u027c\u027d\7?\2\2\u027d\u00aa\3\2\2\2\u027e\u027f\7,\2\2\u027f" + - "\u0280\7?\2\2\u0280\u00ac\3\2\2\2\u0281\u0282\7B\2\2\u0282\u0283\7?\2" + - "\2\u0283\u00ae\3\2\2\2\u0284\u0285\7\61\2\2\u0285\u0286\7?\2\2\u0286\u00b0" + - "\3\2\2\2\u0287\u0288\7\'\2\2\u0288\u0289\7?\2\2\u0289\u00b2\3\2\2\2\u028a" + - "\u028b\7(\2\2\u028b\u028c\7?\2\2\u028c\u00b4\3\2\2\2\u028d\u028e\7~\2" + - "\2\u028e\u028f\7?\2\2\u028f\u00b6\3\2\2\2\u0290\u0291\7`\2\2\u0291\u0292" + - "\7?\2\2\u0292\u00b8\3\2\2\2\u0293\u0294\7>\2\2\u0294\u0295\7>\2\2\u0295" + - "\u0296\7?\2\2\u0296\u00ba\3\2\2\2\u0297\u0298\7@\2\2\u0298\u0299\7@\2" + - "\2\u0299\u029a\7?\2\2\u029a\u00bc\3\2\2\2\u029b\u029c\7,\2\2\u029c\u029d" + - "\7,\2\2\u029d\u029e\7?\2\2\u029e\u00be\3\2\2\2\u029f\u02a0\7\61\2\2\u02a0" + - "\u02a1\7\61\2\2\u02a1\u02a2\7?\2\2\u02a2\u00c0\3\2\2\2\u02a3\u02a7\5\u00f1" + - "y\2\u02a4\u02a7\5\u00f3z\2\u02a5\u02a7\5\u00f5{\2\u02a6\u02a3\3\2\2\2" + - "\u02a6\u02a4\3\2\2\2\u02a6\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9" + - "\ba\t\2\u02a9\u00c2\3\2\2\2\u02aa\u02ab\13\2\2\2\u02ab\u00c4\3\2\2\2\u02ac" + - "\u02b1\7)\2\2\u02ad\u02b0\5\u00cdg\2\u02ae\u02b0\n\t\2\2\u02af\u02ad\3" + - "\2\2\2\u02af\u02ae\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1\u02af\3\2\2\2\u02b1" + - "\u02b2\3\2\2\2\u02b2\u02b4\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b4\u02bf\7)" + - "\2\2\u02b5\u02ba\7$\2\2\u02b6\u02b9\5\u00cdg\2\u02b7\u02b9\n\n\2\2\u02b8" + - "\u02b6\3\2\2\2\u02b8\u02b7\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2" + - "\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bd" + - "\u02bf\7$\2\2\u02be\u02ac\3\2\2\2\u02be\u02b5\3\2\2\2\u02bf\u00c6\3\2" + - "\2\2\u02c0\u02c1\7)\2\2\u02c1\u02c2\7)\2\2\u02c2\u02c3\7)\2\2\u02c3\u02c7" + - "\3\2\2\2\u02c4\u02c6\5\u00c9e\2\u02c5\u02c4\3\2\2\2\u02c6\u02c9\3\2\2" + - "\2\u02c7\u02c8\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02c7" + - "\3\2\2\2\u02ca\u02cb\7)\2\2\u02cb\u02cc\7)\2\2\u02cc\u02db\7)\2\2\u02cd" + - "\u02ce\7$\2\2\u02ce\u02cf\7$\2\2\u02cf\u02d0\7$\2\2\u02d0\u02d4\3\2\2" + - "\2\u02d1\u02d3\5\u00c9e\2\u02d2\u02d1\3\2\2\2\u02d3\u02d6\3\2\2\2\u02d4" + - "\u02d5\3\2\2\2\u02d4\u02d2\3\2\2\2\u02d5\u02d7\3\2\2\2\u02d6\u02d4\3\2" + - "\2\2\u02d7\u02d8\7$\2\2\u02d8\u02d9\7$\2\2\u02d9\u02db\7$\2\2\u02da\u02c0" + - "\3\2\2\2\u02da\u02cd\3\2\2\2\u02db\u00c8\3\2\2\2\u02dc\u02df\5\u00cbf" + - "\2\u02dd\u02df\5\u00cdg\2\u02de\u02dc\3\2\2\2\u02de\u02dd\3\2\2\2\u02df" + - "\u00ca\3\2\2\2\u02e0\u02e1\n\13\2\2\u02e1\u00cc\3\2\2\2\u02e2\u02e3\7" + - "^\2\2\u02e3\u02e7\13\2\2\2\u02e4\u02e5\7^\2\2\u02e5\u02e7\5O(\2\u02e6" + - "\u02e2\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e7\u00ce\3\2\2\2\u02e8\u02e9\t\f" + - "\2\2\u02e9\u00d0\3\2\2\2\u02ea\u02eb\t\r\2\2\u02eb\u00d2\3\2\2\2\u02ec" + - "\u02ed\t\16\2\2\u02ed\u00d4\3\2\2\2\u02ee\u02ef\t\17\2\2\u02ef\u00d6\3" + - "\2\2\2\u02f0\u02f1\t\20\2\2\u02f1\u00d8\3\2\2\2\u02f2\u02f4\5\u00ddo\2" + - "\u02f3\u02f2\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02fa" + - "\5\u00dfp\2\u02f6\u02f7\5\u00ddo\2\u02f7\u02f8\7\60\2\2\u02f8\u02fa\3" + - "\2\2\2\u02f9\u02f3\3\2\2\2\u02f9\u02f6\3\2\2\2\u02fa\u00da\3\2\2\2\u02fb" + - "\u02fe\5\u00ddo\2\u02fc\u02fe\5\u00d9m\2\u02fd\u02fb\3\2\2\2\u02fd\u02fc" + - "\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0300\5\u00e1q\2\u0300\u00dc\3\2\2" + - "\2\u0301\u0303\5\u00d1i\2\u0302\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304" + - "\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u00de\3\2\2\2\u0306\u0308\7\60" + - "\2\2\u0307\u0309\5\u00d1i\2\u0308\u0307\3\2\2\2\u0309\u030a\3\2\2\2\u030a" + - "\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u00e0\3\2\2\2\u030c\u030e\t\21" + - "\2\2\u030d\u030f\t\22\2\2\u030e\u030d\3\2\2\2\u030e\u030f\3\2\2\2\u030f" + - "\u0311\3\2\2\2\u0310\u0312\5\u00d1i\2\u0311\u0310\3\2\2\2\u0312\u0313" + - "\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u00e2\3\2\2\2\u0315" + - "\u031a\7)\2\2\u0316\u0319\5\u00e9u\2\u0317\u0319\5\u00efx\2\u0318\u0316" + - "\3\2\2\2\u0318\u0317\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u0318\3\2\2\2\u031a" + - "\u031b\3\2\2\2\u031b\u031d\3\2\2\2\u031c\u031a\3\2\2\2\u031d\u0328\7)" + - "\2\2\u031e\u0323\7$\2\2\u031f\u0322\5\u00ebv\2\u0320\u0322\5\u00efx\2" + - "\u0321\u031f\3\2\2\2\u0321\u0320\3\2\2\2\u0322\u0325\3\2\2\2\u0323\u0321" + - "\3\2\2\2\u0323\u0324\3\2\2\2\u0324\u0326\3\2\2\2\u0325\u0323\3\2\2\2\u0326" + - "\u0328\7$\2\2\u0327\u0315\3\2\2\2\u0327\u031e\3\2\2\2\u0328\u00e4\3\2" + - "\2\2\u0329\u032a\7)\2\2\u032a\u032b\7)\2\2\u032b\u032c\7)\2\2\u032c\u0330" + - "\3\2\2\2\u032d\u032f\5\u00e7t\2\u032e\u032d\3\2\2\2\u032f\u0332\3\2\2" + - "\2\u0330\u0331\3\2\2\2\u0330\u032e\3\2\2\2\u0331\u0333\3\2\2\2\u0332\u0330" + - "\3\2\2\2\u0333\u0334\7)\2\2\u0334\u0335\7)\2\2\u0335\u0344\7)\2\2\u0336" + - "\u0337\7$\2\2\u0337\u0338\7$\2\2\u0338\u0339\7$\2\2\u0339\u033d\3\2\2" + - "\2\u033a\u033c\5\u00e7t\2\u033b\u033a\3\2\2\2\u033c\u033f\3\2\2\2\u033d" + - "\u033e\3\2\2\2\u033d\u033b\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u033d\3\2" + - "\2\2\u0340\u0341\7$\2\2\u0341\u0342\7$\2\2\u0342\u0344\7$\2\2\u0343\u0329" + - "\3\2\2\2\u0343\u0336\3\2\2\2\u0344\u00e6\3\2\2\2\u0345\u0348\5\u00edw" + - "\2\u0346\u0348\5\u00efx\2\u0347\u0345\3\2\2\2\u0347\u0346\3\2\2\2\u0348" + - "\u00e8\3\2\2\2\u0349\u034b\t\23\2\2\u034a\u0349\3\2\2\2\u034b\u00ea\3" + - "\2\2\2\u034c\u034e\t\24\2\2\u034d\u034c\3\2\2\2\u034e\u00ec\3\2\2\2\u034f" + - "\u0351\t\25\2\2\u0350\u034f\3\2\2\2\u0351\u00ee\3\2\2\2\u0352\u0353\7" + - "^\2\2\u0353\u0354\t\26\2\2\u0354\u00f0\3\2\2\2\u0355\u0357\t\27\2\2\u0356" + - "\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0356\3\2\2\2\u0358\u0359\3\2" + - "\2\2\u0359\u00f2\3\2\2\2\u035a\u035e\7%\2\2\u035b\u035d\n\30\2\2\u035c" + - "\u035b\3\2\2\2\u035d\u0360\3\2\2\2\u035e\u035c\3\2\2\2\u035e\u035f\3\2" + - "\2\2\u035f\u00f4\3\2\2\2\u0360\u035e\3\2\2\2\u0361\u0363\7^\2\2\u0362" + - "\u0364\5\u00f1y\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u036a" + - "\3\2\2\2\u0365\u0367\7\17\2\2\u0366\u0365\3\2\2\2\u0366\u0367\3\2\2\2" + - "\u0367\u0368\3\2\2\2\u0368\u036b\7\f\2\2\u0369\u036b\4\16\17\2\u036a\u0366" + - "\3\2\2\2\u036a\u0369\3\2\2\2\u036b\u00f6\3\2\2\2\u036c\u036e\t\31\2\2" + - "\u036d\u036c\3\2\2\2\u036e\u00f8\3\2\2\2\u036f\u0372\5\u00f7|\2\u0370" + - "\u0372\t\32\2\2\u0371\u036f\3\2\2\2\u0371\u0370\3\2\2\2\u0372\u00fa\3" + - "\2\2\2<\2\u00fd\u0102\u0108\u01cb\u01cf\u01d2\u01d4\u01dc\u01e4\u01e8" + - "\u01ef\u01f3\u01f9\u01ff\u0201\u0208\u020f\u0216\u021a\u021e\u02a6\u02af" + - "\u02b1\u02b8\u02ba\u02be\u02c7\u02d4\u02da\u02de\u02e6\u02f3\u02f9\u02fd" + - "\u0304\u030a\u030e\u0313\u0318\u031a\u0321\u0323\u0327\u0330\u033d\u0343" + - "\u0347\u034a\u034d\u0350\u0358\u035e\u0363\u0366\u036a\u036d\u0371\n\3" + - "(\2\3\65\3\3\66\4\3<\5\3=\6\3I\7\3J\b\b\2\2"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.tokens b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.tokens deleted file mode 100644 index 2ed45ea..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Lexer.tokens +++ /dev/null @@ -1,179 +0,0 @@ -STRING=1 -NUMBER=2 -INTEGER=3 -DEF=4 -RETURN=5 -RAISE=6 -FROM=7 -IMPORT=8 -AS=9 -GLOBAL=10 -NONLOCAL=11 -ASSERT=12 -IF=13 -ELIF=14 -ELSE=15 -WHILE=16 -FOR=17 -IN=18 -TRY=19 -FINALLY=20 -WITH=21 -EXCEPT=22 -LAMBDA=23 -OR=24 -AND=25 -NOT=26 -IS=27 -NONE=28 -TRUE=29 -FALSE=30 -CLASS=31 -YIELD=32 -DEL=33 -PASS=34 -CONTINUE=35 -BREAK=36 -ASYNC=37 -AWAIT=38 -NEWLINE=39 -NAME=40 -STRING_LITERAL=41 -BYTES_LITERAL=42 -DECIMAL_INTEGER=43 -OCT_INTEGER=44 -HEX_INTEGER=45 -BIN_INTEGER=46 -FLOAT_NUMBER=47 -IMAG_NUMBER=48 -DOT=49 -ELLIPSIS=50 -STAR=51 -OPEN_PAREN=52 -CLOSE_PAREN=53 -COMMA=54 -COLON=55 -SEMI_COLON=56 -POWER=57 -ASSIGN=58 -OPEN_BRACK=59 -CLOSE_BRACK=60 -OR_OP=61 -XOR=62 -AND_OP=63 -LEFT_SHIFT=64 -RIGHT_SHIFT=65 -ADD=66 -MINUS=67 -DIV=68 -MOD=69 -IDIV=70 -NOT_OP=71 -OPEN_BRACE=72 -CLOSE_BRACE=73 -LESS_THAN=74 -GREATER_THAN=75 -EQUALS=76 -GT_EQ=77 -LT_EQ=78 -NOT_EQ_1=79 -NOT_EQ_2=80 -AT=81 -ARROW=82 -ADD_ASSIGN=83 -SUB_ASSIGN=84 -MULT_ASSIGN=85 -AT_ASSIGN=86 -DIV_ASSIGN=87 -MOD_ASSIGN=88 -AND_ASSIGN=89 -OR_ASSIGN=90 -XOR_ASSIGN=91 -LEFT_SHIFT_ASSIGN=92 -RIGHT_SHIFT_ASSIGN=93 -POWER_ASSIGN=94 -IDIV_ASSIGN=95 -SKIP_=96 -UNKNOWN_CHAR=97 -'def'=4 -'return'=5 -'raise'=6 -'from'=7 -'import'=8 -'as'=9 -'global'=10 -'nonlocal'=11 -'assert'=12 -'if'=13 -'elif'=14 -'else'=15 -'while'=16 -'for'=17 -'in'=18 -'try'=19 -'finally'=20 -'with'=21 -'except'=22 -'lambda'=23 -'or'=24 -'and'=25 -'not'=26 -'is'=27 -'None'=28 -'True'=29 -'False'=30 -'class'=31 -'yield'=32 -'del'=33 -'pass'=34 -'continue'=35 -'break'=36 -'async'=37 -'await'=38 -'.'=49 -'...'=50 -'*'=51 -'('=52 -')'=53 -','=54 -':'=55 -';'=56 -'**'=57 -'='=58 -'['=59 -']'=60 -'|'=61 -'^'=62 -'&'=63 -'<<'=64 -'>>'=65 -'+'=66 -'-'=67 -'/'=68 -'%'=69 -'//'=70 -'~'=71 -'{'=72 -'}'=73 -'<'=74 -'>'=75 -'=='=76 -'>='=77 -'<='=78 -'<>'=79 -'!='=80 -'@'=81 -'->'=82 -'+='=83 -'-='=84 -'*='=85 -'@='=86 -'/='=87 -'%='=88 -'&='=89 -'|='=90 -'^='=91 -'<<='=92 -'>>='=93 -'**='=94 -'//='=95 diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Listener.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Listener.java deleted file mode 100644 index b27128d..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Listener.java +++ /dev/null @@ -1,1213 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.python;// Generated from Python3.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.tree.ParseTreeListener; - -/** - * This interface defines a complete listener for a parse tree produced by - * {@link Python3Parser}. - */ -public interface Python3Listener extends ParseTreeListener { - /** - * Enter a parse tree produced by {@link Python3Parser#single_input}. - * - * @param ctx the parse tree - */ - void enterSingle_input(Python3Parser.Single_inputContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#single_input}. - * - * @param ctx the parse tree - */ - void exitSingle_input(Python3Parser.Single_inputContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#file_input}. - * - * @param ctx the parse tree - */ - void enterFile_input(Python3Parser.File_inputContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#file_input}. - * - * @param ctx the parse tree - */ - void exitFile_input(Python3Parser.File_inputContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#eval_input}. - * - * @param ctx the parse tree - */ - void enterEval_input(Python3Parser.Eval_inputContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#eval_input}. - * - * @param ctx the parse tree - */ - void exitEval_input(Python3Parser.Eval_inputContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#decorator}. - * - * @param ctx the parse tree - */ - void enterDecorator(Python3Parser.DecoratorContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#decorator}. - * - * @param ctx the parse tree - */ - void exitDecorator(Python3Parser.DecoratorContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#decorators}. - * - * @param ctx the parse tree - */ - void enterDecorators(Python3Parser.DecoratorsContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#decorators}. - * - * @param ctx the parse tree - */ - void exitDecorators(Python3Parser.DecoratorsContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#decorated}. - * - * @param ctx the parse tree - */ - void enterDecorated(Python3Parser.DecoratedContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#decorated}. - * - * @param ctx the parse tree - */ - void exitDecorated(Python3Parser.DecoratedContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#async_funcdef}. - * - * @param ctx the parse tree - */ - void enterAsync_funcdef(Python3Parser.Async_funcdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#async_funcdef}. - * - * @param ctx the parse tree - */ - void exitAsync_funcdef(Python3Parser.Async_funcdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#funcdef}. - * - * @param ctx the parse tree - */ - void enterFuncdef(Python3Parser.FuncdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#funcdef}. - * - * @param ctx the parse tree - */ - void exitFuncdef(Python3Parser.FuncdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#parameters}. - * - * @param ctx the parse tree - */ - void enterParameters(Python3Parser.ParametersContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#parameters}. - * - * @param ctx the parse tree - */ - void exitParameters(Python3Parser.ParametersContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#typedargslist}. - * - * @param ctx the parse tree - */ - void enterTypedargslist(Python3Parser.TypedargslistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#typedargslist}. - * - * @param ctx the parse tree - */ - void exitTypedargslist(Python3Parser.TypedargslistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#tfpdef}. - * - * @param ctx the parse tree - */ - void enterTfpdef(Python3Parser.TfpdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#tfpdef}. - * - * @param ctx the parse tree - */ - void exitTfpdef(Python3Parser.TfpdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#varargslist}. - * - * @param ctx the parse tree - */ - void enterVarargslist(Python3Parser.VarargslistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#varargslist}. - * - * @param ctx the parse tree - */ - void exitVarargslist(Python3Parser.VarargslistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#vfpdef}. - * - * @param ctx the parse tree - */ - void enterVfpdef(Python3Parser.VfpdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#vfpdef}. - * - * @param ctx the parse tree - */ - void exitVfpdef(Python3Parser.VfpdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#stmt}. - * - * @param ctx the parse tree - */ - void enterStmt(Python3Parser.StmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#stmt}. - * - * @param ctx the parse tree - */ - void exitStmt(Python3Parser.StmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#simple_stmt}. - * - * @param ctx the parse tree - */ - void enterSimple_stmt(Python3Parser.Simple_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#simple_stmt}. - * - * @param ctx the parse tree - */ - void exitSimple_stmt(Python3Parser.Simple_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#small_stmt}. - * - * @param ctx the parse tree - */ - void enterSmall_stmt(Python3Parser.Small_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#small_stmt}. - * - * @param ctx the parse tree - */ - void exitSmall_stmt(Python3Parser.Small_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#expr_stmt}. - * - * @param ctx the parse tree - */ - void enterExpr_stmt(Python3Parser.Expr_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#expr_stmt}. - * - * @param ctx the parse tree - */ - void exitExpr_stmt(Python3Parser.Expr_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#annassign}. - * - * @param ctx the parse tree - */ - void enterAnnassign(Python3Parser.AnnassignContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#annassign}. - * - * @param ctx the parse tree - */ - void exitAnnassign(Python3Parser.AnnassignContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#testlist_star_expr}. - * - * @param ctx the parse tree - */ - void enterTestlist_star_expr(Python3Parser.Testlist_star_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#testlist_star_expr}. - * - * @param ctx the parse tree - */ - void exitTestlist_star_expr(Python3Parser.Testlist_star_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#augassign}. - * - * @param ctx the parse tree - */ - void enterAugassign(Python3Parser.AugassignContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#augassign}. - * - * @param ctx the parse tree - */ - void exitAugassign(Python3Parser.AugassignContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#del_stmt}. - * - * @param ctx the parse tree - */ - void enterDel_stmt(Python3Parser.Del_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#del_stmt}. - * - * @param ctx the parse tree - */ - void exitDel_stmt(Python3Parser.Del_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#pass_stmt}. - * - * @param ctx the parse tree - */ - void enterPass_stmt(Python3Parser.Pass_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#pass_stmt}. - * - * @param ctx the parse tree - */ - void exitPass_stmt(Python3Parser.Pass_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#flow_stmt}. - * - * @param ctx the parse tree - */ - void enterFlow_stmt(Python3Parser.Flow_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#flow_stmt}. - * - * @param ctx the parse tree - */ - void exitFlow_stmt(Python3Parser.Flow_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#break_stmt}. - * - * @param ctx the parse tree - */ - void enterBreak_stmt(Python3Parser.Break_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#break_stmt}. - * - * @param ctx the parse tree - */ - void exitBreak_stmt(Python3Parser.Break_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#continue_stmt}. - * - * @param ctx the parse tree - */ - void enterContinue_stmt(Python3Parser.Continue_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#continue_stmt}. - * - * @param ctx the parse tree - */ - void exitContinue_stmt(Python3Parser.Continue_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#return_stmt}. - * - * @param ctx the parse tree - */ - void enterReturn_stmt(Python3Parser.Return_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#return_stmt}. - * - * @param ctx the parse tree - */ - void exitReturn_stmt(Python3Parser.Return_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#yield_stmt}. - * - * @param ctx the parse tree - */ - void enterYield_stmt(Python3Parser.Yield_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#yield_stmt}. - * - * @param ctx the parse tree - */ - void exitYield_stmt(Python3Parser.Yield_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#raise_stmt}. - * - * @param ctx the parse tree - */ - void enterRaise_stmt(Python3Parser.Raise_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#raise_stmt}. - * - * @param ctx the parse tree - */ - void exitRaise_stmt(Python3Parser.Raise_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#import_stmt}. - * - * @param ctx the parse tree - */ - void enterImport_stmt(Python3Parser.Import_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#import_stmt}. - * - * @param ctx the parse tree - */ - void exitImport_stmt(Python3Parser.Import_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#import_name}. - * - * @param ctx the parse tree - */ - void enterImport_name(Python3Parser.Import_nameContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#import_name}. - * - * @param ctx the parse tree - */ - void exitImport_name(Python3Parser.Import_nameContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#import_from}. - * - * @param ctx the parse tree - */ - void enterImport_from(Python3Parser.Import_fromContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#import_from}. - * - * @param ctx the parse tree - */ - void exitImport_from(Python3Parser.Import_fromContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#import_as_name}. - * - * @param ctx the parse tree - */ - void enterImport_as_name(Python3Parser.Import_as_nameContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#import_as_name}. - * - * @param ctx the parse tree - */ - void exitImport_as_name(Python3Parser.Import_as_nameContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#dotted_as_name}. - * - * @param ctx the parse tree - */ - void enterDotted_as_name(Python3Parser.Dotted_as_nameContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#dotted_as_name}. - * - * @param ctx the parse tree - */ - void exitDotted_as_name(Python3Parser.Dotted_as_nameContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#import_as_names}. - * - * @param ctx the parse tree - */ - void enterImport_as_names(Python3Parser.Import_as_namesContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#import_as_names}. - * - * @param ctx the parse tree - */ - void exitImport_as_names(Python3Parser.Import_as_namesContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#dotted_as_names}. - * - * @param ctx the parse tree - */ - void enterDotted_as_names(Python3Parser.Dotted_as_namesContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#dotted_as_names}. - * - * @param ctx the parse tree - */ - void exitDotted_as_names(Python3Parser.Dotted_as_namesContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#dotted_name}. - * - * @param ctx the parse tree - */ - void enterDotted_name(Python3Parser.Dotted_nameContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#dotted_name}. - * - * @param ctx the parse tree - */ - void exitDotted_name(Python3Parser.Dotted_nameContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#global_stmt}. - * - * @param ctx the parse tree - */ - void enterGlobal_stmt(Python3Parser.Global_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#global_stmt}. - * - * @param ctx the parse tree - */ - void exitGlobal_stmt(Python3Parser.Global_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#nonlocal_stmt}. - * - * @param ctx the parse tree - */ - void enterNonlocal_stmt(Python3Parser.Nonlocal_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#nonlocal_stmt}. - * - * @param ctx the parse tree - */ - void exitNonlocal_stmt(Python3Parser.Nonlocal_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#assert_stmt}. - * - * @param ctx the parse tree - */ - void enterAssert_stmt(Python3Parser.Assert_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#assert_stmt}. - * - * @param ctx the parse tree - */ - void exitAssert_stmt(Python3Parser.Assert_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#compound_stmt}. - * - * @param ctx the parse tree - */ - void enterCompound_stmt(Python3Parser.Compound_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#compound_stmt}. - * - * @param ctx the parse tree - */ - void exitCompound_stmt(Python3Parser.Compound_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#async_stmt}. - * - * @param ctx the parse tree - */ - void enterAsync_stmt(Python3Parser.Async_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#async_stmt}. - * - * @param ctx the parse tree - */ - void exitAsync_stmt(Python3Parser.Async_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#if_stmt}. - * - * @param ctx the parse tree - */ - void enterIf_stmt(Python3Parser.If_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#if_stmt}. - * - * @param ctx the parse tree - */ - void exitIf_stmt(Python3Parser.If_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#while_stmt}. - * - * @param ctx the parse tree - */ - void enterWhile_stmt(Python3Parser.While_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#while_stmt}. - * - * @param ctx the parse tree - */ - void exitWhile_stmt(Python3Parser.While_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#for_stmt}. - * - * @param ctx the parse tree - */ - void enterFor_stmt(Python3Parser.For_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#for_stmt}. - * - * @param ctx the parse tree - */ - void exitFor_stmt(Python3Parser.For_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#try_stmt}. - * - * @param ctx the parse tree - */ - void enterTry_stmt(Python3Parser.Try_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#try_stmt}. - * - * @param ctx the parse tree - */ - void exitTry_stmt(Python3Parser.Try_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#with_stmt}. - * - * @param ctx the parse tree - */ - void enterWith_stmt(Python3Parser.With_stmtContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#with_stmt}. - * - * @param ctx the parse tree - */ - void exitWith_stmt(Python3Parser.With_stmtContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#with_item}. - * - * @param ctx the parse tree - */ - void enterWith_item(Python3Parser.With_itemContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#with_item}. - * - * @param ctx the parse tree - */ - void exitWith_item(Python3Parser.With_itemContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#except_clause}. - * - * @param ctx the parse tree - */ - void enterExcept_clause(Python3Parser.Except_clauseContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#except_clause}. - * - * @param ctx the parse tree - */ - void exitExcept_clause(Python3Parser.Except_clauseContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#suite}. - * - * @param ctx the parse tree - */ - void enterSuite(Python3Parser.SuiteContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#suite}. - * - * @param ctx the parse tree - */ - void exitSuite(Python3Parser.SuiteContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#test}. - * - * @param ctx the parse tree - */ - void enterTest(Python3Parser.TestContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#test}. - * - * @param ctx the parse tree - */ - void exitTest(Python3Parser.TestContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#test_nocond}. - * - * @param ctx the parse tree - */ - void enterTest_nocond(Python3Parser.Test_nocondContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#test_nocond}. - * - * @param ctx the parse tree - */ - void exitTest_nocond(Python3Parser.Test_nocondContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#lambdef}. - * - * @param ctx the parse tree - */ - void enterLambdef(Python3Parser.LambdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#lambdef}. - * - * @param ctx the parse tree - */ - void exitLambdef(Python3Parser.LambdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#lambdef_nocond}. - * - * @param ctx the parse tree - */ - void enterLambdef_nocond(Python3Parser.Lambdef_nocondContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#lambdef_nocond}. - * - * @param ctx the parse tree - */ - void exitLambdef_nocond(Python3Parser.Lambdef_nocondContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#or_test}. - * - * @param ctx the parse tree - */ - void enterOr_test(Python3Parser.Or_testContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#or_test}. - * - * @param ctx the parse tree - */ - void exitOr_test(Python3Parser.Or_testContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#and_test}. - * - * @param ctx the parse tree - */ - void enterAnd_test(Python3Parser.And_testContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#and_test}. - * - * @param ctx the parse tree - */ - void exitAnd_test(Python3Parser.And_testContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#not_test}. - * - * @param ctx the parse tree - */ - void enterNot_test(Python3Parser.Not_testContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#not_test}. - * - * @param ctx the parse tree - */ - void exitNot_test(Python3Parser.Not_testContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#comparison}. - * - * @param ctx the parse tree - */ - void enterComparison(Python3Parser.ComparisonContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#comparison}. - * - * @param ctx the parse tree - */ - void exitComparison(Python3Parser.ComparisonContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#comp_op}. - * - * @param ctx the parse tree - */ - void enterComp_op(Python3Parser.Comp_opContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#comp_op}. - * - * @param ctx the parse tree - */ - void exitComp_op(Python3Parser.Comp_opContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#star_expr}. - * - * @param ctx the parse tree - */ - void enterStar_expr(Python3Parser.Star_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#star_expr}. - * - * @param ctx the parse tree - */ - void exitStar_expr(Python3Parser.Star_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#expr}. - * - * @param ctx the parse tree - */ - void enterExpr(Python3Parser.ExprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#expr}. - * - * @param ctx the parse tree - */ - void exitExpr(Python3Parser.ExprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#xor_expr}. - * - * @param ctx the parse tree - */ - void enterXor_expr(Python3Parser.Xor_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#xor_expr}. - * - * @param ctx the parse tree - */ - void exitXor_expr(Python3Parser.Xor_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#and_expr}. - * - * @param ctx the parse tree - */ - void enterAnd_expr(Python3Parser.And_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#and_expr}. - * - * @param ctx the parse tree - */ - void exitAnd_expr(Python3Parser.And_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#shift_expr}. - * - * @param ctx the parse tree - */ - void enterShift_expr(Python3Parser.Shift_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#shift_expr}. - * - * @param ctx the parse tree - */ - void exitShift_expr(Python3Parser.Shift_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#arith_expr}. - * - * @param ctx the parse tree - */ - void enterArith_expr(Python3Parser.Arith_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#arith_expr}. - * - * @param ctx the parse tree - */ - void exitArith_expr(Python3Parser.Arith_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#term}. - * - * @param ctx the parse tree - */ - void enterTerm(Python3Parser.TermContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#term}. - * - * @param ctx the parse tree - */ - void exitTerm(Python3Parser.TermContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#factor}. - * - * @param ctx the parse tree - */ - void enterFactor(Python3Parser.FactorContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#factor}. - * - * @param ctx the parse tree - */ - void exitFactor(Python3Parser.FactorContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#power}. - * - * @param ctx the parse tree - */ - void enterPower(Python3Parser.PowerContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#power}. - * - * @param ctx the parse tree - */ - void exitPower(Python3Parser.PowerContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#atom_expr}. - * - * @param ctx the parse tree - */ - void enterAtom_expr(Python3Parser.Atom_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#atom_expr}. - * - * @param ctx the parse tree - */ - void exitAtom_expr(Python3Parser.Atom_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#atom}. - * - * @param ctx the parse tree - */ - void enterAtom(Python3Parser.AtomContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#atom}. - * - * @param ctx the parse tree - */ - void exitAtom(Python3Parser.AtomContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#testlist_comp}. - * - * @param ctx the parse tree - */ - void enterTestlist_comp(Python3Parser.Testlist_compContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#testlist_comp}. - * - * @param ctx the parse tree - */ - void exitTestlist_comp(Python3Parser.Testlist_compContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#trailer}. - * - * @param ctx the parse tree - */ - void enterTrailer(Python3Parser.TrailerContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#trailer}. - * - * @param ctx the parse tree - */ - void exitTrailer(Python3Parser.TrailerContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#subscriptlist}. - * - * @param ctx the parse tree - */ - void enterSubscriptlist(Python3Parser.SubscriptlistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#subscriptlist}. - * - * @param ctx the parse tree - */ - void exitSubscriptlist(Python3Parser.SubscriptlistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#subscript}. - * - * @param ctx the parse tree - */ - void enterSubscript(Python3Parser.SubscriptContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#subscript}. - * - * @param ctx the parse tree - */ - void exitSubscript(Python3Parser.SubscriptContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#sliceop}. - * - * @param ctx the parse tree - */ - void enterSliceop(Python3Parser.SliceopContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#sliceop}. - * - * @param ctx the parse tree - */ - void exitSliceop(Python3Parser.SliceopContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#exprlist}. - * - * @param ctx the parse tree - */ - void enterExprlist(Python3Parser.ExprlistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#exprlist}. - * - * @param ctx the parse tree - */ - void exitExprlist(Python3Parser.ExprlistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#testlist}. - * - * @param ctx the parse tree - */ - void enterTestlist(Python3Parser.TestlistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#testlist}. - * - * @param ctx the parse tree - */ - void exitTestlist(Python3Parser.TestlistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#dictorsetmaker}. - * - * @param ctx the parse tree - */ - void enterDictorsetmaker(Python3Parser.DictorsetmakerContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#dictorsetmaker}. - * - * @param ctx the parse tree - */ - void exitDictorsetmaker(Python3Parser.DictorsetmakerContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#classdef}. - * - * @param ctx the parse tree - */ - void enterClassdef(Python3Parser.ClassdefContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#classdef}. - * - * @param ctx the parse tree - */ - void exitClassdef(Python3Parser.ClassdefContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#arglist}. - * - * @param ctx the parse tree - */ - void enterArglist(Python3Parser.ArglistContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#arglist}. - * - * @param ctx the parse tree - */ - void exitArglist(Python3Parser.ArglistContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#argument}. - * - * @param ctx the parse tree - */ - void enterArgument(Python3Parser.ArgumentContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#argument}. - * - * @param ctx the parse tree - */ - void exitArgument(Python3Parser.ArgumentContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#comp_iter}. - * - * @param ctx the parse tree - */ - void enterComp_iter(Python3Parser.Comp_iterContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#comp_iter}. - * - * @param ctx the parse tree - */ - void exitComp_iter(Python3Parser.Comp_iterContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#comp_for}. - * - * @param ctx the parse tree - */ - void enterComp_for(Python3Parser.Comp_forContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#comp_for}. - * - * @param ctx the parse tree - */ - void exitComp_for(Python3Parser.Comp_forContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#comp_if}. - * - * @param ctx the parse tree - */ - void enterComp_if(Python3Parser.Comp_ifContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#comp_if}. - * - * @param ctx the parse tree - */ - void exitComp_if(Python3Parser.Comp_ifContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#encoding_decl}. - * - * @param ctx the parse tree - */ - void enterEncoding_decl(Python3Parser.Encoding_declContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#encoding_decl}. - * - * @param ctx the parse tree - */ - void exitEncoding_decl(Python3Parser.Encoding_declContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#yield_expr}. - * - * @param ctx the parse tree - */ - void enterYield_expr(Python3Parser.Yield_exprContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#yield_expr}. - * - * @param ctx the parse tree - */ - void exitYield_expr(Python3Parser.Yield_exprContext ctx); - - /** - * Enter a parse tree produced by {@link Python3Parser#yield_arg}. - * - * @param ctx the parse tree - */ - void enterYield_arg(Python3Parser.Yield_argContext ctx); - - /** - * Exit a parse tree produced by {@link Python3Parser#yield_arg}. - * - * @param ctx the parse tree - */ - void exitYield_arg(Python3Parser.Yield_argContext ctx); -} \ No newline at end of file diff --git a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Parser.java b/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Parser.java deleted file mode 100644 index 1b3986e..0000000 --- a/src/main/java/jp/ac/osaka_u/sdl/nil/parser/python/Python3Parser.java +++ /dev/null @@ -1,8987 +0,0 @@ -package jp.ac.osaka_u.sdl.nil.parser.python;// Generated from Python3.g4 by ANTLR 4.9 - -import org.antlr.v4.runtime.NoViableAltException; -import org.antlr.v4.runtime.Parser; -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.RecognitionException; -import org.antlr.v4.runtime.RuntimeMetaData; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.Vocabulary; -import org.antlr.v4.runtime.VocabularyImpl; -import org.antlr.v4.runtime.atn.ATN; -import org.antlr.v4.runtime.atn.ATNDeserializer; -import org.antlr.v4.runtime.atn.ParserATNSimulator; -import org.antlr.v4.runtime.atn.PredictionContextCache; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.tree.ParseTreeListener; -import org.antlr.v4.runtime.tree.TerminalNode; - -import java.util.List; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class Python3Parser extends Parser { - static { - RuntimeMetaData.checkVersion("4.9", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - STRING = 1, NUMBER = 2, INTEGER = 3, DEF = 4, RETURN = 5, RAISE = 6, FROM = 7, IMPORT = 8, - AS = 9, GLOBAL = 10, NONLOCAL = 11, ASSERT = 12, IF = 13, ELIF = 14, ELSE = 15, WHILE = 16, - FOR = 17, IN = 18, TRY = 19, FINALLY = 20, WITH = 21, EXCEPT = 22, LAMBDA = 23, OR = 24, - AND = 25, NOT = 26, IS = 27, NONE = 28, TRUE = 29, FALSE = 30, CLASS = 31, YIELD = 32, - DEL = 33, PASS = 34, CONTINUE = 35, BREAK = 36, ASYNC = 37, AWAIT = 38, NEWLINE = 39, - NAME = 40, STRING_LITERAL = 41, BYTES_LITERAL = 42, DECIMAL_INTEGER = 43, OCT_INTEGER = 44, - HEX_INTEGER = 45, BIN_INTEGER = 46, FLOAT_NUMBER = 47, IMAG_NUMBER = 48, DOT = 49, - ELLIPSIS = 50, STAR = 51, OPEN_PAREN = 52, CLOSE_PAREN = 53, COMMA = 54, COLON = 55, - SEMI_COLON = 56, POWER = 57, ASSIGN = 58, OPEN_BRACK = 59, CLOSE_BRACK = 60, OR_OP = 61, - XOR = 62, AND_OP = 63, LEFT_SHIFT = 64, RIGHT_SHIFT = 65, ADD = 66, MINUS = 67, DIV = 68, - MOD = 69, IDIV = 70, NOT_OP = 71, OPEN_BRACE = 72, CLOSE_BRACE = 73, LESS_THAN = 74, - GREATER_THAN = 75, EQUALS = 76, GT_EQ = 77, LT_EQ = 78, NOT_EQ_1 = 79, NOT_EQ_2 = 80, - AT = 81, ARROW = 82, ADD_ASSIGN = 83, SUB_ASSIGN = 84, MULT_ASSIGN = 85, AT_ASSIGN = 86, - DIV_ASSIGN = 87, MOD_ASSIGN = 88, AND_ASSIGN = 89, OR_ASSIGN = 90, XOR_ASSIGN = 91, - LEFT_SHIFT_ASSIGN = 92, RIGHT_SHIFT_ASSIGN = 93, POWER_ASSIGN = 94, IDIV_ASSIGN = 95, - SKIP_ = 96, UNKNOWN_CHAR = 97, INDENT = 98, DEDENT = 99; - public static final int - RULE_single_input = 0, RULE_file_input = 1, RULE_eval_input = 2, RULE_decorator = 3, - RULE_decorators = 4, RULE_decorated = 5, RULE_async_funcdef = 6, RULE_funcdef = 7, - RULE_parameters = 8, RULE_typedargslist = 9, RULE_tfpdef = 10, RULE_varargslist = 11, - RULE_vfpdef = 12, RULE_stmt = 13, RULE_simple_stmt = 14, RULE_small_stmt = 15, - RULE_expr_stmt = 16, RULE_annassign = 17, RULE_testlist_star_expr = 18, - RULE_augassign = 19, RULE_del_stmt = 20, RULE_pass_stmt = 21, RULE_flow_stmt = 22, - RULE_break_stmt = 23, RULE_continue_stmt = 24, RULE_return_stmt = 25, - RULE_yield_stmt = 26, RULE_raise_stmt = 27, RULE_import_stmt = 28, RULE_import_name = 29, - RULE_import_from = 30, RULE_import_as_name = 31, RULE_dotted_as_name = 32, - RULE_import_as_names = 33, RULE_dotted_as_names = 34, RULE_dotted_name = 35, - RULE_global_stmt = 36, RULE_nonlocal_stmt = 37, RULE_assert_stmt = 38, - RULE_compound_stmt = 39, RULE_async_stmt = 40, RULE_if_stmt = 41, RULE_while_stmt = 42, - RULE_for_stmt = 43, RULE_try_stmt = 44, RULE_with_stmt = 45, RULE_with_item = 46, - RULE_except_clause = 47, RULE_suite = 48, RULE_test = 49, RULE_test_nocond = 50, - RULE_lambdef = 51, RULE_lambdef_nocond = 52, RULE_or_test = 53, RULE_and_test = 54, - RULE_not_test = 55, RULE_comparison = 56, RULE_comp_op = 57, RULE_star_expr = 58, - RULE_expr = 59, RULE_xor_expr = 60, RULE_and_expr = 61, RULE_shift_expr = 62, - RULE_arith_expr = 63, RULE_term = 64, RULE_factor = 65, RULE_power = 66, - RULE_atom_expr = 67, RULE_atom = 68, RULE_testlist_comp = 69, RULE_trailer = 70, - RULE_subscriptlist = 71, RULE_subscript = 72, RULE_sliceop = 73, RULE_exprlist = 74, - RULE_testlist = 75, RULE_dictorsetmaker = 76, RULE_classdef = 77, RULE_arglist = 78, - RULE_argument = 79, RULE_comp_iter = 80, RULE_comp_for = 81, RULE_comp_if = 82, - RULE_encoding_decl = 83, RULE_yield_expr = 84, RULE_yield_arg = 85; - - private static String[] makeRuleNames() { - return new String[]{ - "single_input", "file_input", "eval_input", "decorator", "decorators", - "decorated", "async_funcdef", "funcdef", "parameters", "typedargslist", - "tfpdef", "varargslist", "vfpdef", "stmt", "simple_stmt", "small_stmt", - "expr_stmt", "annassign", "testlist_star_expr", "augassign", "del_stmt", - "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt", "return_stmt", - "yield_stmt", "raise_stmt", "import_stmt", "import_name", "import_from", - "import_as_name", "dotted_as_name", "import_as_names", "dotted_as_names", - "dotted_name", "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt", - "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt", "with_stmt", - "with_item", "except_clause", "suite", "test", "test_nocond", "lambdef", - "lambdef_nocond", "or_test", "and_test", "not_test", "comparison", "comp_op", - "star_expr", "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr", - "term", "factor", "power", "atom_expr", "atom", "testlist_comp", "trailer", - "subscriptlist", "subscript", "sliceop", "exprlist", "testlist", "dictorsetmaker", - "classdef", "arglist", "argument", "comp_iter", "comp_for", "comp_if", - "encoding_decl", "yield_expr", "yield_arg" - }; - } - - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[]{ - null, null, null, null, "'def'", "'return'", "'raise'", "'from'", "'import'", - "'as'", "'global'", "'nonlocal'", "'assert'", "'if'", "'elif'", "'else'", - "'while'", "'for'", "'in'", "'try'", "'finally'", "'with'", "'except'", - "'lambda'", "'or'", "'and'", "'not'", "'is'", "'None'", "'True'", "'False'", - "'class'", "'yield'", "'del'", "'pass'", "'continue'", "'break'", "'async'", - "'await'", null, null, null, null, null, null, null, null, null, null, - "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='", - "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'", - "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", "'<='", - "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", "'/='", - "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[]{ - null, "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", - "IMPORT", "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", - "WHILE", "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", - "AND", "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", - "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", - "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", - "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", - "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", - "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", - "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", - "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", - "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", - "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", - "SKIP_", "UNKNOWN_CHAR", "INDENT", "DEDENT" - }; - } - - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); - - /** - * @deprecated Use {@link #VOCABULARY} instead. - */ - @Deprecated - public static final String[] tokenNames; - - static { - tokenNames = new String[_SYMBOLIC_NAMES.length]; - for (int i = 0; i < tokenNames.length; i++) { - tokenNames[i] = VOCABULARY.getLiteralName(i); - if (tokenNames[i] == null) { - tokenNames[i] = VOCABULARY.getSymbolicName(i); - } - - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } - - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } - - @Override - - public Vocabulary getVocabulary() { - return VOCABULARY; - } - - @Override - public String getGrammarFileName() { - return "Python3.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public ATN getATN() { - return _ATN; - } - - public Python3Parser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - public static class Single_inputContext extends ParserRuleContext { - public TerminalNode NEWLINE() { - return getToken(Python3Parser.NEWLINE, 0); - } - - public Simple_stmtContext simple_stmt() { - return getRuleContext(Simple_stmtContext.class, 0); - } - - public Compound_stmtContext compound_stmt() { - return getRuleContext(Compound_stmtContext.class, 0); - } - - public Single_inputContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_single_input; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSingle_input(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSingle_input(this); - } - } - - public final Single_inputContext single_input() throws RecognitionException { - Single_inputContext _localctx = new Single_inputContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_single_input); - try { - setState(177); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NEWLINE: - enterOuterAlt(_localctx, 1); - { - setState(172); - match(NEWLINE); - } - break; - case STRING: - case NUMBER: - case RETURN: - case RAISE: - case FROM: - case IMPORT: - case GLOBAL: - case NONLOCAL: - case ASSERT: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case YIELD: - case DEL: - case PASS: - case CONTINUE: - case BREAK: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(173); - simple_stmt(); - } - break; - case DEF: - case IF: - case WHILE: - case FOR: - case TRY: - case WITH: - case CLASS: - case ASYNC: - case AT: - enterOuterAlt(_localctx, 3); - { - setState(174); - compound_stmt(); - setState(175); - match(NEWLINE); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class File_inputContext extends ParserRuleContext { - public TerminalNode EOF() { - return getToken(Python3Parser.EOF, 0); - } - - public List NEWLINE() { - return getTokens(Python3Parser.NEWLINE); - } - - public TerminalNode NEWLINE(int i) { - return getToken(Python3Parser.NEWLINE, i); - } - - public List stmt() { - return getRuleContexts(StmtContext.class); - } - - public StmtContext stmt(int i) { - return getRuleContext(StmtContext.class, i); - } - - public File_inputContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_file_input; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterFile_input(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitFile_input(this); - } - } - - public final File_inputContext file_input() throws RecognitionException { - File_inputContext _localctx = new File_inputContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_file_input); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(183); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NEWLINE) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0)) { - { - setState(181); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NEWLINE: { - setState(179); - match(NEWLINE); - } - break; - case STRING: - case NUMBER: - case DEF: - case RETURN: - case RAISE: - case FROM: - case IMPORT: - case GLOBAL: - case NONLOCAL: - case ASSERT: - case IF: - case WHILE: - case FOR: - case TRY: - case WITH: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case CLASS: - case YIELD: - case DEL: - case PASS: - case CONTINUE: - case BREAK: - case ASYNC: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - case AT: { - setState(180); - stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(185); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(186); - match(EOF); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Eval_inputContext extends ParserRuleContext { - public TestlistContext testlist() { - return getRuleContext(TestlistContext.class, 0); - } - - public TerminalNode EOF() { - return getToken(Python3Parser.EOF, 0); - } - - public List NEWLINE() { - return getTokens(Python3Parser.NEWLINE); - } - - public TerminalNode NEWLINE(int i) { - return getToken(Python3Parser.NEWLINE, i); - } - - public Eval_inputContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_eval_input; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterEval_input(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitEval_input(this); - } - } - - public final Eval_inputContext eval_input() throws RecognitionException { - Eval_inputContext _localctx = new Eval_inputContext(_ctx, getState()); - enterRule(_localctx, 4, RULE_eval_input); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(188); - testlist(); - setState(192); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == NEWLINE) { - { - { - setState(189); - match(NEWLINE); - } - } - setState(194); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(195); - match(EOF); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DecoratorContext extends ParserRuleContext { - public TerminalNode AT() { - return getToken(Python3Parser.AT, 0); - } - - public Dotted_nameContext dotted_name() { - return getRuleContext(Dotted_nameContext.class, 0); - } - - public TerminalNode NEWLINE() { - return getToken(Python3Parser.NEWLINE, 0); - } - - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public ArglistContext arglist() { - return getRuleContext(ArglistContext.class, 0); - } - - public DecoratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_decorator; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDecorator(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDecorator(this); - } - } - - public final DecoratorContext decorator() throws RecognitionException { - DecoratorContext _localctx = new DecoratorContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_decorator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(197); - match(AT); - setState(198); - dotted_name(); - setState(204); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == OPEN_PAREN) { - { - setState(199); - match(OPEN_PAREN); - setState(201); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(200); - arglist(); - } - } - - setState(203); - match(CLOSE_PAREN); - } - } - - setState(206); - match(NEWLINE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DecoratorsContext extends ParserRuleContext { - public List decorator() { - return getRuleContexts(DecoratorContext.class); - } - - public DecoratorContext decorator(int i) { - return getRuleContext(DecoratorContext.class, i); - } - - public DecoratorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_decorators; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDecorators(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDecorators(this); - } - } - - public final DecoratorsContext decorators() throws RecognitionException { - DecoratorsContext _localctx = new DecoratorsContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_decorators); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(209); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(208); - decorator(); - } - } - setState(211); - _errHandler.sync(this); - _la = _input.LA(1); - } while (_la == AT); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DecoratedContext extends ParserRuleContext { - public DecoratorsContext decorators() { - return getRuleContext(DecoratorsContext.class, 0); - } - - public ClassdefContext classdef() { - return getRuleContext(ClassdefContext.class, 0); - } - - public FuncdefContext funcdef() { - return getRuleContext(FuncdefContext.class, 0); - } - - public Async_funcdefContext async_funcdef() { - return getRuleContext(Async_funcdefContext.class, 0); - } - - public DecoratedContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_decorated; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDecorated(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDecorated(this); - } - } - - public final DecoratedContext decorated() throws RecognitionException { - DecoratedContext _localctx = new DecoratedContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_decorated); - try { - enterOuterAlt(_localctx, 1); - { - setState(213); - decorators(); - setState(217); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CLASS: { - setState(214); - classdef(); - } - break; - case DEF: { - setState(215); - funcdef(); - } - break; - case ASYNC: { - setState(216); - async_funcdef(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Async_funcdefContext extends ParserRuleContext { - public TerminalNode ASYNC() { - return getToken(Python3Parser.ASYNC, 0); - } - - public FuncdefContext funcdef() { - return getRuleContext(FuncdefContext.class, 0); - } - - public Async_funcdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_async_funcdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAsync_funcdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAsync_funcdef(this); - } - } - - public final Async_funcdefContext async_funcdef() throws RecognitionException { - Async_funcdefContext _localctx = new Async_funcdefContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_async_funcdef); - try { - enterOuterAlt(_localctx, 1); - { - setState(219); - match(ASYNC); - setState(220); - funcdef(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FuncdefContext extends ParserRuleContext { - public TerminalNode DEF() { - return getToken(Python3Parser.DEF, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public ParametersContext parameters() { - return getRuleContext(ParametersContext.class, 0); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public SuiteContext suite() { - return getRuleContext(SuiteContext.class, 0); - } - - public TerminalNode ARROW() { - return getToken(Python3Parser.ARROW, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public FuncdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_funcdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterFuncdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitFuncdef(this); - } - } - - public final FuncdefContext funcdef() throws RecognitionException { - FuncdefContext _localctx = new FuncdefContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_funcdef); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(222); - match(DEF); - setState(223); - match(NAME); - setState(224); - parameters(); - setState(227); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ARROW) { - { - setState(225); - match(ARROW); - setState(226); - test(); - } - } - - setState(229); - match(COLON); - setState(230); - suite(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ParametersContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public TypedargslistContext typedargslist() { - return getRuleContext(TypedargslistContext.class, 0); - } - - public ParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_parameters; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterParameters(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitParameters(this); - } - } - - public final ParametersContext parameters() throws RecognitionException { - ParametersContext _localctx = new ParametersContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_parameters); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(232); - match(OPEN_PAREN); - setState(234); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { - { - setState(233); - typedargslist(); - } - } - - setState(236); - match(CLOSE_PAREN); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TypedargslistContext extends ParserRuleContext { - public List tfpdef() { - return getRuleContexts(TfpdefContext.class); - } - - public TfpdefContext tfpdef(int i) { - return getRuleContext(TfpdefContext.class, i); - } - - public TerminalNode STAR() { - return getToken(Python3Parser.STAR, 0); - } - - public TerminalNode POWER() { - return getToken(Python3Parser.POWER, 0); - } - - public List ASSIGN() { - return getTokens(Python3Parser.ASSIGN); - } - - public TerminalNode ASSIGN(int i) { - return getToken(Python3Parser.ASSIGN, i); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public TypedargslistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typedargslist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTypedargslist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTypedargslist(this); - } - } - - public final TypedargslistContext typedargslist() throws RecognitionException { - TypedargslistContext _localctx = new TypedargslistContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_typedargslist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(319); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NAME: { - setState(238); - tfpdef(); - setState(241); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(239); - match(ASSIGN); - setState(240); - test(); - } - } - - setState(251); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 12, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(243); - match(COMMA); - setState(244); - tfpdef(); - setState(247); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(245); - match(ASSIGN); - setState(246); - test(); - } - } - - } - } - } - setState(253); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 12, _ctx); - } - setState(287); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(254); - match(COMMA); - setState(285); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STAR: { - setState(255); - match(STAR); - setState(257); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == NAME) { - { - setState(256); - tfpdef(); - } - } - - setState(267); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 15, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(259); - match(COMMA); - setState(260); - tfpdef(); - setState(263); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(261); - match(ASSIGN); - setState(262); - test(); - } - } - - } - } - } - setState(269); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 15, _ctx); - } - setState(278); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(270); - match(COMMA); - setState(276); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == POWER) { - { - setState(271); - match(POWER); - setState(272); - tfpdef(); - setState(274); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(273); - match(COMMA); - } - } - - } - } - - } - } - - } - break; - case POWER: { - setState(280); - match(POWER); - setState(281); - tfpdef(); - setState(283); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(282); - match(COMMA); - } - } - - } - break; - case CLOSE_PAREN: - break; - default: - break; - } - } - } - - } - break; - case STAR: { - setState(289); - match(STAR); - setState(291); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == NAME) { - { - setState(290); - tfpdef(); - } - } - - setState(301); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 24, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(293); - match(COMMA); - setState(294); - tfpdef(); - setState(297); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(295); - match(ASSIGN); - setState(296); - test(); - } - } - - } - } - } - setState(303); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 24, _ctx); - } - setState(312); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(304); - match(COMMA); - setState(310); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == POWER) { - { - setState(305); - match(POWER); - setState(306); - tfpdef(); - setState(308); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(307); - match(COMMA); - } - } - - } - } - - } - } - - } - break; - case POWER: { - setState(314); - match(POWER); - setState(315); - tfpdef(); - setState(317); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(316); - match(COMMA); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TfpdefContext extends ParserRuleContext { - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public TfpdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_tfpdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTfpdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTfpdef(this); - } - } - - public final TfpdefContext tfpdef() throws RecognitionException { - TfpdefContext _localctx = new TfpdefContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_tfpdef); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(321); - match(NAME); - setState(324); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COLON) { - { - setState(322); - match(COLON); - setState(323); - test(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VarargslistContext extends ParserRuleContext { - public List vfpdef() { - return getRuleContexts(VfpdefContext.class); - } - - public VfpdefContext vfpdef(int i) { - return getRuleContext(VfpdefContext.class, i); - } - - public TerminalNode STAR() { - return getToken(Python3Parser.STAR, 0); - } - - public TerminalNode POWER() { - return getToken(Python3Parser.POWER, 0); - } - - public List ASSIGN() { - return getTokens(Python3Parser.ASSIGN); - } - - public TerminalNode ASSIGN(int i) { - return getToken(Python3Parser.ASSIGN, i); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public VarargslistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_varargslist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterVarargslist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitVarargslist(this); - } - } - - public final VarargslistContext varargslist() throws RecognitionException { - VarargslistContext _localctx = new VarargslistContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_varargslist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(407); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NAME: { - setState(326); - vfpdef(); - setState(329); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(327); - match(ASSIGN); - setState(328); - test(); - } - } - - setState(339); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 33, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(331); - match(COMMA); - setState(332); - vfpdef(); - setState(335); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(333); - match(ASSIGN); - setState(334); - test(); - } - } - - } - } - } - setState(341); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 33, _ctx); - } - setState(375); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(342); - match(COMMA); - setState(373); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STAR: { - setState(343); - match(STAR); - setState(345); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == NAME) { - { - setState(344); - vfpdef(); - } - } - - setState(355); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(347); - match(COMMA); - setState(348); - vfpdef(); - setState(351); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(349); - match(ASSIGN); - setState(350); - test(); - } - } - - } - } - } - setState(357); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 36, _ctx); - } - setState(366); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(358); - match(COMMA); - setState(364); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == POWER) { - { - setState(359); - match(POWER); - setState(360); - vfpdef(); - setState(362); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(361); - match(COMMA); - } - } - - } - } - - } - } - - } - break; - case POWER: { - setState(368); - match(POWER); - setState(369); - vfpdef(); - setState(371); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(370); - match(COMMA); - } - } - - } - break; - case COLON: - break; - default: - break; - } - } - } - - } - break; - case STAR: { - setState(377); - match(STAR); - setState(379); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == NAME) { - { - setState(378); - vfpdef(); - } - } - - setState(389); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 45, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(381); - match(COMMA); - setState(382); - vfpdef(); - setState(385); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(383); - match(ASSIGN); - setState(384); - test(); - } - } - - } - } - } - setState(391); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 45, _ctx); - } - setState(400); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(392); - match(COMMA); - setState(398); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == POWER) { - { - setState(393); - match(POWER); - setState(394); - vfpdef(); - setState(396); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(395); - match(COMMA); - } - } - - } - } - - } - } - - } - break; - case POWER: { - setState(402); - match(POWER); - setState(403); - vfpdef(); - setState(405); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(404); - match(COMMA); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class VfpdefContext extends ParserRuleContext { - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public VfpdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_vfpdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterVfpdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitVfpdef(this); - } - } - - public final VfpdefContext vfpdef() throws RecognitionException { - VfpdefContext _localctx = new VfpdefContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_vfpdef); - try { - enterOuterAlt(_localctx, 1); - { - setState(409); - match(NAME); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class StmtContext extends ParserRuleContext { - public Simple_stmtContext simple_stmt() { - return getRuleContext(Simple_stmtContext.class, 0); - } - - public Compound_stmtContext compound_stmt() { - return getRuleContext(Compound_stmtContext.class, 0); - } - - public StmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterStmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitStmt(this); - } - } - - public final StmtContext stmt() throws RecognitionException { - StmtContext _localctx = new StmtContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_stmt); - try { - setState(413); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case RETURN: - case RAISE: - case FROM: - case IMPORT: - case GLOBAL: - case NONLOCAL: - case ASSERT: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case YIELD: - case DEL: - case PASS: - case CONTINUE: - case BREAK: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(411); - simple_stmt(); - } - break; - case DEF: - case IF: - case WHILE: - case FOR: - case TRY: - case WITH: - case CLASS: - case ASYNC: - case AT: - enterOuterAlt(_localctx, 2); - { - setState(412); - compound_stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Simple_stmtContext extends ParserRuleContext { - public List small_stmt() { - return getRuleContexts(Small_stmtContext.class); - } - - public Small_stmtContext small_stmt(int i) { - return getRuleContext(Small_stmtContext.class, i); - } - - public TerminalNode NEWLINE() { - return getToken(Python3Parser.NEWLINE, 0); - } - - public List SEMI_COLON() { - return getTokens(Python3Parser.SEMI_COLON); - } - - public TerminalNode SEMI_COLON(int i) { - return getToken(Python3Parser.SEMI_COLON, i); - } - - public Simple_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_simple_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSimple_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSimple_stmt(this); - } - } - - public final Simple_stmtContext simple_stmt() throws RecognitionException { - Simple_stmtContext _localctx = new Simple_stmtContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_simple_stmt); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(415); - small_stmt(); - setState(420); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(416); - match(SEMI_COLON); - setState(417); - small_stmt(); - } - } - } - setState(422); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); - } - setState(424); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == SEMI_COLON) { - { - setState(423); - match(SEMI_COLON); - } - } - - setState(426); - match(NEWLINE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Small_stmtContext extends ParserRuleContext { - public Expr_stmtContext expr_stmt() { - return getRuleContext(Expr_stmtContext.class, 0); - } - - public Del_stmtContext del_stmt() { - return getRuleContext(Del_stmtContext.class, 0); - } - - public Pass_stmtContext pass_stmt() { - return getRuleContext(Pass_stmtContext.class, 0); - } - - public Flow_stmtContext flow_stmt() { - return getRuleContext(Flow_stmtContext.class, 0); - } - - public Import_stmtContext import_stmt() { - return getRuleContext(Import_stmtContext.class, 0); - } - - public Global_stmtContext global_stmt() { - return getRuleContext(Global_stmtContext.class, 0); - } - - public Nonlocal_stmtContext nonlocal_stmt() { - return getRuleContext(Nonlocal_stmtContext.class, 0); - } - - public Assert_stmtContext assert_stmt() { - return getRuleContext(Assert_stmtContext.class, 0); - } - - public Small_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_small_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSmall_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSmall_stmt(this); - } - } - - public final Small_stmtContext small_stmt() throws RecognitionException { - Small_stmtContext _localctx = new Small_stmtContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_small_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(436); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(428); - expr_stmt(); - } - break; - case DEL: { - setState(429); - del_stmt(); - } - break; - case PASS: { - setState(430); - pass_stmt(); - } - break; - case RETURN: - case RAISE: - case YIELD: - case CONTINUE: - case BREAK: { - setState(431); - flow_stmt(); - } - break; - case FROM: - case IMPORT: { - setState(432); - import_stmt(); - } - break; - case GLOBAL: { - setState(433); - global_stmt(); - } - break; - case NONLOCAL: { - setState(434); - nonlocal_stmt(); - } - break; - case ASSERT: { - setState(435); - assert_stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Expr_stmtContext extends ParserRuleContext { - public List testlist_star_expr() { - return getRuleContexts(Testlist_star_exprContext.class); - } - - public Testlist_star_exprContext testlist_star_expr(int i) { - return getRuleContext(Testlist_star_exprContext.class, i); - } - - public AnnassignContext annassign() { - return getRuleContext(AnnassignContext.class, 0); - } - - public AugassignContext augassign() { - return getRuleContext(AugassignContext.class, 0); - } - - public List yield_expr() { - return getRuleContexts(Yield_exprContext.class); - } - - public Yield_exprContext yield_expr(int i) { - return getRuleContext(Yield_exprContext.class, i); - } - - public TestlistContext testlist() { - return getRuleContext(TestlistContext.class, 0); - } - - public List ASSIGN() { - return getTokens(Python3Parser.ASSIGN); - } - - public TerminalNode ASSIGN(int i) { - return getToken(Python3Parser.ASSIGN, i); - } - - public Expr_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expr_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterExpr_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitExpr_stmt(this); - } - } - - public final Expr_stmtContext expr_stmt() throws RecognitionException { - Expr_stmtContext _localctx = new Expr_stmtContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_expr_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(438); - testlist_star_expr(); - setState(455); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: { - setState(439); - annassign(); - } - break; - case ADD_ASSIGN: - case SUB_ASSIGN: - case MULT_ASSIGN: - case AT_ASSIGN: - case DIV_ASSIGN: - case MOD_ASSIGN: - case AND_ASSIGN: - case OR_ASSIGN: - case XOR_ASSIGN: - case LEFT_SHIFT_ASSIGN: - case RIGHT_SHIFT_ASSIGN: - case POWER_ASSIGN: - case IDIV_ASSIGN: { - setState(440); - augassign(); - setState(443); - _errHandler.sync(this); - switch (_input.LA(1)) { - case YIELD: { - setState(441); - yield_expr(); - } - break; - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(442); - testlist(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case NEWLINE: - case SEMI_COLON: - case ASSIGN: { - setState(452); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == ASSIGN) { - { - { - setState(445); - match(ASSIGN); - setState(448); - _errHandler.sync(this); - switch (_input.LA(1)) { - case YIELD: { - setState(446); - yield_expr(); - } - break; - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(447); - testlist_star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(454); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AnnassignContext extends ParserRuleContext { - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public TerminalNode ASSIGN() { - return getToken(Python3Parser.ASSIGN, 0); - } - - public AnnassignContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annassign; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAnnassign(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAnnassign(this); - } - } - - public final AnnassignContext annassign() throws RecognitionException { - AnnassignContext _localctx = new AnnassignContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_annassign); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(457); - match(COLON); - setState(458); - test(); - setState(461); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASSIGN) { - { - setState(459); - match(ASSIGN); - setState(460); - test(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Testlist_star_exprContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List star_expr() { - return getRuleContexts(Star_exprContext.class); - } - - public Star_exprContext star_expr(int i) { - return getRuleContext(Star_exprContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Testlist_star_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_testlist_star_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTestlist_star_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTestlist_star_expr(this); - } - } - - public final Testlist_star_exprContext testlist_star_expr() throws RecognitionException { - Testlist_star_exprContext _localctx = new Testlist_star_exprContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_testlist_star_expr); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(465); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(463); - test(); - } - break; - case STAR: { - setState(464); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(474); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 62, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(467); - match(COMMA); - setState(470); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(468); - test(); - } - break; - case STAR: { - setState(469); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - setState(476); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 62, _ctx); - } - setState(478); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(477); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AugassignContext extends ParserRuleContext { - public TerminalNode ADD_ASSIGN() { - return getToken(Python3Parser.ADD_ASSIGN, 0); - } - - public TerminalNode SUB_ASSIGN() { - return getToken(Python3Parser.SUB_ASSIGN, 0); - } - - public TerminalNode MULT_ASSIGN() { - return getToken(Python3Parser.MULT_ASSIGN, 0); - } - - public TerminalNode AT_ASSIGN() { - return getToken(Python3Parser.AT_ASSIGN, 0); - } - - public TerminalNode DIV_ASSIGN() { - return getToken(Python3Parser.DIV_ASSIGN, 0); - } - - public TerminalNode MOD_ASSIGN() { - return getToken(Python3Parser.MOD_ASSIGN, 0); - } - - public TerminalNode AND_ASSIGN() { - return getToken(Python3Parser.AND_ASSIGN, 0); - } - - public TerminalNode OR_ASSIGN() { - return getToken(Python3Parser.OR_ASSIGN, 0); - } - - public TerminalNode XOR_ASSIGN() { - return getToken(Python3Parser.XOR_ASSIGN, 0); - } - - public TerminalNode LEFT_SHIFT_ASSIGN() { - return getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0); - } - - public TerminalNode RIGHT_SHIFT_ASSIGN() { - return getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0); - } - - public TerminalNode POWER_ASSIGN() { - return getToken(Python3Parser.POWER_ASSIGN, 0); - } - - public TerminalNode IDIV_ASSIGN() { - return getToken(Python3Parser.IDIV_ASSIGN, 0); - } - - public AugassignContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_augassign; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAugassign(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAugassign(this); - } - } - - public final AugassignContext augassign() throws RecognitionException { - AugassignContext _localctx = new AugassignContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_augassign); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(480); - _la = _input.LA(1); - if (!(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (ADD_ASSIGN - 83)) | (1L << (SUB_ASSIGN - 83)) | (1L << (MULT_ASSIGN - 83)) | (1L << (AT_ASSIGN - 83)) | (1L << (DIV_ASSIGN - 83)) | (1L << (MOD_ASSIGN - 83)) | (1L << (AND_ASSIGN - 83)) | (1L << (OR_ASSIGN - 83)) | (1L << (XOR_ASSIGN - 83)) | (1L << (LEFT_SHIFT_ASSIGN - 83)) | (1L << (RIGHT_SHIFT_ASSIGN - 83)) | (1L << (POWER_ASSIGN - 83)) | (1L << (IDIV_ASSIGN - 83)))) != 0))) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Del_stmtContext extends ParserRuleContext { - public TerminalNode DEL() { - return getToken(Python3Parser.DEL, 0); - } - - public ExprlistContext exprlist() { - return getRuleContext(ExprlistContext.class, 0); - } - - public Del_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_del_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDel_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDel_stmt(this); - } - } - - public final Del_stmtContext del_stmt() throws RecognitionException { - Del_stmtContext _localctx = new Del_stmtContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_del_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(482); - match(DEL); - setState(483); - exprlist(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Pass_stmtContext extends ParserRuleContext { - public TerminalNode PASS() { - return getToken(Python3Parser.PASS, 0); - } - - public Pass_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_pass_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterPass_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitPass_stmt(this); - } - } - - public final Pass_stmtContext pass_stmt() throws RecognitionException { - Pass_stmtContext _localctx = new Pass_stmtContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_pass_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(485); - match(PASS); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Flow_stmtContext extends ParserRuleContext { - public Break_stmtContext break_stmt() { - return getRuleContext(Break_stmtContext.class, 0); - } - - public Continue_stmtContext continue_stmt() { - return getRuleContext(Continue_stmtContext.class, 0); - } - - public Return_stmtContext return_stmt() { - return getRuleContext(Return_stmtContext.class, 0); - } - - public Raise_stmtContext raise_stmt() { - return getRuleContext(Raise_stmtContext.class, 0); - } - - public Yield_stmtContext yield_stmt() { - return getRuleContext(Yield_stmtContext.class, 0); - } - - public Flow_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_flow_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterFlow_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitFlow_stmt(this); - } - } - - public final Flow_stmtContext flow_stmt() throws RecognitionException { - Flow_stmtContext _localctx = new Flow_stmtContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_flow_stmt); - try { - setState(492); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BREAK: - enterOuterAlt(_localctx, 1); - { - setState(487); - break_stmt(); - } - break; - case CONTINUE: - enterOuterAlt(_localctx, 2); - { - setState(488); - continue_stmt(); - } - break; - case RETURN: - enterOuterAlt(_localctx, 3); - { - setState(489); - return_stmt(); - } - break; - case RAISE: - enterOuterAlt(_localctx, 4); - { - setState(490); - raise_stmt(); - } - break; - case YIELD: - enterOuterAlt(_localctx, 5); - { - setState(491); - yield_stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Break_stmtContext extends ParserRuleContext { - public TerminalNode BREAK() { - return getToken(Python3Parser.BREAK, 0); - } - - public Break_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_break_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterBreak_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitBreak_stmt(this); - } - } - - public final Break_stmtContext break_stmt() throws RecognitionException { - Break_stmtContext _localctx = new Break_stmtContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_break_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(494); - match(BREAK); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Continue_stmtContext extends ParserRuleContext { - public TerminalNode CONTINUE() { - return getToken(Python3Parser.CONTINUE, 0); - } - - public Continue_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_continue_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterContinue_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitContinue_stmt(this); - } - } - - public final Continue_stmtContext continue_stmt() throws RecognitionException { - Continue_stmtContext _localctx = new Continue_stmtContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_continue_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(496); - match(CONTINUE); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Return_stmtContext extends ParserRuleContext { - public TerminalNode RETURN() { - return getToken(Python3Parser.RETURN, 0); - } - - public TestlistContext testlist() { - return getRuleContext(TestlistContext.class, 0); - } - - public Return_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_return_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterReturn_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitReturn_stmt(this); - } - } - - public final Return_stmtContext return_stmt() throws RecognitionException { - Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_return_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(498); - match(RETURN); - setState(500); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(499); - testlist(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Yield_stmtContext extends ParserRuleContext { - public Yield_exprContext yield_expr() { - return getRuleContext(Yield_exprContext.class, 0); - } - - public Yield_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_yield_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterYield_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitYield_stmt(this); - } - } - - public final Yield_stmtContext yield_stmt() throws RecognitionException { - Yield_stmtContext _localctx = new Yield_stmtContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_yield_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(502); - yield_expr(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Raise_stmtContext extends ParserRuleContext { - public TerminalNode RAISE() { - return getToken(Python3Parser.RAISE, 0); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public TerminalNode FROM() { - return getToken(Python3Parser.FROM, 0); - } - - public Raise_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_raise_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterRaise_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitRaise_stmt(this); - } - } - - public final Raise_stmtContext raise_stmt() throws RecognitionException { - Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_raise_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(504); - match(RAISE); - setState(510); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(505); - test(); - setState(508); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == FROM) { - { - setState(506); - match(FROM); - setState(507); - test(); - } - } - - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Import_stmtContext extends ParserRuleContext { - public Import_nameContext import_name() { - return getRuleContext(Import_nameContext.class, 0); - } - - public Import_fromContext import_from() { - return getRuleContext(Import_fromContext.class, 0); - } - - public Import_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_import_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterImport_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitImport_stmt(this); - } - } - - public final Import_stmtContext import_stmt() throws RecognitionException { - Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_import_stmt); - try { - setState(514); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IMPORT: - enterOuterAlt(_localctx, 1); - { - setState(512); - import_name(); - } - break; - case FROM: - enterOuterAlt(_localctx, 2); - { - setState(513); - import_from(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Import_nameContext extends ParserRuleContext { - public TerminalNode IMPORT() { - return getToken(Python3Parser.IMPORT, 0); - } - - public Dotted_as_namesContext dotted_as_names() { - return getRuleContext(Dotted_as_namesContext.class, 0); - } - - public Import_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_import_name; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterImport_name(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitImport_name(this); - } - } - - public final Import_nameContext import_name() throws RecognitionException { - Import_nameContext _localctx = new Import_nameContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_import_name); - try { - enterOuterAlt(_localctx, 1); - { - setState(516); - match(IMPORT); - setState(517); - dotted_as_names(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Import_fromContext extends ParserRuleContext { - public TerminalNode FROM() { - return getToken(Python3Parser.FROM, 0); - } - - public TerminalNode IMPORT() { - return getToken(Python3Parser.IMPORT, 0); - } - - public Dotted_nameContext dotted_name() { - return getRuleContext(Dotted_nameContext.class, 0); - } - - public TerminalNode STAR() { - return getToken(Python3Parser.STAR, 0); - } - - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public Import_as_namesContext import_as_names() { - return getRuleContext(Import_as_namesContext.class, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public List DOT() { - return getTokens(Python3Parser.DOT); - } - - public TerminalNode DOT(int i) { - return getToken(Python3Parser.DOT, i); - } - - public List ELLIPSIS() { - return getTokens(Python3Parser.ELLIPSIS); - } - - public TerminalNode ELLIPSIS(int i) { - return getToken(Python3Parser.ELLIPSIS, i); - } - - public Import_fromContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_import_from; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterImport_from(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitImport_from(this); - } - } - - public final Import_fromContext import_from() throws RecognitionException { - Import_fromContext _localctx = new Import_fromContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_import_from); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - { - setState(519); - match(FROM); - setState(532); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 71, _ctx)) { - case 1: { - setState(523); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT || _la == ELLIPSIS) { - { - { - setState(520); - _la = _input.LA(1); - if (!(_la == DOT || _la == ELLIPSIS)) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - setState(525); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(526); - dotted_name(); - } - break; - case 2: { - setState(528); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(527); - _la = _input.LA(1); - if (!(_la == DOT || _la == ELLIPSIS)) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - setState(530); - _errHandler.sync(this); - _la = _input.LA(1); - } while (_la == DOT || _la == ELLIPSIS); - } - break; - } - setState(534); - match(IMPORT); - setState(541); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STAR: { - setState(535); - match(STAR); - } - break; - case OPEN_PAREN: { - setState(536); - match(OPEN_PAREN); - setState(537); - import_as_names(); - setState(538); - match(CLOSE_PAREN); - } - break; - case NAME: { - setState(540); - import_as_names(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Import_as_nameContext extends ParserRuleContext { - public List NAME() { - return getTokens(Python3Parser.NAME); - } - - public TerminalNode NAME(int i) { - return getToken(Python3Parser.NAME, i); - } - - public TerminalNode AS() { - return getToken(Python3Parser.AS, 0); - } - - public Import_as_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_import_as_name; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterImport_as_name(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitImport_as_name(this); - } - } - - public final Import_as_nameContext import_as_name() throws RecognitionException { - Import_as_nameContext _localctx = new Import_as_nameContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_import_as_name); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(543); - match(NAME); - setState(546); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == AS) { - { - setState(544); - match(AS); - setState(545); - match(NAME); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Dotted_as_nameContext extends ParserRuleContext { - public Dotted_nameContext dotted_name() { - return getRuleContext(Dotted_nameContext.class, 0); - } - - public TerminalNode AS() { - return getToken(Python3Parser.AS, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public Dotted_as_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dotted_as_name; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDotted_as_name(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDotted_as_name(this); - } - } - - public final Dotted_as_nameContext dotted_as_name() throws RecognitionException { - Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_dotted_as_name); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(548); - dotted_name(); - setState(551); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == AS) { - { - setState(549); - match(AS); - setState(550); - match(NAME); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Import_as_namesContext extends ParserRuleContext { - public List import_as_name() { - return getRuleContexts(Import_as_nameContext.class); - } - - public Import_as_nameContext import_as_name(int i) { - return getRuleContext(Import_as_nameContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Import_as_namesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_import_as_names; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterImport_as_names(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitImport_as_names(this); - } - } - - public final Import_as_namesContext import_as_names() throws RecognitionException { - Import_as_namesContext _localctx = new Import_as_namesContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_import_as_names); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(553); - import_as_name(); - setState(558); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(554); - match(COMMA); - setState(555); - import_as_name(); - } - } - } - setState(560); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); - } - setState(562); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(561); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Dotted_as_namesContext extends ParserRuleContext { - public List dotted_as_name() { - return getRuleContexts(Dotted_as_nameContext.class); - } - - public Dotted_as_nameContext dotted_as_name(int i) { - return getRuleContext(Dotted_as_nameContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Dotted_as_namesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dotted_as_names; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDotted_as_names(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDotted_as_names(this); - } - } - - public final Dotted_as_namesContext dotted_as_names() throws RecognitionException { - Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_dotted_as_names); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(564); - dotted_as_name(); - setState(569); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(565); - match(COMMA); - setState(566); - dotted_as_name(); - } - } - setState(571); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Dotted_nameContext extends ParserRuleContext { - public List NAME() { - return getTokens(Python3Parser.NAME); - } - - public TerminalNode NAME(int i) { - return getToken(Python3Parser.NAME, i); - } - - public List DOT() { - return getTokens(Python3Parser.DOT); - } - - public TerminalNode DOT(int i) { - return getToken(Python3Parser.DOT, i); - } - - public Dotted_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dotted_name; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDotted_name(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDotted_name(this); - } - } - - public final Dotted_nameContext dotted_name() throws RecognitionException { - Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_dotted_name); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(572); - match(NAME); - setState(577); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT) { - { - { - setState(573); - match(DOT); - setState(574); - match(NAME); - } - } - setState(579); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Global_stmtContext extends ParserRuleContext { - public TerminalNode GLOBAL() { - return getToken(Python3Parser.GLOBAL, 0); - } - - public List NAME() { - return getTokens(Python3Parser.NAME); - } - - public TerminalNode NAME(int i) { - return getToken(Python3Parser.NAME, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Global_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_global_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterGlobal_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitGlobal_stmt(this); - } - } - - public final Global_stmtContext global_stmt() throws RecognitionException { - Global_stmtContext _localctx = new Global_stmtContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_global_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(580); - match(GLOBAL); - setState(581); - match(NAME); - setState(586); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(582); - match(COMMA); - setState(583); - match(NAME); - } - } - setState(588); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Nonlocal_stmtContext extends ParserRuleContext { - public TerminalNode NONLOCAL() { - return getToken(Python3Parser.NONLOCAL, 0); - } - - public List NAME() { - return getTokens(Python3Parser.NAME); - } - - public TerminalNode NAME(int i) { - return getToken(Python3Parser.NAME, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Nonlocal_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_nonlocal_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterNonlocal_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitNonlocal_stmt(this); - } - } - - public final Nonlocal_stmtContext nonlocal_stmt() throws RecognitionException { - Nonlocal_stmtContext _localctx = new Nonlocal_stmtContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_nonlocal_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(589); - match(NONLOCAL); - setState(590); - match(NAME); - setState(595); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(591); - match(COMMA); - setState(592); - match(NAME); - } - } - setState(597); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Assert_stmtContext extends ParserRuleContext { - public TerminalNode ASSERT() { - return getToken(Python3Parser.ASSERT, 0); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public TerminalNode COMMA() { - return getToken(Python3Parser.COMMA, 0); - } - - public Assert_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_assert_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAssert_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAssert_stmt(this); - } - } - - public final Assert_stmtContext assert_stmt() throws RecognitionException { - Assert_stmtContext _localctx = new Assert_stmtContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_assert_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(598); - match(ASSERT); - setState(599); - test(); - setState(602); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(600); - match(COMMA); - setState(601); - test(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Compound_stmtContext extends ParserRuleContext { - public If_stmtContext if_stmt() { - return getRuleContext(If_stmtContext.class, 0); - } - - public While_stmtContext while_stmt() { - return getRuleContext(While_stmtContext.class, 0); - } - - public For_stmtContext for_stmt() { - return getRuleContext(For_stmtContext.class, 0); - } - - public Try_stmtContext try_stmt() { - return getRuleContext(Try_stmtContext.class, 0); - } - - public With_stmtContext with_stmt() { - return getRuleContext(With_stmtContext.class, 0); - } - - public FuncdefContext funcdef() { - return getRuleContext(FuncdefContext.class, 0); - } - - public ClassdefContext classdef() { - return getRuleContext(ClassdefContext.class, 0); - } - - public DecoratedContext decorated() { - return getRuleContext(DecoratedContext.class, 0); - } - - public Async_stmtContext async_stmt() { - return getRuleContext(Async_stmtContext.class, 0); - } - - public Compound_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_compound_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterCompound_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitCompound_stmt(this); - } - } - - public final Compound_stmtContext compound_stmt() throws RecognitionException { - Compound_stmtContext _localctx = new Compound_stmtContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_compound_stmt); - try { - setState(613); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IF: - enterOuterAlt(_localctx, 1); - { - setState(604); - if_stmt(); - } - break; - case WHILE: - enterOuterAlt(_localctx, 2); - { - setState(605); - while_stmt(); - } - break; - case FOR: - enterOuterAlt(_localctx, 3); - { - setState(606); - for_stmt(); - } - break; - case TRY: - enterOuterAlt(_localctx, 4); - { - setState(607); - try_stmt(); - } - break; - case WITH: - enterOuterAlt(_localctx, 5); - { - setState(608); - with_stmt(); - } - break; - case DEF: - enterOuterAlt(_localctx, 6); - { - setState(609); - funcdef(); - } - break; - case CLASS: - enterOuterAlt(_localctx, 7); - { - setState(610); - classdef(); - } - break; - case AT: - enterOuterAlt(_localctx, 8); - { - setState(611); - decorated(); - } - break; - case ASYNC: - enterOuterAlt(_localctx, 9); - { - setState(612); - async_stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Async_stmtContext extends ParserRuleContext { - public TerminalNode ASYNC() { - return getToken(Python3Parser.ASYNC, 0); - } - - public FuncdefContext funcdef() { - return getRuleContext(FuncdefContext.class, 0); - } - - public With_stmtContext with_stmt() { - return getRuleContext(With_stmtContext.class, 0); - } - - public For_stmtContext for_stmt() { - return getRuleContext(For_stmtContext.class, 0); - } - - public Async_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_async_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAsync_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAsync_stmt(this); - } - } - - public final Async_stmtContext async_stmt() throws RecognitionException { - Async_stmtContext _localctx = new Async_stmtContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_async_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(615); - match(ASYNC); - setState(619); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DEF: { - setState(616); - funcdef(); - } - break; - case WITH: { - setState(617); - with_stmt(); - } - break; - case FOR: { - setState(618); - for_stmt(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class If_stmtContext extends ParserRuleContext { - public TerminalNode IF() { - return getToken(Python3Parser.IF, 0); - } - - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List COLON() { - return getTokens(Python3Parser.COLON); - } - - public TerminalNode COLON(int i) { - return getToken(Python3Parser.COLON, i); - } - - public List suite() { - return getRuleContexts(SuiteContext.class); - } - - public SuiteContext suite(int i) { - return getRuleContext(SuiteContext.class, i); - } - - public List ELIF() { - return getTokens(Python3Parser.ELIF); - } - - public TerminalNode ELIF(int i) { - return getToken(Python3Parser.ELIF, i); - } - - public TerminalNode ELSE() { - return getToken(Python3Parser.ELSE, 0); - } - - public If_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_if_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterIf_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitIf_stmt(this); - } - } - - public final If_stmtContext if_stmt() throws RecognitionException { - If_stmtContext _localctx = new If_stmtContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_if_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(621); - match(IF); - setState(622); - test(); - setState(623); - match(COLON); - setState(624); - suite(); - setState(632); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == ELIF) { - { - { - setState(625); - match(ELIF); - setState(626); - test(); - setState(627); - match(COLON); - setState(628); - suite(); - } - } - setState(634); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(638); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ELSE) { - { - setState(635); - match(ELSE); - setState(636); - match(COLON); - setState(637); - suite(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class While_stmtContext extends ParserRuleContext { - public TerminalNode WHILE() { - return getToken(Python3Parser.WHILE, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public List COLON() { - return getTokens(Python3Parser.COLON); - } - - public TerminalNode COLON(int i) { - return getToken(Python3Parser.COLON, i); - } - - public List suite() { - return getRuleContexts(SuiteContext.class); - } - - public SuiteContext suite(int i) { - return getRuleContext(SuiteContext.class, i); - } - - public TerminalNode ELSE() { - return getToken(Python3Parser.ELSE, 0); - } - - public While_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_while_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterWhile_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitWhile_stmt(this); - } - } - - public final While_stmtContext while_stmt() throws RecognitionException { - While_stmtContext _localctx = new While_stmtContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_while_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(640); - match(WHILE); - setState(641); - test(); - setState(642); - match(COLON); - setState(643); - suite(); - setState(647); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ELSE) { - { - setState(644); - match(ELSE); - setState(645); - match(COLON); - setState(646); - suite(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class For_stmtContext extends ParserRuleContext { - public TerminalNode FOR() { - return getToken(Python3Parser.FOR, 0); - } - - public ExprlistContext exprlist() { - return getRuleContext(ExprlistContext.class, 0); - } - - public TerminalNode IN() { - return getToken(Python3Parser.IN, 0); - } - - public TestlistContext testlist() { - return getRuleContext(TestlistContext.class, 0); - } - - public List COLON() { - return getTokens(Python3Parser.COLON); - } - - public TerminalNode COLON(int i) { - return getToken(Python3Parser.COLON, i); - } - - public List suite() { - return getRuleContexts(SuiteContext.class); - } - - public SuiteContext suite(int i) { - return getRuleContext(SuiteContext.class, i); - } - - public TerminalNode ELSE() { - return getToken(Python3Parser.ELSE, 0); - } - - public For_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_for_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterFor_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitFor_stmt(this); - } - } - - public final For_stmtContext for_stmt() throws RecognitionException { - For_stmtContext _localctx = new For_stmtContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_for_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(649); - match(FOR); - setState(650); - exprlist(); - setState(651); - match(IN); - setState(652); - testlist(); - setState(653); - match(COLON); - setState(654); - suite(); - setState(658); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ELSE) { - { - setState(655); - match(ELSE); - setState(656); - match(COLON); - setState(657); - suite(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Try_stmtContext extends ParserRuleContext { - public TerminalNode TRY() { - return getToken(Python3Parser.TRY, 0); - } - - public List COLON() { - return getTokens(Python3Parser.COLON); - } - - public TerminalNode COLON(int i) { - return getToken(Python3Parser.COLON, i); - } - - public List suite() { - return getRuleContexts(SuiteContext.class); - } - - public SuiteContext suite(int i) { - return getRuleContext(SuiteContext.class, i); - } - - public TerminalNode FINALLY() { - return getToken(Python3Parser.FINALLY, 0); - } - - public List except_clause() { - return getRuleContexts(Except_clauseContext.class); - } - - public Except_clauseContext except_clause(int i) { - return getRuleContext(Except_clauseContext.class, i); - } - - public TerminalNode ELSE() { - return getToken(Python3Parser.ELSE, 0); - } - - public Try_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_try_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTry_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTry_stmt(this); - } - } - - public final Try_stmtContext try_stmt() throws RecognitionException { - Try_stmtContext _localctx = new Try_stmtContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_try_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - { - setState(660); - match(TRY); - setState(661); - match(COLON); - setState(662); - suite(); - setState(684); - _errHandler.sync(this); - switch (_input.LA(1)) { - case EXCEPT: { - setState(667); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(663); - except_clause(); - setState(664); - match(COLON); - setState(665); - suite(); - } - } - setState(669); - _errHandler.sync(this); - _la = _input.LA(1); - } while (_la == EXCEPT); - setState(674); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ELSE) { - { - setState(671); - match(ELSE); - setState(672); - match(COLON); - setState(673); - suite(); - } - } - - setState(679); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == FINALLY) { - { - setState(676); - match(FINALLY); - setState(677); - match(COLON); - setState(678); - suite(); - } - } - - } - break; - case FINALLY: { - setState(681); - match(FINALLY); - setState(682); - match(COLON); - setState(683); - suite(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class With_stmtContext extends ParserRuleContext { - public TerminalNode WITH() { - return getToken(Python3Parser.WITH, 0); - } - - public List with_item() { - return getRuleContexts(With_itemContext.class); - } - - public With_itemContext with_item(int i) { - return getRuleContext(With_itemContext.class, i); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public SuiteContext suite() { - return getRuleContext(SuiteContext.class, 0); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public With_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_with_stmt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterWith_stmt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitWith_stmt(this); - } - } - - public final With_stmtContext with_stmt() throws RecognitionException { - With_stmtContext _localctx = new With_stmtContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_with_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(686); - match(WITH); - setState(687); - with_item(); - setState(692); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(688); - match(COMMA); - setState(689); - with_item(); - } - } - setState(694); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(695); - match(COLON); - setState(696); - suite(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class With_itemContext extends ParserRuleContext { - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public TerminalNode AS() { - return getToken(Python3Parser.AS, 0); - } - - public ExprContext expr() { - return getRuleContext(ExprContext.class, 0); - } - - public With_itemContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_with_item; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterWith_item(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitWith_item(this); - } - } - - public final With_itemContext with_item() throws RecognitionException { - With_itemContext _localctx = new With_itemContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_with_item); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(698); - test(); - setState(701); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == AS) { - { - setState(699); - match(AS); - setState(700); - expr(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Except_clauseContext extends ParserRuleContext { - public TerminalNode EXCEPT() { - return getToken(Python3Parser.EXCEPT, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public TerminalNode AS() { - return getToken(Python3Parser.AS, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public Except_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_except_clause; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterExcept_clause(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitExcept_clause(this); - } - } - - public final Except_clauseContext except_clause() throws RecognitionException { - Except_clauseContext _localctx = new Except_clauseContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_except_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(703); - match(EXCEPT); - setState(709); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(704); - test(); - setState(707); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == AS) { - { - setState(705); - match(AS); - setState(706); - match(NAME); - } - } - - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SuiteContext extends ParserRuleContext { - public Simple_stmtContext simple_stmt() { - return getRuleContext(Simple_stmtContext.class, 0); - } - - public TerminalNode NEWLINE() { - return getToken(Python3Parser.NEWLINE, 0); - } - - public TerminalNode INDENT() { - return getToken(Python3Parser.INDENT, 0); - } - - public TerminalNode DEDENT() { - return getToken(Python3Parser.DEDENT, 0); - } - - public List stmt() { - return getRuleContexts(StmtContext.class); - } - - public StmtContext stmt(int i) { - return getRuleContext(StmtContext.class, i); - } - - public SuiteContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_suite; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSuite(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSuite(this); - } - } - - public final SuiteContext suite() throws RecognitionException { - SuiteContext _localctx = new SuiteContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_suite); - int _la; - try { - setState(721); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case RETURN: - case RAISE: - case FROM: - case IMPORT: - case GLOBAL: - case NONLOCAL: - case ASSERT: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case YIELD: - case DEL: - case PASS: - case CONTINUE: - case BREAK: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(711); - simple_stmt(); - } - break; - case NEWLINE: - enterOuterAlt(_localctx, 2); - { - setState(712); - match(NEWLINE); - setState(713); - match(INDENT); - setState(715); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(714); - stmt(); - } - } - setState(717); - _errHandler.sync(this); - _la = _input.LA(1); - } while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0)); - setState(719); - match(DEDENT); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TestContext extends ParserRuleContext { - public List or_test() { - return getRuleContexts(Or_testContext.class); - } - - public Or_testContext or_test(int i) { - return getRuleContext(Or_testContext.class, i); - } - - public TerminalNode IF() { - return getToken(Python3Parser.IF, 0); - } - - public TerminalNode ELSE() { - return getToken(Python3Parser.ELSE, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public LambdefContext lambdef() { - return getRuleContext(LambdefContext.class, 0); - } - - public TestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_test; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTest(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTest(this); - } - } - - public final TestContext test() throws RecognitionException { - TestContext _localctx = new TestContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_test); - int _la; - try { - setState(732); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(723); - or_test(); - setState(729); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == IF) { - { - setState(724); - match(IF); - setState(725); - or_test(); - setState(726); - match(ELSE); - setState(727); - test(); - } - } - - } - break; - case LAMBDA: - enterOuterAlt(_localctx, 2); - { - setState(731); - lambdef(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Test_nocondContext extends ParserRuleContext { - public Or_testContext or_test() { - return getRuleContext(Or_testContext.class, 0); - } - - public Lambdef_nocondContext lambdef_nocond() { - return getRuleContext(Lambdef_nocondContext.class, 0); - } - - public Test_nocondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_test_nocond; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTest_nocond(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTest_nocond(this); - } - } - - public final Test_nocondContext test_nocond() throws RecognitionException { - Test_nocondContext _localctx = new Test_nocondContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_test_nocond); - try { - setState(736); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 1); - { - setState(734); - or_test(); - } - break; - case LAMBDA: - enterOuterAlt(_localctx, 2); - { - setState(735); - lambdef_nocond(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class LambdefContext extends ParserRuleContext { - public TerminalNode LAMBDA() { - return getToken(Python3Parser.LAMBDA, 0); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public VarargslistContext varargslist() { - return getRuleContext(VarargslistContext.class, 0); - } - - public LambdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lambdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterLambdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitLambdef(this); - } - } - - public final LambdefContext lambdef() throws RecognitionException { - LambdefContext _localctx = new LambdefContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_lambdef); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(738); - match(LAMBDA); - setState(740); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { - { - setState(739); - varargslist(); - } - } - - setState(742); - match(COLON); - setState(743); - test(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Lambdef_nocondContext extends ParserRuleContext { - public TerminalNode LAMBDA() { - return getToken(Python3Parser.LAMBDA, 0); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public Test_nocondContext test_nocond() { - return getRuleContext(Test_nocondContext.class, 0); - } - - public VarargslistContext varargslist() { - return getRuleContext(VarargslistContext.class, 0); - } - - public Lambdef_nocondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lambdef_nocond; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterLambdef_nocond(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitLambdef_nocond(this); - } - } - - public final Lambdef_nocondContext lambdef_nocond() throws RecognitionException { - Lambdef_nocondContext _localctx = new Lambdef_nocondContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_lambdef_nocond); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(745); - match(LAMBDA); - setState(747); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { - { - setState(746); - varargslist(); - } - } - - setState(749); - match(COLON); - setState(750); - test_nocond(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Or_testContext extends ParserRuleContext { - public List and_test() { - return getRuleContexts(And_testContext.class); - } - - public And_testContext and_test(int i) { - return getRuleContext(And_testContext.class, i); - } - - public List OR() { - return getTokens(Python3Parser.OR); - } - - public TerminalNode OR(int i) { - return getToken(Python3Parser.OR, i); - } - - public Or_testContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_or_test; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterOr_test(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitOr_test(this); - } - } - - public final Or_testContext or_test() throws RecognitionException { - Or_testContext _localctx = new Or_testContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_or_test); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(752); - and_test(); - setState(757); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == OR) { - { - { - setState(753); - match(OR); - setState(754); - and_test(); - } - } - setState(759); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class And_testContext extends ParserRuleContext { - public List not_test() { - return getRuleContexts(Not_testContext.class); - } - - public Not_testContext not_test(int i) { - return getRuleContext(Not_testContext.class, i); - } - - public List AND() { - return getTokens(Python3Parser.AND); - } - - public TerminalNode AND(int i) { - return getToken(Python3Parser.AND, i); - } - - public And_testContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_and_test; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAnd_test(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAnd_test(this); - } - } - - public final And_testContext and_test() throws RecognitionException { - And_testContext _localctx = new And_testContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_and_test); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(760); - not_test(); - setState(765); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AND) { - { - { - setState(761); - match(AND); - setState(762); - not_test(); - } - } - setState(767); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Not_testContext extends ParserRuleContext { - public TerminalNode NOT() { - return getToken(Python3Parser.NOT, 0); - } - - public Not_testContext not_test() { - return getRuleContext(Not_testContext.class, 0); - } - - public ComparisonContext comparison() { - return getRuleContext(ComparisonContext.class, 0); - } - - public Not_testContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_not_test; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterNot_test(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitNot_test(this); - } - } - - public final Not_testContext not_test() throws RecognitionException { - Not_testContext _localctx = new Not_testContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_not_test); - try { - setState(771); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NOT: - enterOuterAlt(_localctx, 1); - { - setState(768); - match(NOT); - setState(769); - not_test(); - } - break; - case STRING: - case NUMBER: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(770); - comparison(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ComparisonContext extends ParserRuleContext { - public List expr() { - return getRuleContexts(ExprContext.class); - } - - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class, i); - } - - public List comp_op() { - return getRuleContexts(Comp_opContext.class); - } - - public Comp_opContext comp_op(int i) { - return getRuleContext(Comp_opContext.class, i); - } - - public ComparisonContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_comparison; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterComparison(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitComparison(this); - } - } - - public final ComparisonContext comparison() throws RecognitionException { - ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_comparison); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(773); - expr(); - setState(779); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (IN - 18)) | (1L << (NOT - 18)) | (1L << (IS - 18)) | (1L << (LESS_THAN - 18)) | (1L << (GREATER_THAN - 18)) | (1L << (EQUALS - 18)) | (1L << (GT_EQ - 18)) | (1L << (LT_EQ - 18)) | (1L << (NOT_EQ_1 - 18)) | (1L << (NOT_EQ_2 - 18)))) != 0)) { - { - { - setState(774); - comp_op(); - setState(775); - expr(); - } - } - setState(781); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Comp_opContext extends ParserRuleContext { - public TerminalNode LESS_THAN() { - return getToken(Python3Parser.LESS_THAN, 0); - } - - public TerminalNode GREATER_THAN() { - return getToken(Python3Parser.GREATER_THAN, 0); - } - - public TerminalNode EQUALS() { - return getToken(Python3Parser.EQUALS, 0); - } - - public TerminalNode GT_EQ() { - return getToken(Python3Parser.GT_EQ, 0); - } - - public TerminalNode LT_EQ() { - return getToken(Python3Parser.LT_EQ, 0); - } - - public TerminalNode NOT_EQ_1() { - return getToken(Python3Parser.NOT_EQ_1, 0); - } - - public TerminalNode NOT_EQ_2() { - return getToken(Python3Parser.NOT_EQ_2, 0); - } - - public TerminalNode IN() { - return getToken(Python3Parser.IN, 0); - } - - public TerminalNode NOT() { - return getToken(Python3Parser.NOT, 0); - } - - public TerminalNode IS() { - return getToken(Python3Parser.IS, 0); - } - - public Comp_opContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_comp_op; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterComp_op(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitComp_op(this); - } - } - - public final Comp_opContext comp_op() throws RecognitionException { - Comp_opContext _localctx = new Comp_opContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_comp_op); - try { - setState(795); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 107, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(782); - match(LESS_THAN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(783); - match(GREATER_THAN); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(784); - match(EQUALS); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(785); - match(GT_EQ); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(786); - match(LT_EQ); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(787); - match(NOT_EQ_1); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(788); - match(NOT_EQ_2); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(789); - match(IN); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(790); - match(NOT); - setState(791); - match(IN); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(792); - match(IS); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(793); - match(IS); - setState(794); - match(NOT); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Star_exprContext extends ParserRuleContext { - public TerminalNode STAR() { - return getToken(Python3Parser.STAR, 0); - } - - public ExprContext expr() { - return getRuleContext(ExprContext.class, 0); - } - - public Star_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_star_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterStar_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitStar_expr(this); - } - } - - public final Star_exprContext star_expr() throws RecognitionException { - Star_exprContext _localctx = new Star_exprContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_star_expr); - try { - enterOuterAlt(_localctx, 1); - { - setState(797); - match(STAR); - setState(798); - expr(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExprContext extends ParserRuleContext { - public List xor_expr() { - return getRuleContexts(Xor_exprContext.class); - } - - public Xor_exprContext xor_expr(int i) { - return getRuleContext(Xor_exprContext.class, i); - } - - public List OR_OP() { - return getTokens(Python3Parser.OR_OP); - } - - public TerminalNode OR_OP(int i) { - return getToken(Python3Parser.OR_OP, i); - } - - public ExprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterExpr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitExpr(this); - } - } - - public final ExprContext expr() throws RecognitionException { - ExprContext _localctx = new ExprContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(800); - xor_expr(); - setState(805); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == OR_OP) { - { - { - setState(801); - match(OR_OP); - setState(802); - xor_expr(); - } - } - setState(807); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Xor_exprContext extends ParserRuleContext { - public List and_expr() { - return getRuleContexts(And_exprContext.class); - } - - public And_exprContext and_expr(int i) { - return getRuleContext(And_exprContext.class, i); - } - - public List XOR() { - return getTokens(Python3Parser.XOR); - } - - public TerminalNode XOR(int i) { - return getToken(Python3Parser.XOR, i); - } - - public Xor_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_xor_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterXor_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitXor_expr(this); - } - } - - public final Xor_exprContext xor_expr() throws RecognitionException { - Xor_exprContext _localctx = new Xor_exprContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_xor_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(808); - and_expr(); - setState(813); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == XOR) { - { - { - setState(809); - match(XOR); - setState(810); - and_expr(); - } - } - setState(815); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class And_exprContext extends ParserRuleContext { - public List shift_expr() { - return getRuleContexts(Shift_exprContext.class); - } - - public Shift_exprContext shift_expr(int i) { - return getRuleContext(Shift_exprContext.class, i); - } - - public List AND_OP() { - return getTokens(Python3Parser.AND_OP); - } - - public TerminalNode AND_OP(int i) { - return getToken(Python3Parser.AND_OP, i); - } - - public And_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_and_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAnd_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAnd_expr(this); - } - } - - public final And_exprContext and_expr() throws RecognitionException { - And_exprContext _localctx = new And_exprContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_and_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(816); - shift_expr(); - setState(821); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AND_OP) { - { - { - setState(817); - match(AND_OP); - setState(818); - shift_expr(); - } - } - setState(823); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Shift_exprContext extends ParserRuleContext { - public List arith_expr() { - return getRuleContexts(Arith_exprContext.class); - } - - public Arith_exprContext arith_expr(int i) { - return getRuleContext(Arith_exprContext.class, i); - } - - public List LEFT_SHIFT() { - return getTokens(Python3Parser.LEFT_SHIFT); - } - - public TerminalNode LEFT_SHIFT(int i) { - return getToken(Python3Parser.LEFT_SHIFT, i); - } - - public List RIGHT_SHIFT() { - return getTokens(Python3Parser.RIGHT_SHIFT); - } - - public TerminalNode RIGHT_SHIFT(int i) { - return getToken(Python3Parser.RIGHT_SHIFT, i); - } - - public Shift_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_shift_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterShift_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitShift_expr(this); - } - } - - public final Shift_exprContext shift_expr() throws RecognitionException { - Shift_exprContext _localctx = new Shift_exprContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_shift_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(824); - arith_expr(); - setState(829); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LEFT_SHIFT || _la == RIGHT_SHIFT) { - { - { - setState(825); - _la = _input.LA(1); - if (!(_la == LEFT_SHIFT || _la == RIGHT_SHIFT)) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(826); - arith_expr(); - } - } - setState(831); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Arith_exprContext extends ParserRuleContext { - public List term() { - return getRuleContexts(TermContext.class); - } - - public TermContext term(int i) { - return getRuleContext(TermContext.class, i); - } - - public List ADD() { - return getTokens(Python3Parser.ADD); - } - - public TerminalNode ADD(int i) { - return getToken(Python3Parser.ADD, i); - } - - public List MINUS() { - return getTokens(Python3Parser.MINUS); - } - - public TerminalNode MINUS(int i) { - return getToken(Python3Parser.MINUS, i); - } - - public Arith_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arith_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterArith_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitArith_expr(this); - } - } - - public final Arith_exprContext arith_expr() throws RecognitionException { - Arith_exprContext _localctx = new Arith_exprContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_arith_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(832); - term(); - setState(837); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == ADD || _la == MINUS) { - { - { - setState(833); - _la = _input.LA(1); - if (!(_la == ADD || _la == MINUS)) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(834); - term(); - } - } - setState(839); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TermContext extends ParserRuleContext { - public List factor() { - return getRuleContexts(FactorContext.class); - } - - public FactorContext factor(int i) { - return getRuleContext(FactorContext.class, i); - } - - public List STAR() { - return getTokens(Python3Parser.STAR); - } - - public TerminalNode STAR(int i) { - return getToken(Python3Parser.STAR, i); - } - - public List AT() { - return getTokens(Python3Parser.AT); - } - - public TerminalNode AT(int i) { - return getToken(Python3Parser.AT, i); - } - - public List DIV() { - return getTokens(Python3Parser.DIV); - } - - public TerminalNode DIV(int i) { - return getToken(Python3Parser.DIV, i); - } - - public List MOD() { - return getTokens(Python3Parser.MOD); - } - - public TerminalNode MOD(int i) { - return getToken(Python3Parser.MOD, i); - } - - public List IDIV() { - return getTokens(Python3Parser.IDIV); - } - - public TerminalNode IDIV(int i) { - return getToken(Python3Parser.IDIV, i); - } - - public TermContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_term; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTerm(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTerm(this); - } - } - - public final TermContext term() throws RecognitionException { - TermContext _localctx = new TermContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_term); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(840); - factor(); - setState(845); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 0)) { - { - { - setState(841); - _la = _input.LA(1); - if (!(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 0))) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(842); - factor(); - } - } - setState(847); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class FactorContext extends ParserRuleContext { - public FactorContext factor() { - return getRuleContext(FactorContext.class, 0); - } - - public TerminalNode ADD() { - return getToken(Python3Parser.ADD, 0); - } - - public TerminalNode MINUS() { - return getToken(Python3Parser.MINUS, 0); - } - - public TerminalNode NOT_OP() { - return getToken(Python3Parser.NOT_OP, 0); - } - - public PowerContext power() { - return getRuleContext(PowerContext.class, 0); - } - - public FactorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_factor; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterFactor(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitFactor(this); - } - } - - public final FactorContext factor() throws RecognitionException { - FactorContext _localctx = new FactorContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_factor); - int _la; - try { - setState(851); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ADD: - case MINUS: - case NOT_OP: - enterOuterAlt(_localctx, 1); - { - setState(848); - _la = _input.LA(1); - if (!(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)))) != 0))) { - _errHandler.recoverInline(this); - } else { - if (_input.LA(1) == Token.EOF) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(849); - factor(); - } - break; - case STRING: - case NUMBER: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(850); - power(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class PowerContext extends ParserRuleContext { - public Atom_exprContext atom_expr() { - return getRuleContext(Atom_exprContext.class, 0); - } - - public TerminalNode POWER() { - return getToken(Python3Parser.POWER, 0); - } - - public FactorContext factor() { - return getRuleContext(FactorContext.class, 0); - } - - public PowerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_power; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterPower(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitPower(this); - } - } - - public final PowerContext power() throws RecognitionException { - PowerContext _localctx = new PowerContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_power); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(853); - atom_expr(); - setState(856); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == POWER) { - { - setState(854); - match(POWER); - setState(855); - factor(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Atom_exprContext extends ParserRuleContext { - public AtomContext atom() { - return getRuleContext(AtomContext.class, 0); - } - - public TerminalNode AWAIT() { - return getToken(Python3Parser.AWAIT, 0); - } - - public List trailer() { - return getRuleContexts(TrailerContext.class); - } - - public TrailerContext trailer(int i) { - return getRuleContext(TrailerContext.class, i); - } - - public Atom_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_atom_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAtom_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAtom_expr(this); - } - } - - public final Atom_exprContext atom_expr() throws RecognitionException { - Atom_exprContext _localctx = new Atom_exprContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_atom_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(859); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == AWAIT) { - { - setState(858); - match(AWAIT); - } - } - - setState(861); - atom(); - setState(865); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DOT) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0)) { - { - { - setState(862); - trailer(); - } - } - setState(867); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class AtomContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public TerminalNode OPEN_BRACK() { - return getToken(Python3Parser.OPEN_BRACK, 0); - } - - public TerminalNode CLOSE_BRACK() { - return getToken(Python3Parser.CLOSE_BRACK, 0); - } - - public TerminalNode OPEN_BRACE() { - return getToken(Python3Parser.OPEN_BRACE, 0); - } - - public TerminalNode CLOSE_BRACE() { - return getToken(Python3Parser.CLOSE_BRACE, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public TerminalNode NUMBER() { - return getToken(Python3Parser.NUMBER, 0); - } - - public TerminalNode ELLIPSIS() { - return getToken(Python3Parser.ELLIPSIS, 0); - } - - public TerminalNode NONE() { - return getToken(Python3Parser.NONE, 0); - } - - public TerminalNode TRUE() { - return getToken(Python3Parser.TRUE, 0); - } - - public TerminalNode FALSE() { - return getToken(Python3Parser.FALSE, 0); - } - - public Yield_exprContext yield_expr() { - return getRuleContext(Yield_exprContext.class, 0); - } - - public Testlist_compContext testlist_comp() { - return getRuleContext(Testlist_compContext.class, 0); - } - - public DictorsetmakerContext dictorsetmaker() { - return getRuleContext(DictorsetmakerContext.class, 0); - } - - public List STRING() { - return getTokens(Python3Parser.STRING); - } - - public TerminalNode STRING(int i) { - return getToken(Python3Parser.STRING, i); - } - - public AtomContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_atom; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterAtom(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitAtom(this); - } - } - - public final AtomContext atom() throws RecognitionException { - AtomContext _localctx = new AtomContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_atom); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(895); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_PAREN: { - setState(868); - match(OPEN_PAREN); - setState(871); - _errHandler.sync(this); - switch (_input.LA(1)) { - case YIELD: { - setState(869); - yield_expr(); - } - break; - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case STAR: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(870); - testlist_comp(); - } - break; - case CLOSE_PAREN: - break; - default: - break; - } - setState(873); - match(CLOSE_PAREN); - } - break; - case OPEN_BRACK: { - setState(874); - match(OPEN_BRACK); - setState(876); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(875); - testlist_comp(); - } - } - - setState(878); - match(CLOSE_BRACK); - } - break; - case OPEN_BRACE: { - setState(879); - match(OPEN_BRACE); - setState(881); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(880); - dictorsetmaker(); - } - } - - setState(883); - match(CLOSE_BRACE); - } - break; - case NAME: { - setState(884); - match(NAME); - } - break; - case NUMBER: { - setState(885); - match(NUMBER); - } - break; - case STRING: { - setState(887); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(886); - match(STRING); - } - } - setState(889); - _errHandler.sync(this); - _la = _input.LA(1); - } while (_la == STRING); - } - break; - case ELLIPSIS: { - setState(891); - match(ELLIPSIS); - } - break; - case NONE: { - setState(892); - match(NONE); - } - break; - case TRUE: { - setState(893); - match(TRUE); - } - break; - case FALSE: { - setState(894); - match(FALSE); - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Testlist_compContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List star_expr() { - return getRuleContexts(Star_exprContext.class); - } - - public Star_exprContext star_expr(int i) { - return getRuleContext(Star_exprContext.class, i); - } - - public Comp_forContext comp_for() { - return getRuleContext(Comp_forContext.class, 0); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public Testlist_compContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_testlist_comp; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTestlist_comp(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTestlist_comp(this); - } - } - - public final Testlist_compContext testlist_comp() throws RecognitionException { - Testlist_compContext _localctx = new Testlist_compContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_testlist_comp); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(899); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(897); - test(); - } - break; - case STAR: { - setState(898); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(915); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - case ASYNC: { - setState(901); - comp_for(); - } - break; - case CLOSE_PAREN: - case COMMA: - case CLOSE_BRACK: { - setState(909); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 125, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(902); - match(COMMA); - setState(905); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(903); - test(); - } - break; - case STAR: { - setState(904); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - setState(911); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 125, _ctx); - } - setState(913); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(912); - match(COMMA); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TrailerContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public ArglistContext arglist() { - return getRuleContext(ArglistContext.class, 0); - } - - public TerminalNode OPEN_BRACK() { - return getToken(Python3Parser.OPEN_BRACK, 0); - } - - public SubscriptlistContext subscriptlist() { - return getRuleContext(SubscriptlistContext.class, 0); - } - - public TerminalNode CLOSE_BRACK() { - return getToken(Python3Parser.CLOSE_BRACK, 0); - } - - public TerminalNode DOT() { - return getToken(Python3Parser.DOT, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public TrailerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_trailer; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTrailer(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTrailer(this); - } - } - - public final TrailerContext trailer() throws RecognitionException { - TrailerContext _localctx = new TrailerContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_trailer); - int _la; - try { - setState(928); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_PAREN: - enterOuterAlt(_localctx, 1); - { - setState(917); - match(OPEN_PAREN); - setState(919); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(918); - arglist(); - } - } - - setState(921); - match(CLOSE_PAREN); - } - break; - case OPEN_BRACK: - enterOuterAlt(_localctx, 2); - { - setState(922); - match(OPEN_BRACK); - setState(923); - subscriptlist(); - setState(924); - match(CLOSE_BRACK); - } - break; - case DOT: - enterOuterAlt(_localctx, 3); - { - setState(926); - match(DOT); - setState(927); - match(NAME); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SubscriptlistContext extends ParserRuleContext { - public List subscript() { - return getRuleContexts(SubscriptContext.class); - } - - public SubscriptContext subscript(int i) { - return getRuleContext(SubscriptContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public SubscriptlistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_subscriptlist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSubscriptlist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSubscriptlist(this); - } - } - - public final SubscriptlistContext subscriptlist() throws RecognitionException { - SubscriptlistContext _localctx = new SubscriptlistContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_subscriptlist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(930); - subscript(); - setState(935); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 130, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(931); - match(COMMA); - setState(932); - subscript(); - } - } - } - setState(937); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 130, _ctx); - } - setState(939); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(938); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SubscriptContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public SliceopContext sliceop() { - return getRuleContext(SliceopContext.class, 0); - } - - public SubscriptContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_subscript; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSubscript(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSubscript(this); - } - } - - public final SubscriptContext subscript() throws RecognitionException { - SubscriptContext _localctx = new SubscriptContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_subscript); - int _la; - try { - setState(952); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 135, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(941); - test(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(943); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(942); - test(); - } - } - - setState(945); - match(COLON); - setState(947); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(946); - test(); - } - } - - setState(950); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COLON) { - { - setState(949); - sliceop(); - } - } - - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class SliceopContext extends ParserRuleContext { - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public SliceopContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_sliceop; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterSliceop(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitSliceop(this); - } - } - - public final SliceopContext sliceop() throws RecognitionException { - SliceopContext _localctx = new SliceopContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_sliceop); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(954); - match(COLON); - setState(956); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(955); - test(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ExprlistContext extends ParserRuleContext { - public List expr() { - return getRuleContexts(ExprContext.class); - } - - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class, i); - } - - public List star_expr() { - return getRuleContexts(Star_exprContext.class); - } - - public Star_exprContext star_expr(int i) { - return getRuleContext(Star_exprContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public ExprlistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_exprlist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterExprlist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitExprlist(this); - } - } - - public final ExprlistContext exprlist() throws RecognitionException { - ExprlistContext _localctx = new ExprlistContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_exprlist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(960); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(958); - expr(); - } - break; - case STAR: { - setState(959); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(969); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 139, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(962); - match(COMMA); - setState(965); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(963); - expr(); - } - break; - case STAR: { - setState(964); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - setState(971); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 139, _ctx); - } - setState(973); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(972); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class TestlistContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public TestlistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_testlist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterTestlist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitTestlist(this); - } - } - - public final TestlistContext testlist() throws RecognitionException { - TestlistContext _localctx = new TestlistContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_testlist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(975); - test(); - setState(980); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 141, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(976); - match(COMMA); - setState(977); - test(); - } - } - } - setState(982); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 141, _ctx); - } - setState(984); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(983); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class DictorsetmakerContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public List COLON() { - return getTokens(Python3Parser.COLON); - } - - public TerminalNode COLON(int i) { - return getToken(Python3Parser.COLON, i); - } - - public List POWER() { - return getTokens(Python3Parser.POWER); - } - - public TerminalNode POWER(int i) { - return getToken(Python3Parser.POWER, i); - } - - public List expr() { - return getRuleContexts(ExprContext.class); - } - - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class, i); - } - - public Comp_forContext comp_for() { - return getRuleContext(Comp_forContext.class, 0); - } - - public List star_expr() { - return getRuleContexts(Star_exprContext.class); - } - - public Star_exprContext star_expr(int i) { - return getRuleContext(Star_exprContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public DictorsetmakerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_dictorsetmaker; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterDictorsetmaker(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitDictorsetmaker(this); - } - } - - public final DictorsetmakerContext dictorsetmaker() throws RecognitionException { - DictorsetmakerContext _localctx = new DictorsetmakerContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_dictorsetmaker); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1034); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 153, _ctx)) { - case 1: { - { - setState(992); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(986); - test(); - setState(987); - match(COLON); - setState(988); - test(); - } - break; - case POWER: { - setState(990); - match(POWER); - setState(991); - expr(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1012); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - case ASYNC: { - setState(994); - comp_for(); - } - break; - case COMMA: - case CLOSE_BRACE: { - setState(1006); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 145, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(995); - match(COMMA); - setState(1002); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(996); - test(); - setState(997); - match(COLON); - setState(998); - test(); - } - break; - case POWER: { - setState(1000); - match(POWER); - setState(1001); - expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - setState(1008); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 145, _ctx); - } - setState(1010); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1009); - match(COMMA); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } - break; - case 2: { - { - setState(1016); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(1014); - test(); - } - break; - case STAR: { - setState(1015); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1032); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - case ASYNC: { - setState(1018); - comp_for(); - } - break; - case COMMA: - case CLOSE_BRACE: { - setState(1026); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 150, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1019); - match(COMMA); - setState(1022); - _errHandler.sync(this); - switch (_input.LA(1)) { - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: { - setState(1020); - test(); - } - break; - case STAR: { - setState(1021); - star_expr(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - } - setState(1028); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 150, _ctx); - } - setState(1030); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1029); - match(COMMA); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ClassdefContext extends ParserRuleContext { - public TerminalNode CLASS() { - return getToken(Python3Parser.CLASS, 0); - } - - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public TerminalNode COLON() { - return getToken(Python3Parser.COLON, 0); - } - - public SuiteContext suite() { - return getRuleContext(SuiteContext.class, 0); - } - - public TerminalNode OPEN_PAREN() { - return getToken(Python3Parser.OPEN_PAREN, 0); - } - - public TerminalNode CLOSE_PAREN() { - return getToken(Python3Parser.CLOSE_PAREN, 0); - } - - public ArglistContext arglist() { - return getRuleContext(ArglistContext.class, 0); - } - - public ClassdefContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classdef; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterClassdef(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitClassdef(this); - } - } - - public final ClassdefContext classdef() throws RecognitionException { - ClassdefContext _localctx = new ClassdefContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_classdef); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1036); - match(CLASS); - setState(1037); - match(NAME); - setState(1043); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == OPEN_PAREN) { - { - setState(1038); - match(OPEN_PAREN); - setState(1040); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(1039); - arglist(); - } - } - - setState(1042); - match(CLOSE_PAREN); - } - } - - setState(1045); - match(COLON); - setState(1046); - suite(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArglistContext extends ParserRuleContext { - public List argument() { - return getRuleContexts(ArgumentContext.class); - } - - public ArgumentContext argument(int i) { - return getRuleContext(ArgumentContext.class, i); - } - - public List COMMA() { - return getTokens(Python3Parser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(Python3Parser.COMMA, i); - } - - public ArglistContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arglist; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterArglist(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitArglist(this); - } - } - - public final ArglistContext arglist() throws RecognitionException { - ArglistContext _localctx = new ArglistContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_arglist); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1048); - argument(); - setState(1053); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 156, _ctx); - while (_alt != 2 && _alt != ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1049); - match(COMMA); - setState(1050); - argument(); - } - } - } - setState(1055); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 156, _ctx); - } - setState(1057); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == COMMA) { - { - setState(1056); - match(COMMA); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class ArgumentContext extends ParserRuleContext { - public List test() { - return getRuleContexts(TestContext.class); - } - - public TestContext test(int i) { - return getRuleContext(TestContext.class, i); - } - - public TerminalNode ASSIGN() { - return getToken(Python3Parser.ASSIGN, 0); - } - - public TerminalNode POWER() { - return getToken(Python3Parser.POWER, 0); - } - - public TerminalNode STAR() { - return getToken(Python3Parser.STAR, 0); - } - - public Comp_forContext comp_for() { - return getRuleContext(Comp_forContext.class, 0); - } - - public ArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_argument; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterArgument(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitArgument(this); - } - } - - public final ArgumentContext argument() throws RecognitionException { - ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_argument); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1071); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 159, _ctx)) { - case 1: { - setState(1059); - test(); - setState(1061); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == FOR || _la == ASYNC) { - { - setState(1060); - comp_for(); - } - } - - } - break; - case 2: { - setState(1063); - test(); - setState(1064); - match(ASSIGN); - setState(1065); - test(); - } - break; - case 3: { - setState(1067); - match(POWER); - setState(1068); - test(); - } - break; - case 4: { - setState(1069); - match(STAR); - setState(1070); - test(); - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Comp_iterContext extends ParserRuleContext { - public Comp_forContext comp_for() { - return getRuleContext(Comp_forContext.class, 0); - } - - public Comp_ifContext comp_if() { - return getRuleContext(Comp_ifContext.class, 0); - } - - public Comp_iterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_comp_iter; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterComp_iter(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitComp_iter(this); - } - } - - public final Comp_iterContext comp_iter() throws RecognitionException { - Comp_iterContext _localctx = new Comp_iterContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_comp_iter); - try { - setState(1075); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - case ASYNC: - enterOuterAlt(_localctx, 1); - { - setState(1073); - comp_for(); - } - break; - case IF: - enterOuterAlt(_localctx, 2); - { - setState(1074); - comp_if(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Comp_forContext extends ParserRuleContext { - public TerminalNode FOR() { - return getToken(Python3Parser.FOR, 0); - } - - public ExprlistContext exprlist() { - return getRuleContext(ExprlistContext.class, 0); - } - - public TerminalNode IN() { - return getToken(Python3Parser.IN, 0); - } - - public Or_testContext or_test() { - return getRuleContext(Or_testContext.class, 0); - } - - public TerminalNode ASYNC() { - return getToken(Python3Parser.ASYNC, 0); - } - - public Comp_iterContext comp_iter() { - return getRuleContext(Comp_iterContext.class, 0); - } - - public Comp_forContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_comp_for; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterComp_for(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitComp_for(this); - } - } - - public final Comp_forContext comp_for() throws RecognitionException { - Comp_forContext _localctx = new Comp_forContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_comp_for); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1078); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == ASYNC) { - { - setState(1077); - match(ASYNC); - } - } - - setState(1080); - match(FOR); - setState(1081); - exprlist(); - setState(1082); - match(IN); - setState(1083); - or_test(); - setState(1085); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FOR) | (1L << ASYNC))) != 0)) { - { - setState(1084); - comp_iter(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Comp_ifContext extends ParserRuleContext { - public TerminalNode IF() { - return getToken(Python3Parser.IF, 0); - } - - public Test_nocondContext test_nocond() { - return getRuleContext(Test_nocondContext.class, 0); - } - - public Comp_iterContext comp_iter() { - return getRuleContext(Comp_iterContext.class, 0); - } - - public Comp_ifContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_comp_if; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterComp_if(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitComp_if(this); - } - } - - public final Comp_ifContext comp_if() throws RecognitionException { - Comp_ifContext _localctx = new Comp_ifContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_comp_if); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1087); - match(IF); - setState(1088); - test_nocond(); - setState(1090); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FOR) | (1L << ASYNC))) != 0)) { - { - setState(1089); - comp_iter(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Encoding_declContext extends ParserRuleContext { - public TerminalNode NAME() { - return getToken(Python3Parser.NAME, 0); - } - - public Encoding_declContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_encoding_decl; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterEncoding_decl(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitEncoding_decl(this); - } - } - - public final Encoding_declContext encoding_decl() throws RecognitionException { - Encoding_declContext _localctx = new Encoding_declContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_encoding_decl); - try { - enterOuterAlt(_localctx, 1); - { - setState(1092); - match(NAME); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Yield_exprContext extends ParserRuleContext { - public TerminalNode YIELD() { - return getToken(Python3Parser.YIELD, 0); - } - - public Yield_argContext yield_arg() { - return getRuleContext(Yield_argContext.class, 0); - } - - public Yield_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_yield_expr; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterYield_expr(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitYield_expr(this); - } - } - - public final Yield_exprContext yield_expr() throws RecognitionException { - Yield_exprContext _localctx = new Yield_exprContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_yield_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1094); - match(YIELD); - setState(1096); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << FROM) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { - { - setState(1095); - yield_arg(); - } - } - - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static class Yield_argContext extends ParserRuleContext { - public TerminalNode FROM() { - return getToken(Python3Parser.FROM, 0); - } - - public TestContext test() { - return getRuleContext(TestContext.class, 0); - } - - public TestlistContext testlist() { - return getRuleContext(TestlistContext.class, 0); - } - - public Yield_argContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_yield_arg; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).enterYield_arg(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof Python3Listener) ((Python3Listener) listener).exitYield_arg(this); - } - } - - public final Yield_argContext yield_arg() throws RecognitionException { - Yield_argContext _localctx = new Yield_argContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_yield_arg); - try { - setState(1101); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FROM: - enterOuterAlt(_localctx, 1); - { - setState(1098); - match(FROM); - setState(1099); - test(); - } - break; - case STRING: - case NUMBER: - case LAMBDA: - case NOT: - case NONE: - case TRUE: - case FALSE: - case AWAIT: - case NAME: - case ELLIPSIS: - case OPEN_PAREN: - case OPEN_BRACK: - case ADD: - case MINUS: - case NOT_OP: - case OPEN_BRACE: - enterOuterAlt(_localctx, 2); - { - setState(1100); - testlist(); - } - break; - default: - throw new NoViableAltException(this); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; - } - - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3e\u0452\4\2\t\2\4" + - "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t" + - "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22" + - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31" + - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!" + - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4" + - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t" + - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=" + - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I" + - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT" + - "\4U\tU\4V\tV\4W\tW\3\2\3\2\3\2\3\2\3\2\5\2\u00b4\n\2\3\3\3\3\7\3\u00b8" + - "\n\3\f\3\16\3\u00bb\13\3\3\3\3\3\3\4\3\4\7\4\u00c1\n\4\f\4\16\4\u00c4" + - "\13\4\3\4\3\4\3\5\3\5\3\5\3\5\5\5\u00cc\n\5\3\5\5\5\u00cf\n\5\3\5\3\5" + - "\3\6\6\6\u00d4\n\6\r\6\16\6\u00d5\3\7\3\7\3\7\3\7\5\7\u00dc\n\7\3\b\3" + - "\b\3\b\3\t\3\t\3\t\3\t\3\t\5\t\u00e6\n\t\3\t\3\t\3\t\3\n\3\n\5\n\u00ed" + - "\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u00f4\n\13\3\13\3\13\3\13\3\13\5\13\u00fa" + - "\n\13\7\13\u00fc\n\13\f\13\16\13\u00ff\13\13\3\13\3\13\3\13\5\13\u0104" + - "\n\13\3\13\3\13\3\13\3\13\5\13\u010a\n\13\7\13\u010c\n\13\f\13\16\13\u010f" + - "\13\13\3\13\3\13\3\13\3\13\5\13\u0115\n\13\5\13\u0117\n\13\5\13\u0119" + - "\n\13\3\13\3\13\3\13\5\13\u011e\n\13\5\13\u0120\n\13\5\13\u0122\n\13\3" + - "\13\3\13\5\13\u0126\n\13\3\13\3\13\3\13\3\13\5\13\u012c\n\13\7\13\u012e" + - "\n\13\f\13\16\13\u0131\13\13\3\13\3\13\3\13\3\13\5\13\u0137\n\13\5\13" + - "\u0139\n\13\5\13\u013b\n\13\3\13\3\13\3\13\5\13\u0140\n\13\5\13\u0142" + - "\n\13\3\f\3\f\3\f\5\f\u0147\n\f\3\r\3\r\3\r\5\r\u014c\n\r\3\r\3\r\3\r" + - "\3\r\5\r\u0152\n\r\7\r\u0154\n\r\f\r\16\r\u0157\13\r\3\r\3\r\3\r\5\r\u015c" + - "\n\r\3\r\3\r\3\r\3\r\5\r\u0162\n\r\7\r\u0164\n\r\f\r\16\r\u0167\13\r\3" + - "\r\3\r\3\r\3\r\5\r\u016d\n\r\5\r\u016f\n\r\5\r\u0171\n\r\3\r\3\r\3\r\5" + - "\r\u0176\n\r\5\r\u0178\n\r\5\r\u017a\n\r\3\r\3\r\5\r\u017e\n\r\3\r\3\r" + - "\3\r\3\r\5\r\u0184\n\r\7\r\u0186\n\r\f\r\16\r\u0189\13\r\3\r\3\r\3\r\3" + - "\r\5\r\u018f\n\r\5\r\u0191\n\r\5\r\u0193\n\r\3\r\3\r\3\r\5\r\u0198\n\r" + - "\5\r\u019a\n\r\3\16\3\16\3\17\3\17\5\17\u01a0\n\17\3\20\3\20\3\20\7\20" + - "\u01a5\n\20\f\20\16\20\u01a8\13\20\3\20\5\20\u01ab\n\20\3\20\3\20\3\21" + - "\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u01b7\n\21\3\22\3\22\3\22\3\22" + - "\3\22\5\22\u01be\n\22\3\22\3\22\3\22\5\22\u01c3\n\22\7\22\u01c5\n\22\f" + - "\22\16\22\u01c8\13\22\5\22\u01ca\n\22\3\23\3\23\3\23\3\23\5\23\u01d0\n" + - "\23\3\24\3\24\5\24\u01d4\n\24\3\24\3\24\3\24\5\24\u01d9\n\24\7\24\u01db" + - "\n\24\f\24\16\24\u01de\13\24\3\24\5\24\u01e1\n\24\3\25\3\25\3\26\3\26" + - "\3\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\5\30\u01ef\n\30\3\31\3\31\3\32" + - "\3\32\3\33\3\33\5\33\u01f7\n\33\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u01ff" + - "\n\35\5\35\u0201\n\35\3\36\3\36\5\36\u0205\n\36\3\37\3\37\3\37\3 \3 \7" + - " \u020c\n \f \16 \u020f\13 \3 \3 \6 \u0213\n \r \16 \u0214\5 \u0217\n" + - " \3 \3 \3 \3 \3 \3 \3 \5 \u0220\n \3!\3!\3!\5!\u0225\n!\3\"\3\"\3\"\5" + - "\"\u022a\n\"\3#\3#\3#\7#\u022f\n#\f#\16#\u0232\13#\3#\5#\u0235\n#\3$\3" + - "$\3$\7$\u023a\n$\f$\16$\u023d\13$\3%\3%\3%\7%\u0242\n%\f%\16%\u0245\13" + - "%\3&\3&\3&\3&\7&\u024b\n&\f&\16&\u024e\13&\3\'\3\'\3\'\3\'\7\'\u0254\n" + - "\'\f\'\16\'\u0257\13\'\3(\3(\3(\3(\5(\u025d\n(\3)\3)\3)\3)\3)\3)\3)\3" + - ")\3)\5)\u0268\n)\3*\3*\3*\3*\5*\u026e\n*\3+\3+\3+\3+\3+\3+\3+\3+\3+\7" + - "+\u0279\n+\f+\16+\u027c\13+\3+\3+\3+\5+\u0281\n+\3,\3,\3,\3,\3,\3,\3," + - "\5,\u028a\n,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0295\n-\3.\3.\3.\3.\3.\3." + - "\3.\6.\u029e\n.\r.\16.\u029f\3.\3.\3.\5.\u02a5\n.\3.\3.\3.\5.\u02aa\n" + - ".\3.\3.\3.\5.\u02af\n.\3/\3/\3/\3/\7/\u02b5\n/\f/\16/\u02b8\13/\3/\3/" + - "\3/\3\60\3\60\3\60\5\60\u02c0\n\60\3\61\3\61\3\61\3\61\5\61\u02c6\n\61" + - "\5\61\u02c8\n\61\3\62\3\62\3\62\3\62\6\62\u02ce\n\62\r\62\16\62\u02cf" + - "\3\62\3\62\5\62\u02d4\n\62\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02dc\n" + - "\63\3\63\5\63\u02df\n\63\3\64\3\64\5\64\u02e3\n\64\3\65\3\65\5\65\u02e7" + - "\n\65\3\65\3\65\3\65\3\66\3\66\5\66\u02ee\n\66\3\66\3\66\3\66\3\67\3\67" + - "\3\67\7\67\u02f6\n\67\f\67\16\67\u02f9\13\67\38\38\38\78\u02fe\n8\f8\16" + - "8\u0301\138\39\39\39\59\u0306\n9\3:\3:\3:\3:\7:\u030c\n:\f:\16:\u030f" + - "\13:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\5;\u031e\n;\3<\3<\3<\3=\3" + - "=\3=\7=\u0326\n=\f=\16=\u0329\13=\3>\3>\3>\7>\u032e\n>\f>\16>\u0331\13" + - ">\3?\3?\3?\7?\u0336\n?\f?\16?\u0339\13?\3@\3@\3@\7@\u033e\n@\f@\16@\u0341" + - "\13@\3A\3A\3A\7A\u0346\nA\fA\16A\u0349\13A\3B\3B\3B\7B\u034e\nB\fB\16" + - "B\u0351\13B\3C\3C\3C\5C\u0356\nC\3D\3D\3D\5D\u035b\nD\3E\5E\u035e\nE\3" + - "E\3E\7E\u0362\nE\fE\16E\u0365\13E\3F\3F\3F\5F\u036a\nF\3F\3F\3F\5F\u036f" + - "\nF\3F\3F\3F\5F\u0374\nF\3F\3F\3F\3F\6F\u037a\nF\rF\16F\u037b\3F\3F\3" + - "F\3F\5F\u0382\nF\3G\3G\5G\u0386\nG\3G\3G\3G\3G\5G\u038c\nG\7G\u038e\n" + - "G\fG\16G\u0391\13G\3G\5G\u0394\nG\5G\u0396\nG\3H\3H\5H\u039a\nH\3H\3H" + - "\3H\3H\3H\3H\3H\5H\u03a3\nH\3I\3I\3I\7I\u03a8\nI\fI\16I\u03ab\13I\3I\5" + - "I\u03ae\nI\3J\3J\5J\u03b2\nJ\3J\3J\5J\u03b6\nJ\3J\5J\u03b9\nJ\5J\u03bb" + - "\nJ\3K\3K\5K\u03bf\nK\3L\3L\5L\u03c3\nL\3L\3L\3L\5L\u03c8\nL\7L\u03ca" + - "\nL\fL\16L\u03cd\13L\3L\5L\u03d0\nL\3M\3M\3M\7M\u03d5\nM\fM\16M\u03d8" + - "\13M\3M\5M\u03db\nM\3N\3N\3N\3N\3N\3N\5N\u03e3\nN\3N\3N\3N\3N\3N\3N\3" + - "N\3N\5N\u03ed\nN\7N\u03ef\nN\fN\16N\u03f2\13N\3N\5N\u03f5\nN\5N\u03f7" + - "\nN\3N\3N\5N\u03fb\nN\3N\3N\3N\3N\5N\u0401\nN\7N\u0403\nN\fN\16N\u0406" + - "\13N\3N\5N\u0409\nN\5N\u040b\nN\5N\u040d\nN\3O\3O\3O\3O\5O\u0413\nO\3" + - "O\5O\u0416\nO\3O\3O\3O\3P\3P\3P\7P\u041e\nP\fP\16P\u0421\13P\3P\5P\u0424" + - "\nP\3Q\3Q\5Q\u0428\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0432\nQ\3R\3R\5R\u0436" + - "\nR\3S\5S\u0439\nS\3S\3S\3S\3S\3S\5S\u0440\nS\3T\3T\3T\5T\u0445\nT\3U" + - "\3U\3V\3V\5V\u044b\nV\3W\3W\3W\5W\u0450\nW\3W\2\2X\2\4\6\b\n\f\16\20\22" + - "\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp" + - "rtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094" + - "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac" + - "\2\b\3\2Ua\3\2\63\64\3\2BC\3\2DE\5\2\65\65FHSS\4\2DEII\2\u04cf\2\u00b3" + - "\3\2\2\2\4\u00b9\3\2\2\2\6\u00be\3\2\2\2\b\u00c7\3\2\2\2\n\u00d3\3\2\2" + - "\2\f\u00d7\3\2\2\2\16\u00dd\3\2\2\2\20\u00e0\3\2\2\2\22\u00ea\3\2\2\2" + - "\24\u0141\3\2\2\2\26\u0143\3\2\2\2\30\u0199\3\2\2\2\32\u019b\3\2\2\2\34" + - "\u019f\3\2\2\2\36\u01a1\3\2\2\2 \u01b6\3\2\2\2\"\u01b8\3\2\2\2$\u01cb" + - "\3\2\2\2&\u01d3\3\2\2\2(\u01e2\3\2\2\2*\u01e4\3\2\2\2,\u01e7\3\2\2\2." + - "\u01ee\3\2\2\2\60\u01f0\3\2\2\2\62\u01f2\3\2\2\2\64\u01f4\3\2\2\2\66\u01f8" + - "\3\2\2\28\u01fa\3\2\2\2:\u0204\3\2\2\2<\u0206\3\2\2\2>\u0209\3\2\2\2@" + - "\u0221\3\2\2\2B\u0226\3\2\2\2D\u022b\3\2\2\2F\u0236\3\2\2\2H\u023e\3\2" + - "\2\2J\u0246\3\2\2\2L\u024f\3\2\2\2N\u0258\3\2\2\2P\u0267\3\2\2\2R\u0269" + - "\3\2\2\2T\u026f\3\2\2\2V\u0282\3\2\2\2X\u028b\3\2\2\2Z\u0296\3\2\2\2\\" + - "\u02b0\3\2\2\2^\u02bc\3\2\2\2`\u02c1\3\2\2\2b\u02d3\3\2\2\2d\u02de\3\2" + - "\2\2f\u02e2\3\2\2\2h\u02e4\3\2\2\2j\u02eb\3\2\2\2l\u02f2\3\2\2\2n\u02fa" + - "\3\2\2\2p\u0305\3\2\2\2r\u0307\3\2\2\2t\u031d\3\2\2\2v\u031f\3\2\2\2x" + - "\u0322\3\2\2\2z\u032a\3\2\2\2|\u0332\3\2\2\2~\u033a\3\2\2\2\u0080\u0342" + - "\3\2\2\2\u0082\u034a\3\2\2\2\u0084\u0355\3\2\2\2\u0086\u0357\3\2\2\2\u0088" + - "\u035d\3\2\2\2\u008a\u0381\3\2\2\2\u008c\u0385\3\2\2\2\u008e\u03a2\3\2" + - "\2\2\u0090\u03a4\3\2\2\2\u0092\u03ba\3\2\2\2\u0094\u03bc\3\2\2\2\u0096" + - "\u03c2\3\2\2\2\u0098\u03d1\3\2\2\2\u009a\u040c\3\2\2\2\u009c\u040e\3\2" + - "\2\2\u009e\u041a\3\2\2\2\u00a0\u0431\3\2\2\2\u00a2\u0435\3\2\2\2\u00a4" + - "\u0438\3\2\2\2\u00a6\u0441\3\2\2\2\u00a8\u0446\3\2\2\2\u00aa\u0448\3\2" + - "\2\2\u00ac\u044f\3\2\2\2\u00ae\u00b4\7)\2\2\u00af\u00b4\5\36\20\2\u00b0" + - "\u00b1\5P)\2\u00b1\u00b2\7)\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00ae\3\2\2" + - "\2\u00b3\u00af\3\2\2\2\u00b3\u00b0\3\2\2\2\u00b4\3\3\2\2\2\u00b5\u00b8" + - "\7)\2\2\u00b6\u00b8\5\34\17\2\u00b7\u00b5\3\2\2\2\u00b7\u00b6\3\2\2\2" + - "\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc" + - "\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00bd\7\2\2\3\u00bd\5\3\2\2\2\u00be" + - "\u00c2\5\u0098M\2\u00bf\u00c1\7)\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3" + - "\2\2\2\u00c2\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c5\3\2\2\2\u00c4" + - "\u00c2\3\2\2\2\u00c5\u00c6\7\2\2\3\u00c6\7\3\2\2\2\u00c7\u00c8\7S\2\2" + - "\u00c8\u00ce\5H%\2\u00c9\u00cb\7\66\2\2\u00ca\u00cc\5\u009eP\2\u00cb\u00ca" + - "\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cf\7\67\2\2" + - "\u00ce\u00c9\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d1" + - "\7)\2\2\u00d1\t\3\2\2\2\u00d2\u00d4\5\b\5\2\u00d3\u00d2\3\2\2\2\u00d4" + - "\u00d5\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\13\3\2\2" + - "\2\u00d7\u00db\5\n\6\2\u00d8\u00dc\5\u009cO\2\u00d9\u00dc\5\20\t\2\u00da" + - "\u00dc\5\16\b\2\u00db\u00d8\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00da\3" + - "\2\2\2\u00dc\r\3\2\2\2\u00dd\u00de\7\'\2\2\u00de\u00df\5\20\t\2\u00df" + - "\17\3\2\2\2\u00e0\u00e1\7\6\2\2\u00e1\u00e2\7*\2\2\u00e2\u00e5\5\22\n" + - "\2\u00e3\u00e4\7T\2\2\u00e4\u00e6\5d\63\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6" + - "\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\79\2\2\u00e8\u00e9\5b\62\2\u00e9" + - "\21\3\2\2\2\u00ea\u00ec\7\66\2\2\u00eb\u00ed\5\24\13\2\u00ec\u00eb\3\2" + - "\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\7\67\2\2\u00ef" + - "\23\3\2\2\2\u00f0\u00f3\5\26\f\2\u00f1\u00f2\7<\2\2\u00f2\u00f4\5d\63" + - "\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00fd\3\2\2\2\u00f5\u00f6" + - "\78\2\2\u00f6\u00f9\5\26\f\2\u00f7\u00f8\7<\2\2\u00f8\u00fa\5d\63\2\u00f9" + - "\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\3\2\2\2\u00fb\u00f5\3\2" + - "\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe" + - "\u0121\3\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u011f\78\2\2\u0101\u0103\7\65" + - "\2\2\u0102\u0104\5\26\f\2\u0103\u0102\3\2\2\2\u0103\u0104\3\2\2\2\u0104" + - "\u010d\3\2\2\2\u0105\u0106\78\2\2\u0106\u0109\5\26\f\2\u0107\u0108\7<" + - "\2\2\u0108\u010a\5d\63\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a" + - "\u010c\3\2\2\2\u010b\u0105\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b\3\2" + - "\2\2\u010d\u010e\3\2\2\2\u010e\u0118\3\2\2\2\u010f\u010d\3\2\2\2\u0110" + - "\u0116\78\2\2\u0111\u0112\7;\2\2\u0112\u0114\5\26\f\2\u0113\u0115\78\2" + - "\2\u0114\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0111" + - "\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u0110\3\2\2\2\u0118" + - "\u0119\3\2\2\2\u0119\u0120\3\2\2\2\u011a\u011b\7;\2\2\u011b\u011d\5\26" + - "\f\2\u011c\u011e\78\2\2\u011d\u011c\3\2\2\2\u011d\u011e\3\2\2\2\u011e" + - "\u0120\3\2\2\2\u011f\u0101\3\2\2\2\u011f\u011a\3\2\2\2\u011f\u0120\3\2" + - "\2\2\u0120\u0122\3\2\2\2\u0121\u0100\3\2\2\2\u0121\u0122\3\2\2\2\u0122" + - "\u0142\3\2\2\2\u0123\u0125\7\65\2\2\u0124\u0126\5\26\f\2\u0125\u0124\3" + - "\2\2\2\u0125\u0126\3\2\2\2\u0126\u012f\3\2\2\2\u0127\u0128\78\2\2\u0128" + - "\u012b\5\26\f\2\u0129\u012a\7<\2\2\u012a\u012c\5d\63\2\u012b\u0129\3\2" + - "\2\2\u012b\u012c\3\2\2\2\u012c\u012e\3\2\2\2\u012d\u0127\3\2\2\2\u012e" + - "\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u013a\3\2" + - "\2\2\u0131\u012f\3\2\2\2\u0132\u0138\78\2\2\u0133\u0134\7;\2\2\u0134\u0136" + - "\5\26\f\2\u0135\u0137\78\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137" + - "\u0139\3\2\2\2\u0138\u0133\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2" + - "\2\2\u013a\u0132\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u0142\3\2\2\2\u013c" + - "\u013d\7;\2\2\u013d\u013f\5\26\f\2\u013e\u0140\78\2\2\u013f\u013e\3\2" + - "\2\2\u013f\u0140\3\2\2\2\u0140\u0142\3\2\2\2\u0141\u00f0\3\2\2\2\u0141" + - "\u0123\3\2\2\2\u0141\u013c\3\2\2\2\u0142\25\3\2\2\2\u0143\u0146\7*\2\2" + - "\u0144\u0145\79\2\2\u0145\u0147\5d\63\2\u0146\u0144\3\2\2\2\u0146\u0147" + - "\3\2\2\2\u0147\27\3\2\2\2\u0148\u014b\5\32\16\2\u0149\u014a\7<\2\2\u014a" + - "\u014c\5d\63\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u0155\3\2" + - "\2\2\u014d\u014e\78\2\2\u014e\u0151\5\32\16\2\u014f\u0150\7<\2\2\u0150" + - "\u0152\5d\63\2\u0151\u014f\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2" + - "\2\2\u0153\u014d\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2\u0155" + - "\u0156\3\2\2\2\u0156\u0179\3\2\2\2\u0157\u0155\3\2\2\2\u0158\u0177\78" + - "\2\2\u0159\u015b\7\65\2\2\u015a\u015c\5\32\16\2\u015b\u015a\3\2\2\2\u015b" + - "\u015c\3\2\2\2\u015c\u0165\3\2\2\2\u015d\u015e\78\2\2\u015e\u0161\5\32" + - "\16\2\u015f\u0160\7<\2\2\u0160\u0162\5d\63\2\u0161\u015f\3\2\2\2\u0161" + - "\u0162\3\2\2\2\u0162\u0164\3\2\2\2\u0163\u015d\3\2\2\2\u0164\u0167\3\2" + - "\2\2\u0165\u0163\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u0170\3\2\2\2\u0167" + - "\u0165\3\2\2\2\u0168\u016e\78\2\2\u0169\u016a\7;\2\2\u016a\u016c\5\32" + - "\16\2\u016b\u016d\78\2\2\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d" + - "\u016f\3\2\2\2\u016e\u0169\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2" + - "\2\2\u0170\u0168\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0178\3\2\2\2\u0172" + - "\u0173\7;\2\2\u0173\u0175\5\32\16\2\u0174\u0176\78\2\2\u0175\u0174\3\2" + - "\2\2\u0175\u0176\3\2\2\2\u0176\u0178\3\2\2\2\u0177\u0159\3\2\2\2\u0177" + - "\u0172\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017a\3\2\2\2\u0179\u0158\3\2" + - "\2\2\u0179\u017a\3\2\2\2\u017a\u019a\3\2\2\2\u017b\u017d\7\65\2\2\u017c" + - "\u017e\5\32\16\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0187\3" + - "\2\2\2\u017f\u0180\78\2\2\u0180\u0183\5\32\16\2\u0181\u0182\7<\2\2\u0182" + - "\u0184\5d\63\2\u0183\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0186\3\2" + - "\2\2\u0185\u017f\3\2\2\2\u0186\u0189\3\2\2\2\u0187\u0185\3\2\2\2\u0187" + - "\u0188\3\2\2\2\u0188\u0192\3\2\2\2\u0189\u0187\3\2\2\2\u018a\u0190\78" + - "\2\2\u018b\u018c\7;\2\2\u018c\u018e\5\32\16\2\u018d\u018f\78\2\2\u018e" + - "\u018d\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u018b\3\2" + - "\2\2\u0190\u0191\3\2\2\2\u0191\u0193\3\2\2\2\u0192\u018a\3\2\2\2\u0192" + - "\u0193\3\2\2\2\u0193\u019a\3\2\2\2\u0194\u0195\7;\2\2\u0195\u0197\5\32" + - "\16\2\u0196\u0198\78\2\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198" + - "\u019a\3\2\2\2\u0199\u0148\3\2\2\2\u0199\u017b\3\2\2\2\u0199\u0194\3\2" + - "\2\2\u019a\31\3\2\2\2\u019b\u019c\7*\2\2\u019c\33\3\2\2\2\u019d\u01a0" + - "\5\36\20\2\u019e\u01a0\5P)\2\u019f\u019d\3\2\2\2\u019f\u019e\3\2\2\2\u01a0" + - "\35\3\2\2\2\u01a1\u01a6\5 \21\2\u01a2\u01a3\7:\2\2\u01a3\u01a5\5 \21\2" + - "\u01a4\u01a2\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7" + - "\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a9\u01ab\7:\2\2\u01aa" + - "\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\7)" + - "\2\2\u01ad\37\3\2\2\2\u01ae\u01b7\5\"\22\2\u01af\u01b7\5*\26\2\u01b0\u01b7" + - "\5,\27\2\u01b1\u01b7\5.\30\2\u01b2\u01b7\5:\36\2\u01b3\u01b7\5J&\2\u01b4" + - "\u01b7\5L\'\2\u01b5\u01b7\5N(\2\u01b6\u01ae\3\2\2\2\u01b6\u01af\3\2\2" + - "\2\u01b6\u01b0\3\2\2\2\u01b6\u01b1\3\2\2\2\u01b6\u01b2\3\2\2\2\u01b6\u01b3" + - "\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b5\3\2\2\2\u01b7!\3\2\2\2\u01b8" + - "\u01c9\5&\24\2\u01b9\u01ca\5$\23\2\u01ba\u01bd\5(\25\2\u01bb\u01be\5\u00aa" + - "V\2\u01bc\u01be\5\u0098M\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be" + - "\u01ca\3\2\2\2\u01bf\u01c2\7<\2\2\u01c0\u01c3\5\u00aaV\2\u01c1\u01c3\5" + - "&\24\2\u01c2\u01c0\3\2\2\2\u01c2\u01c1\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4" + - "\u01bf\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2" + - "\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01b9\3\2\2\2\u01c9" + - "\u01ba\3\2\2\2\u01c9\u01c6\3\2\2\2\u01ca#\3\2\2\2\u01cb\u01cc\79\2\2\u01cc" + - "\u01cf\5d\63\2\u01cd\u01ce\7<\2\2\u01ce\u01d0\5d\63\2\u01cf\u01cd\3\2" + - "\2\2\u01cf\u01d0\3\2\2\2\u01d0%\3\2\2\2\u01d1\u01d4\5d\63\2\u01d2\u01d4" + - "\5v<\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2\3\2\2\2\u01d4\u01dc\3\2\2\2\u01d5" + - "\u01d8\78\2\2\u01d6\u01d9\5d\63\2\u01d7\u01d9\5v<\2\u01d8\u01d6\3\2\2" + - "\2\u01d8\u01d7\3\2\2\2\u01d9\u01db\3\2\2\2\u01da\u01d5\3\2\2\2\u01db\u01de" + - "\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de" + - "\u01dc\3\2\2\2\u01df\u01e1\78\2\2\u01e0\u01df\3\2\2\2\u01e0\u01e1\3\2" + - "\2\2\u01e1\'\3\2\2\2\u01e2\u01e3\t\2\2\2\u01e3)\3\2\2\2\u01e4\u01e5\7" + - "#\2\2\u01e5\u01e6\5\u0096L\2\u01e6+\3\2\2\2\u01e7\u01e8\7$\2\2\u01e8-" + - "\3\2\2\2\u01e9\u01ef\5\60\31\2\u01ea\u01ef\5\62\32\2\u01eb\u01ef\5\64" + - "\33\2\u01ec\u01ef\58\35\2\u01ed\u01ef\5\66\34\2\u01ee\u01e9\3\2\2\2\u01ee" + - "\u01ea\3\2\2\2\u01ee\u01eb\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ee\u01ed\3\2" + - "\2\2\u01ef/\3\2\2\2\u01f0\u01f1\7&\2\2\u01f1\61\3\2\2\2\u01f2\u01f3\7" + - "%\2\2\u01f3\63\3\2\2\2\u01f4\u01f6\7\7\2\2\u01f5\u01f7\5\u0098M\2\u01f6" + - "\u01f5\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\65\3\2\2\2\u01f8\u01f9\5\u00aa" + - "V\2\u01f9\67\3\2\2\2\u01fa\u0200\7\b\2\2\u01fb\u01fe\5d\63\2\u01fc\u01fd" + - "\7\t\2\2\u01fd\u01ff\5d\63\2\u01fe\u01fc\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff" + - "\u0201\3\2\2\2\u0200\u01fb\3\2\2\2\u0200\u0201\3\2\2\2\u02019\3\2\2\2" + - "\u0202\u0205\5<\37\2\u0203\u0205\5> \2\u0204\u0202\3\2\2\2\u0204\u0203" + - "\3\2\2\2\u0205;\3\2\2\2\u0206\u0207\7\n\2\2\u0207\u0208\5F$\2\u0208=\3" + - "\2\2\2\u0209\u0216\7\t\2\2\u020a\u020c\t\3\2\2\u020b\u020a\3\2\2\2\u020c" + - "\u020f\3\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2" + - "\2\2\u020f\u020d\3\2\2\2\u0210\u0217\5H%\2\u0211\u0213\t\3\2\2\u0212\u0211" + - "\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215\3\2\2\2\u0215" + - "\u0217\3\2\2\2\u0216\u020d\3\2\2\2\u0216\u0212\3\2\2\2\u0217\u0218\3\2" + - "\2\2\u0218\u021f\7\n\2\2\u0219\u0220\7\65\2\2\u021a\u021b\7\66\2\2\u021b" + - "\u021c\5D#\2\u021c\u021d\7\67\2\2\u021d\u0220\3\2\2\2\u021e\u0220\5D#" + - "\2\u021f\u0219\3\2\2\2\u021f\u021a\3\2\2\2\u021f\u021e\3\2\2\2\u0220?" + - "\3\2\2\2\u0221\u0224\7*\2\2\u0222\u0223\7\13\2\2\u0223\u0225\7*\2\2\u0224" + - "\u0222\3\2\2\2\u0224\u0225\3\2\2\2\u0225A\3\2\2\2\u0226\u0229\5H%\2\u0227" + - "\u0228\7\13\2\2\u0228\u022a\7*\2\2\u0229\u0227\3\2\2\2\u0229\u022a\3\2" + - "\2\2\u022aC\3\2\2\2\u022b\u0230\5@!\2\u022c\u022d\78\2\2\u022d\u022f\5" + - "@!\2\u022e\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3\2\2\2\u0230" + - "\u0231\3\2\2\2\u0231\u0234\3\2\2\2\u0232\u0230\3\2\2\2\u0233\u0235\78" + - "\2\2\u0234\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235E\3\2\2\2\u0236\u023b" + - "\5B\"\2\u0237\u0238\78\2\2\u0238\u023a\5B\"\2\u0239\u0237\3\2\2\2\u023a" + - "\u023d\3\2\2\2\u023b\u0239\3\2\2\2\u023b\u023c\3\2\2\2\u023cG\3\2\2\2" + - "\u023d\u023b\3\2\2\2\u023e\u0243\7*\2\2\u023f\u0240\7\63\2\2\u0240\u0242" + - "\7*\2\2\u0241\u023f\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243" + - "\u0244\3\2\2\2\u0244I\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\7\f\2\2" + - "\u0247\u024c\7*\2\2\u0248\u0249\78\2\2\u0249\u024b\7*\2\2\u024a\u0248" + - "\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024a\3\2\2\2\u024c\u024d\3\2\2\2\u024d" + - "K\3\2\2\2\u024e\u024c\3\2\2\2\u024f\u0250\7\r\2\2\u0250\u0255\7*\2\2\u0251" + - "\u0252\78\2\2\u0252\u0254\7*\2\2\u0253\u0251\3\2\2\2\u0254\u0257\3\2\2" + - "\2\u0255\u0253\3\2\2\2\u0255\u0256\3\2\2\2\u0256M\3\2\2\2\u0257\u0255" + - "\3\2\2\2\u0258\u0259\7\16\2\2\u0259\u025c\5d\63\2\u025a\u025b\78\2\2\u025b" + - "\u025d\5d\63\2\u025c\u025a\3\2\2\2\u025c\u025d\3\2\2\2\u025dO\3\2\2\2" + - "\u025e\u0268\5T+\2\u025f\u0268\5V,\2\u0260\u0268\5X-\2\u0261\u0268\5Z" + - ".\2\u0262\u0268\5\\/\2\u0263\u0268\5\20\t\2\u0264\u0268\5\u009cO\2\u0265" + - "\u0268\5\f\7\2\u0266\u0268\5R*\2\u0267\u025e\3\2\2\2\u0267\u025f\3\2\2" + - "\2\u0267\u0260\3\2\2\2\u0267\u0261\3\2\2\2\u0267\u0262\3\2\2\2\u0267\u0263" + - "\3\2\2\2\u0267\u0264\3\2\2\2\u0267\u0265\3\2\2\2\u0267\u0266\3\2\2\2\u0268" + - "Q\3\2\2\2\u0269\u026d\7\'\2\2\u026a\u026e\5\20\t\2\u026b\u026e\5\\/\2" + - "\u026c\u026e\5X-\2\u026d\u026a\3\2\2\2\u026d\u026b\3\2\2\2\u026d\u026c" + - "\3\2\2\2\u026eS\3\2\2\2\u026f\u0270\7\17\2\2\u0270\u0271\5d\63\2\u0271" + - "\u0272\79\2\2\u0272\u027a\5b\62\2\u0273\u0274\7\20\2\2\u0274\u0275\5d" + - "\63\2\u0275\u0276\79\2\2\u0276\u0277\5b\62\2\u0277\u0279\3\2\2\2\u0278" + - "\u0273\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2" + - "\2\2\u027b\u0280\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u027e\7\21\2\2\u027e" + - "\u027f\79\2\2\u027f\u0281\5b\62\2\u0280\u027d\3\2\2\2\u0280\u0281\3\2" + - "\2\2\u0281U\3\2\2\2\u0282\u0283\7\22\2\2\u0283\u0284\5d\63\2\u0284\u0285" + - "\79\2\2\u0285\u0289\5b\62\2\u0286\u0287\7\21\2\2\u0287\u0288\79\2\2\u0288" + - "\u028a\5b\62\2\u0289\u0286\3\2\2\2\u0289\u028a\3\2\2\2\u028aW\3\2\2\2" + - "\u028b\u028c\7\23\2\2\u028c\u028d\5\u0096L\2\u028d\u028e\7\24\2\2\u028e" + - "\u028f\5\u0098M\2\u028f\u0290\79\2\2\u0290\u0294\5b\62\2\u0291\u0292\7" + - "\21\2\2\u0292\u0293\79\2\2\u0293\u0295\5b\62\2\u0294\u0291\3\2\2\2\u0294" + - "\u0295\3\2\2\2\u0295Y\3\2\2\2\u0296\u0297\7\25\2\2\u0297\u0298\79\2\2" + - "\u0298\u02ae\5b\62\2\u0299\u029a\5`\61\2\u029a\u029b\79\2\2\u029b\u029c" + - "\5b\62\2\u029c\u029e\3\2\2\2\u029d\u0299\3\2\2\2\u029e\u029f\3\2\2\2\u029f" + - "\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a4\3\2\2\2\u02a1\u02a2\7\21" + - "\2\2\u02a2\u02a3\79\2\2\u02a3\u02a5\5b\62\2\u02a4\u02a1\3\2\2\2\u02a4" + - "\u02a5\3\2\2\2\u02a5\u02a9\3\2\2\2\u02a6\u02a7\7\26\2\2\u02a7\u02a8\7" + - "9\2\2\u02a8\u02aa\5b\62\2\u02a9\u02a6\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa" + - "\u02af\3\2\2\2\u02ab\u02ac\7\26\2\2\u02ac\u02ad\79\2\2\u02ad\u02af\5b" + - "\62\2\u02ae\u029d\3\2\2\2\u02ae\u02ab\3\2\2\2\u02af[\3\2\2\2\u02b0\u02b1" + - "\7\27\2\2\u02b1\u02b6\5^\60\2\u02b2\u02b3\78\2\2\u02b3\u02b5\5^\60\2\u02b4" + - "\u02b2\3\2\2\2\u02b5\u02b8\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2" + - "\2\2\u02b7\u02b9\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02ba\79\2\2\u02ba" + - "\u02bb\5b\62\2\u02bb]\3\2\2\2\u02bc\u02bf\5d\63\2\u02bd\u02be\7\13\2\2" + - "\u02be\u02c0\5x=\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0_\3\2" + - "\2\2\u02c1\u02c7\7\30\2\2\u02c2\u02c5\5d\63\2\u02c3\u02c4\7\13\2\2\u02c4" + - "\u02c6\7*\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c8\3\2" + - "\2\2\u02c7\u02c2\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8a\3\2\2\2\u02c9\u02d4" + - "\5\36\20\2\u02ca\u02cb\7)\2\2\u02cb\u02cd\7d\2\2\u02cc\u02ce\5\34\17\2" + - "\u02cd\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0" + - "\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\7e\2\2\u02d2\u02d4\3\2\2\2\u02d3" + - "\u02c9\3\2\2\2\u02d3\u02ca\3\2\2\2\u02d4c\3\2\2\2\u02d5\u02db\5l\67\2" + - "\u02d6\u02d7\7\17\2\2\u02d7\u02d8\5l\67\2\u02d8\u02d9\7\21\2\2\u02d9\u02da" + - "\5d\63\2\u02da\u02dc\3\2\2\2\u02db\u02d6\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc" + - "\u02df\3\2\2\2\u02dd\u02df\5h\65\2\u02de\u02d5\3\2\2\2\u02de\u02dd\3\2" + - "\2\2\u02dfe\3\2\2\2\u02e0\u02e3\5l\67\2\u02e1\u02e3\5j\66\2\u02e2\u02e0" + - "\3\2\2\2\u02e2\u02e1\3\2\2\2\u02e3g\3\2\2\2\u02e4\u02e6\7\31\2\2\u02e5" + - "\u02e7\5\30\r\2\u02e6\u02e5\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\3" + - "\2\2\2\u02e8\u02e9\79\2\2\u02e9\u02ea\5d\63\2\u02eai\3\2\2\2\u02eb\u02ed" + - "\7\31\2\2\u02ec\u02ee\5\30\r\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee\3\2\2\2" + - "\u02ee\u02ef\3\2\2\2\u02ef\u02f0\79\2\2\u02f0\u02f1\5f\64\2\u02f1k\3\2" + - "\2\2\u02f2\u02f7\5n8\2\u02f3\u02f4\7\32\2\2\u02f4\u02f6\5n8\2\u02f5\u02f3" + - "\3\2\2\2\u02f6\u02f9\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8" + - "m\3\2\2\2\u02f9\u02f7\3\2\2\2\u02fa\u02ff\5p9\2\u02fb\u02fc\7\33\2\2\u02fc" + - "\u02fe\5p9\2\u02fd\u02fb\3\2\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2" + - "\2\u02ff\u0300\3\2\2\2\u0300o\3\2\2\2\u0301\u02ff\3\2\2\2\u0302\u0303" + - "\7\34\2\2\u0303\u0306\5p9\2\u0304\u0306\5r:\2\u0305\u0302\3\2\2\2\u0305" + - "\u0304\3\2\2\2\u0306q\3\2\2\2\u0307\u030d\5x=\2\u0308\u0309\5t;\2\u0309" + - "\u030a\5x=\2\u030a\u030c\3\2\2\2\u030b\u0308\3\2\2\2\u030c\u030f\3\2\2" + - "\2\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030es\3\2\2\2\u030f\u030d" + - "\3\2\2\2\u0310\u031e\7L\2\2\u0311\u031e\7M\2\2\u0312\u031e\7N\2\2\u0313" + - "\u031e\7O\2\2\u0314\u031e\7P\2\2\u0315\u031e\7Q\2\2\u0316\u031e\7R\2\2" + - "\u0317\u031e\7\24\2\2\u0318\u0319\7\34\2\2\u0319\u031e\7\24\2\2\u031a" + - "\u031e\7\35\2\2\u031b\u031c\7\35\2\2\u031c\u031e\7\34\2\2\u031d\u0310" + - "\3\2\2\2\u031d\u0311\3\2\2\2\u031d\u0312\3\2\2\2\u031d\u0313\3\2\2\2\u031d" + - "\u0314\3\2\2\2\u031d\u0315\3\2\2\2\u031d\u0316\3\2\2\2\u031d\u0317\3\2" + - "\2\2\u031d\u0318\3\2\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031e" + - "u\3\2\2\2\u031f\u0320\7\65\2\2\u0320\u0321\5x=\2\u0321w\3\2\2\2\u0322" + - "\u0327\5z>\2\u0323\u0324\7?\2\2\u0324\u0326\5z>\2\u0325\u0323\3\2\2\2" + - "\u0326\u0329\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328y\3" + - "\2\2\2\u0329\u0327\3\2\2\2\u032a\u032f\5|?\2\u032b\u032c\7@\2\2\u032c" + - "\u032e\5|?\2\u032d\u032b\3\2\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2" + - "\2\u032f\u0330\3\2\2\2\u0330{\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0337" + - "\5~@\2\u0333\u0334\7A\2\2\u0334\u0336\5~@\2\u0335\u0333\3\2\2\2\u0336" + - "\u0339\3\2\2\2\u0337\u0335\3\2\2\2\u0337\u0338\3\2\2\2\u0338}\3\2\2\2" + - "\u0339\u0337\3\2\2\2\u033a\u033f\5\u0080A\2\u033b\u033c\t\4\2\2\u033c" + - "\u033e\5\u0080A\2\u033d\u033b\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d" + - "\3\2\2\2\u033f\u0340\3\2\2\2\u0340\177\3\2\2\2\u0341\u033f\3\2\2\2\u0342" + - "\u0347\5\u0082B\2\u0343\u0344\t\5\2\2\u0344\u0346\5\u0082B\2\u0345\u0343" + - "\3\2\2\2\u0346\u0349\3\2\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348" + - "\u0081\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034f\5\u0084C\2\u034b\u034c" + - "\t\6\2\2\u034c\u034e\5\u0084C\2\u034d\u034b\3\2\2\2\u034e\u0351\3\2\2" + - "\2\u034f\u034d\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0083\3\2\2\2\u0351\u034f" + - "\3\2\2\2\u0352\u0353\t\7\2\2\u0353\u0356\5\u0084C\2\u0354\u0356\5\u0086" + - "D\2\u0355\u0352\3\2\2\2\u0355\u0354\3\2\2\2\u0356\u0085\3\2\2\2\u0357" + - "\u035a\5\u0088E\2\u0358\u0359\7;\2\2\u0359\u035b\5\u0084C\2\u035a\u0358" + - "\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u0087\3\2\2\2\u035c\u035e\7(\2\2\u035d" + - "\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0363\5\u008a" + - "F\2\u0360\u0362\5\u008eH\2\u0361\u0360\3\2\2\2\u0362\u0365\3\2\2\2\u0363" + - "\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0089\3\2\2\2\u0365\u0363\3\2" + - "\2\2\u0366\u0369\7\66\2\2\u0367\u036a\5\u00aaV\2\u0368\u036a\5\u008cG" + - "\2\u0369\u0367\3\2\2\2\u0369\u0368\3\2\2\2\u0369\u036a\3\2\2\2\u036a\u036b" + - "\3\2\2\2\u036b\u0382\7\67\2\2\u036c\u036e\7=\2\2\u036d\u036f\5\u008cG" + - "\2\u036e\u036d\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0382" + - "\7>\2\2\u0371\u0373\7J\2\2\u0372\u0374\5\u009aN\2\u0373\u0372\3\2\2\2" + - "\u0373\u0374\3\2\2\2\u0374\u0375\3\2\2\2\u0375\u0382\7K\2\2\u0376\u0382" + - "\7*\2\2\u0377\u0382\7\4\2\2\u0378\u037a\7\3\2\2\u0379\u0378\3\2\2\2\u037a" + - "\u037b\3\2\2\2\u037b\u0379\3\2\2\2\u037b\u037c\3\2\2\2\u037c\u0382\3\2" + - "\2\2\u037d\u0382\7\64\2\2\u037e\u0382\7\36\2\2\u037f\u0382\7\37\2\2\u0380" + - "\u0382\7 \2\2\u0381\u0366\3\2\2\2\u0381\u036c\3\2\2\2\u0381\u0371\3\2" + - "\2\2\u0381\u0376\3\2\2\2\u0381\u0377\3\2\2\2\u0381\u0379\3\2\2\2\u0381" + - "\u037d\3\2\2\2\u0381\u037e\3\2\2\2\u0381\u037f\3\2\2\2\u0381\u0380\3\2" + - "\2\2\u0382\u008b\3\2\2\2\u0383\u0386\5d\63\2\u0384\u0386\5v<\2\u0385\u0383" + - "\3\2\2\2\u0385\u0384\3\2\2\2\u0386\u0395\3\2\2\2\u0387\u0396\5\u00a4S" + - "\2\u0388\u038b\78\2\2\u0389\u038c\5d\63\2\u038a\u038c\5v<\2\u038b\u0389" + - "\3\2\2\2\u038b\u038a\3\2\2\2\u038c\u038e\3\2\2\2\u038d\u0388\3\2\2\2\u038e" + - "\u0391\3\2\2\2\u038f\u038d\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0393\3\2" + - "\2\2\u0391\u038f\3\2\2\2\u0392\u0394\78\2\2\u0393\u0392\3\2\2\2\u0393" + - "\u0394\3\2\2\2\u0394\u0396\3\2\2\2\u0395\u0387\3\2\2\2\u0395\u038f\3\2" + - "\2\2\u0396\u008d\3\2\2\2\u0397\u0399\7\66\2\2\u0398\u039a\5\u009eP\2\u0399" + - "\u0398\3\2\2\2\u0399\u039a\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u03a3\7\67" + - "\2\2\u039c\u039d\7=\2\2\u039d\u039e\5\u0090I\2\u039e\u039f\7>\2\2\u039f" + - "\u03a3\3\2\2\2\u03a0\u03a1\7\63\2\2\u03a1\u03a3\7*\2\2\u03a2\u0397\3\2" + - "\2\2\u03a2\u039c\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a3\u008f\3\2\2\2\u03a4" + - "\u03a9\5\u0092J\2\u03a5\u03a6\78\2\2\u03a6\u03a8\5\u0092J\2\u03a7\u03a5" + - "\3\2\2\2\u03a8\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa" + - "\u03ad\3\2\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ae\78\2\2\u03ad\u03ac\3\2" + - "\2\2\u03ad\u03ae\3\2\2\2\u03ae\u0091\3\2\2\2\u03af\u03bb\5d\63\2\u03b0" + - "\u03b2\5d\63\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\3\2" + - "\2\2\u03b3\u03b5\79\2\2\u03b4\u03b6\5d\63\2\u03b5\u03b4\3\2\2\2\u03b5" + - "\u03b6\3\2\2\2\u03b6\u03b8\3\2\2\2\u03b7\u03b9\5\u0094K\2\u03b8\u03b7" + - "\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03af\3\2\2\2\u03ba" + - "\u03b1\3\2\2\2\u03bb\u0093\3\2\2\2\u03bc\u03be\79\2\2\u03bd\u03bf\5d\63" + - "\2\u03be\u03bd\3\2\2\2\u03be\u03bf\3\2\2\2\u03bf\u0095\3\2\2\2\u03c0\u03c3" + - "\5x=\2\u03c1\u03c3\5v<\2\u03c2\u03c0\3\2\2\2\u03c2\u03c1\3\2\2\2\u03c3" + - "\u03cb\3\2\2\2\u03c4\u03c7\78\2\2\u03c5\u03c8\5x=\2\u03c6\u03c8\5v<\2" + - "\u03c7\u03c5\3\2\2\2\u03c7\u03c6\3\2\2\2\u03c8\u03ca\3\2\2\2\u03c9\u03c4" + - "\3\2\2\2\u03ca\u03cd\3\2\2\2\u03cb\u03c9\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc" + - "\u03cf\3\2\2\2\u03cd\u03cb\3\2\2\2\u03ce\u03d0\78\2\2\u03cf\u03ce\3\2" + - "\2\2\u03cf\u03d0\3\2\2\2\u03d0\u0097\3\2\2\2\u03d1\u03d6\5d\63\2\u03d2" + - "\u03d3\78\2\2\u03d3\u03d5\5d\63\2\u03d4\u03d2\3\2\2\2\u03d5\u03d8\3\2" + - "\2\2\u03d6\u03d4\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03da\3\2\2\2\u03d8" + - "\u03d6\3\2\2\2\u03d9\u03db\78\2\2\u03da\u03d9\3\2\2\2\u03da\u03db\3\2" + - "\2\2\u03db\u0099\3\2\2\2\u03dc\u03dd\5d\63\2\u03dd\u03de\79\2\2\u03de" + - "\u03df\5d\63\2\u03df\u03e3\3\2\2\2\u03e0\u03e1\7;\2\2\u03e1\u03e3\5x=" + - "\2\u03e2\u03dc\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e3\u03f6\3\2\2\2\u03e4\u03f7" + - "\5\u00a4S\2\u03e5\u03ec\78\2\2\u03e6\u03e7\5d\63\2\u03e7\u03e8\79\2\2" + - "\u03e8\u03e9\5d\63\2\u03e9\u03ed\3\2\2\2\u03ea\u03eb\7;\2\2\u03eb\u03ed" + - "\5x=\2\u03ec\u03e6\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ed\u03ef\3\2\2\2\u03ee" + - "\u03e5\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0\u03ee\3\2\2\2\u03f0\u03f1\3\2" + - "\2\2\u03f1\u03f4\3\2\2\2\u03f2\u03f0\3\2\2\2\u03f3\u03f5\78\2\2\u03f4" + - "\u03f3\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03e4\3\2" + - "\2\2\u03f6\u03f0\3\2\2\2\u03f7\u040d\3\2\2\2\u03f8\u03fb\5d\63\2\u03f9" + - "\u03fb\5v<\2\u03fa\u03f8\3\2\2\2\u03fa\u03f9\3\2\2\2\u03fb\u040a\3\2\2" + - "\2\u03fc\u040b\5\u00a4S\2\u03fd\u0400\78\2\2\u03fe\u0401\5d\63\2\u03ff" + - "\u0401\5v<\2\u0400\u03fe\3\2\2\2\u0400\u03ff\3\2\2\2\u0401\u0403\3\2\2" + - "\2\u0402\u03fd\3\2\2\2\u0403\u0406\3\2\2\2\u0404\u0402\3\2\2\2\u0404\u0405" + - "\3\2\2\2\u0405\u0408\3\2\2\2\u0406\u0404\3\2\2\2\u0407\u0409\78\2\2\u0408" + - "\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040b\3\2\2\2\u040a\u03fc\3\2" + - "\2\2\u040a\u0404\3\2\2\2\u040b\u040d\3\2\2\2\u040c\u03e2\3\2\2\2\u040c" + - "\u03fa\3\2\2\2\u040d\u009b\3\2\2\2\u040e\u040f\7!\2\2\u040f\u0415\7*\2" + - "\2\u0410\u0412\7\66\2\2\u0411\u0413\5\u009eP\2\u0412\u0411\3\2\2\2\u0412" + - "\u0413\3\2\2\2\u0413\u0414\3\2\2\2\u0414\u0416\7\67\2\2\u0415\u0410\3" + - "\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u0418\79\2\2\u0418" + - "\u0419\5b\62\2\u0419\u009d\3\2\2\2\u041a\u041f\5\u00a0Q\2\u041b\u041c" + - "\78\2\2\u041c\u041e\5\u00a0Q\2\u041d\u041b\3\2\2\2\u041e\u0421\3\2\2\2" + - "\u041f\u041d\3\2\2\2\u041f\u0420\3\2\2\2\u0420\u0423\3\2\2\2\u0421\u041f" + - "\3\2\2\2\u0422\u0424\78\2\2\u0423\u0422\3\2\2\2\u0423\u0424\3\2\2\2\u0424" + - "\u009f\3\2\2\2\u0425\u0427\5d\63\2\u0426\u0428\5\u00a4S\2\u0427\u0426" + - "\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u0432\3\2\2\2\u0429\u042a\5d\63\2\u042a" + - "\u042b\7<\2\2\u042b\u042c\5d\63\2\u042c\u0432\3\2\2\2\u042d\u042e\7;\2" + - "\2\u042e\u0432\5d\63\2\u042f\u0430\7\65\2\2\u0430\u0432\5d\63\2\u0431" + - "\u0425\3\2\2\2\u0431\u0429\3\2\2\2\u0431\u042d\3\2\2\2\u0431\u042f\3\2" + - "\2\2\u0432\u00a1\3\2\2\2\u0433\u0436\5\u00a4S\2\u0434\u0436\5\u00a6T\2" + - "\u0435\u0433\3\2\2\2\u0435\u0434\3\2\2\2\u0436\u00a3\3\2\2\2\u0437\u0439" + - "\7\'\2\2\u0438\u0437\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u043a\3\2\2\2\u043a" + - "\u043b\7\23\2\2\u043b\u043c\5\u0096L\2\u043c\u043d\7\24\2\2\u043d\u043f" + - "\5l\67\2\u043e\u0440\5\u00a2R\2\u043f\u043e\3\2\2\2\u043f\u0440\3\2\2" + - "\2\u0440\u00a5\3\2\2\2\u0441\u0442\7\17\2\2\u0442\u0444\5f\64\2\u0443" + - "\u0445\5\u00a2R\2\u0444\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u00a7" + - "\3\2\2\2\u0446\u0447\7*\2\2\u0447\u00a9\3\2\2\2\u0448\u044a\7\"\2\2\u0449" + - "\u044b\5\u00acW\2\u044a\u0449\3\2\2\2\u044a\u044b\3\2\2\2\u044b\u00ab" + - "\3\2\2\2\u044c\u044d\7\t\2\2\u044d\u0450\5d\63\2\u044e\u0450\5\u0098M" + - "\2\u044f\u044c\3\2\2\2\u044f\u044e\3\2\2\2\u0450\u00ad\3\2\2\2\u00a8\u00b3" + - "\u00b7\u00b9\u00c2\u00cb\u00ce\u00d5\u00db\u00e5\u00ec\u00f3\u00f9\u00fd" + - "\u0103\u0109\u010d\u0114\u0116\u0118\u011d\u011f\u0121\u0125\u012b\u012f" + - "\u0136\u0138\u013a\u013f\u0141\u0146\u014b\u0151\u0155\u015b\u0161\u0165" + - "\u016c\u016e\u0170\u0175\u0177\u0179\u017d\u0183\u0187\u018e\u0190\u0192" + - "\u0197\u0199\u019f\u01a6\u01aa\u01b6\u01bd\u01c2\u01c6\u01c9\u01cf\u01d3" + - "\u01d8\u01dc\u01e0\u01ee\u01f6\u01fe\u0200\u0204\u020d\u0214\u0216\u021f" + - "\u0224\u0229\u0230\u0234\u023b\u0243\u024c\u0255\u025c\u0267\u026d\u027a" + - "\u0280\u0289\u0294\u029f\u02a4\u02a9\u02ae\u02b6\u02bf\u02c5\u02c7\u02cf" + - "\u02d3\u02db\u02de\u02e2\u02e6\u02ed\u02f7\u02ff\u0305\u030d\u031d\u0327" + - "\u032f\u0337\u033f\u0347\u034f\u0355\u035a\u035d\u0363\u0369\u036e\u0373" + - "\u037b\u0381\u0385\u038b\u038f\u0393\u0395\u0399\u03a2\u03a9\u03ad\u03b1" + - "\u03b5\u03b8\u03ba\u03be\u03c2\u03c7\u03cb\u03cf\u03d6\u03da\u03e2\u03ec" + - "\u03f0\u03f4\u03f6\u03fa\u0400\u0404\u0408\u040a\u040c\u0412\u0415\u041f" + - "\u0423\u0427\u0431\u0435\u0438\u043f\u0444\u044a\u044f"; - public static final ATN _ATN = - new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } - } -} \ No newline at end of file diff --git a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cpp/CPPTransformer.kt b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cpp/CPPTransformer.kt index 1769235..f8399f5 100644 --- a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cpp/CPPTransformer.kt +++ b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cpp/CPPTransformer.kt @@ -1,9 +1,9 @@ package jp.ac.osaka_u.sdl.nil.usecase.preprocess.cpp +import CPP14Lexer +import CPP14Parser +import CPP14ParserBaseListener import jp.ac.osaka_u.sdl.nil.NILConfig -import jp.ac.osaka_u.sdl.nil.parser.cpp.CPP14Lexer -import jp.ac.osaka_u.sdl.nil.parser.cpp.CPP14Parser -import jp.ac.osaka_u.sdl.nil.parser.cpp.CPP14ParserBaseListener import jp.ac.osaka_u.sdl.nil.usecase.preprocess.AntlrTransformer import org.antlr.v4.runtime.Parser import org.antlr.v4.runtime.ParserRuleContext diff --git a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cs/CSharpTransformer.kt b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cs/CSharpTransformer.kt index 606e521..21d3a3b 100644 --- a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cs/CSharpTransformer.kt +++ b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/cs/CSharpTransformer.kt @@ -1,9 +1,9 @@ package jp.ac.osaka_u.sdl.nil.usecase.preprocess.cs +import CSharpLexer +import CSharpParser +import CSharpParserBaseListener import jp.ac.osaka_u.sdl.nil.NILConfig -import jp.ac.osaka_u.sdl.nil.parser.cs.CSharpLexer -import jp.ac.osaka_u.sdl.nil.parser.cs.CSharpParser -import jp.ac.osaka_u.sdl.nil.parser.cs.CSharpParserBaseListener import jp.ac.osaka_u.sdl.nil.usecase.preprocess.AntlrTransformer import org.antlr.v4.runtime.Parser import org.antlr.v4.runtime.ParserRuleContext diff --git a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/kotlin/KotlinTransformer.kt b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/kotlin/KotlinTransformer.kt index 54fd297..2cf18c3 100644 --- a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/kotlin/KotlinTransformer.kt +++ b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/kotlin/KotlinTransformer.kt @@ -1,9 +1,9 @@ package jp.ac.osaka_u.sdl.nil.usecase.preprocess.kotlin +import KotlinLexer +import KotlinParser +import KotlinParserBaseListener import jp.ac.osaka_u.sdl.nil.NILConfig -import jp.ac.osaka_u.sdl.nil.parser.kotlin.KotlinLexer -import jp.ac.osaka_u.sdl.nil.parser.kotlin.KotlinParser -import jp.ac.osaka_u.sdl.nil.parser.kotlin.KotlinParserBaseListener import jp.ac.osaka_u.sdl.nil.usecase.preprocess.AntlrTransformer import org.antlr.v4.runtime.Parser import org.antlr.v4.runtime.ParserRuleContext diff --git a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/python/PythonTransformer.kt b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/python/PythonTransformer.kt index af467da..e497fd2 100644 --- a/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/python/PythonTransformer.kt +++ b/src/main/kotlin/jp/ac/osaka_u/sdl/nil/usecase/preprocess/python/PythonTransformer.kt @@ -1,11 +1,9 @@ package jp.ac.osaka_u.sdl.nil.usecase.preprocess.python +import PythonLexer +import PythonParser +import PythonParserBaseListener import jp.ac.osaka_u.sdl.nil.NILConfig -import jp.ac.osaka_u.sdl.nil.parser.cpp.CPP14Parser -import jp.ac.osaka_u.sdl.nil.parser.cpp.CPP14ParserBaseListener -import jp.ac.osaka_u.sdl.nil.parser.python.Python3BaseListener -import jp.ac.osaka_u.sdl.nil.parser.python.Python3Lexer -import jp.ac.osaka_u.sdl.nil.parser.python.Python3Parser import jp.ac.osaka_u.sdl.nil.usecase.preprocess.AntlrTransformer import org.antlr.v4.runtime.Parser import org.antlr.v4.runtime.ParserRuleContext @@ -15,17 +13,18 @@ import org.antlr.v4.runtime.tree.ParseTreeListener class PythonTransformer(config: NILConfig) : AntlrTransformer( config, - ::Python3Lexer, - ::Python3Parser + ::PythonLexer, + ::PythonParser ) { override fun createVisitor(action: (ParserRuleContext) -> Unit): ParseTreeListener = - object : Python3BaseListener() { - override fun enterFuncdef(ctx: Python3Parser.FuncdefContext) = + object : PythonParserBaseListener() { + override fun enterFunction_def(ctx: PythonParser.Function_defContext) { action(ctx) + } } override fun Parser.extractRuleContext(): ParserRuleContext = - (this as Python3Parser).file_input() + (this as PythonParser).file_input() override fun Token.isNegligible(): Boolean = this.text.run { From 289ec4ea661d5cdc76597828049509c80c1e6487 Mon Sep 17 00:00:00 2001 From: T45K Date: Sat, 4 Jan 2025 09:59:31 +0900 Subject: [PATCH 4/5] remove result files --- .gitignore | 5 +++++ clone_pairs | 1 - code_blocks | 2 -- result_5_10_70.csv | 1 - 4 files changed, 5 insertions(+), 4 deletions(-) delete mode 100644 clone_pairs delete mode 100644 code_blocks delete mode 100644 result_5_10_70.csv diff --git a/.gitignore b/.gitignore index 92782b3..3fe5962 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,8 @@ build .idea .DS_Store + +# Execution results +clone_pairs +code_blocks +result_*.csv diff --git a/clone_pairs b/clone_pairs deleted file mode 100644 index 93c12d9..0000000 --- a/clone_pairs +++ /dev/null @@ -1 +0,0 @@ -0,1 diff --git a/code_blocks b/code_blocks deleted file mode 100644 index eecdb02..0000000 --- a/code_blocks +++ /dev/null @@ -1,2 +0,0 @@ -/Users/t45k/prog/NIL/src/test/resources/examples/FizzBuzz.py,1,13 -/Users/t45k/prog/NIL/src/test/resources/examples/FizzBuzz.py,13,24 diff --git a/result_5_10_70.csv b/result_5_10_70.csv deleted file mode 100644 index f77c657..0000000 --- a/result_5_10_70.csv +++ /dev/null @@ -1 +0,0 @@ -examples,FizzBuzz.py,1,13,examples,FizzBuzz.py,13,24 From b0fc88939cddf572dc969913c40f6932e2b73eee Mon Sep 17 00:00:00 2001 From: T45K Date: Sun, 12 Jan 2025 12:27:37 +0900 Subject: [PATCH 5/5] update test --- src/test/kotlin/jp/ac/osaka_u/sdl/nil/NILMainTest.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/kotlin/jp/ac/osaka_u/sdl/nil/NILMainTest.kt b/src/test/kotlin/jp/ac/osaka_u/sdl/nil/NILMainTest.kt index 4021eec..aa8b021 100644 --- a/src/test/kotlin/jp/ac/osaka_u/sdl/nil/NILMainTest.kt +++ b/src/test/kotlin/jp/ac/osaka_u/sdl/nil/NILMainTest.kt @@ -63,7 +63,7 @@ internal class NILMainTest { val outputFile = File(config.outputFileName) val result = listOf( - "examples,FizzBuzz.py,1,11,examples,FizzBuzz.py,13,23", + "examples,FizzBuzz.py,1,13,examples,FizzBuzz.py,13,24", "" )